Agent skill

Venice Decisions

by veniceai in veniceai/skills

Call Venice's Beta POST /decisions (and its TypeSafe-compatible alias POST /systemone) to get typed judgments instead of generated text.

MITAuto-check passedEducation

Install Venice Decisions

skills CLI
$ npx skills add veniceai/skills --skill venice-decisions -a claude-code

Project install by default; add -g for ~/.claude/skills/.

GitHub CLI
$ gh skill install veniceai/skills venice-decisions --agent claude-code

Project scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).

Manual copy
$ git clone --depth 1 https://github.com/veniceai/skills.git skills-src && mkdir -p .claude/skills && cp -r skills-src/skills/venice-decisions .claude/skills/venice-decisions && rm -rf skills-src

Use ~/.claude/skills/ instead of .claude/skills for a personal install. The folder must contain SKILL.md.

Claude Code skills documentation · loads skills from .claude/skills/

Facts

Skill name
venice-decisions
GitHub stars
144
Token cost
~4.1k tokens
SKILL.md length
1,448 words
Files
1
Skills in repo
22
Repo updated
First seen
Licence
MIT

At a glance

Call Venice's Beta POST /decisions (and its TypeSafe-compatible alias POST /systemone) to get typed judgments instead of generated text.

  • Tasks that involve Quizzes and assessments
  • SKILL.md covers Use when, Endpoints, Quick start and Request schema, plus 7 more sections
  • Calls curl; reaches api.venice.ai; needs VENICE_API_KEY
  • Tasks that involve Rate limiting

What it does

Venice Decisions is an agent skill from veniceai/skills. Call Venice's Beta POST /decisions (and its TypeSafe-compatible alias POST /systemone) to get typed judgments instead of generated text. Covers the Jev "System One" decision model (jev-latest, aliases jev-1-13-0 / typesafe-jev), the state + questions request shape, the three question/answer types (noul yes/no probability, choice with probability distribution + confidence, score on an ordered rubric), token limits (maxStateTokens / maxTotalTokens), input-token pricing, rate limits, and how upstream 422 validation…

Its SKILL.md is about 4.1k tokens, which your agent loads only when the skill is triggered. It is a single SKILL.md file with no bundled scripts.

It sits in Education, covering Quizzes and assessments and Rate limiting. The repository describes itself as: Agent Skills for the Venice.ai API. One folder per surface area, each with a SKILL.md for agent runtimes (Cursor, Claude, Codex, etc.). The licence is MIT.

When your agent uses it

  • Tasks that involve Quizzes and assessments
  • Tasks that involve Rate limiting

Example prompts

  • “System One”
  • “/venice-decisions”

Requirements

  • Python 3
  • A credential in VENICE_API_KEY

What it can do on your machine

Read from SKILL.md and the folder at commit 5eaeac5. It shows what the files ask for, not the result of running them.

  • Tool permissions

    Pre-approves nothing: there is no allowed-tools line, so your agent's usual permission prompts apply.

    From allowed-tools in the SKILL.md frontmatter.

  • Runs code

    Shell commands in SKILL.md call:

    • curl

    From the folder's file list and the shell code blocks in SKILL.md.

  • Network

    Hosts in commands or code, which the agent is likely to contact:

    • api.venice.ai

    Also links to:

    • venice.ai

    From URLs in SKILL.md, links to its own repository left out.

  • Credentials

    Names these keys or tokens, usually read from environment variables:

    • VENICE_API_KEY

    From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.

Context cost

Venice Decisions loads about 4.1k tokens when it runs. Until then it costs about 139 tokens; SKILL.md has 1,448 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it
~139
When it runs · the whole SKILL.md, loaded when a task matches
~4.1k

Estimates: characters ÷ 4, the usual rule of thumb; real counts depend on the model's tokenizer. Scripts and assets cost tokens only if the agent reads them.

Safety

Auto-check passed

The automated check found no risky patterns in SKILL.md.

Automated static check — not a guarantee. Review scripts before installing. It scans the text of SKILL.md for risky patterns (piping downloads into a shell, reading credential files, hidden Unicode, destructive commands); files beside SKILL.md are not scanned.

SKILL.md

The full file from veniceai/skills at commit 5eaeac5, republished under its MIT licence (© veniceai). 1,448 words, ~4,146 tokens.

Download SKILL.mdSave it as .claude/skills/venice-decisions/SKILL.md (or your agent's skills folder).
name
venice-decisions
description
Call Venice's Beta POST /decisions (and its TypeSafe-compatible alias POST /systemone) to get typed judgments instead of generated text. Covers the Jev "System One" decision model (jev-latest, aliases jev-1-13-0 / typesafe-jev), the state + questions request shape, the three question/answer types (noul yes/no probability, choice with probability distribution + confidence, score on an ordered rubric), token limits (maxStateTokens / maxTotalTokens), input-token pricing, rate limits, and how upstream 422 validation errors surface as 400.

Venice Decisions (Beta)

POST /api/v1/decisions evaluates a state (text or JSON) against a map of typed questions and returns one structured answer per question — probabilities, picks, and scores your code can branch on directly. It does not generate text. The only model is TypeSafe's Jev (jev-latest), a "System One" decision model.

Beta. The spec labels both routes Beta: "Request/response schemas and behavior may change without notice."

Use when

  • Routing / classifying (support tickets, intents, moderation buckets) into a closed set of options.
  • Yes/no gates where the probability itself is useful (is_urgent, requests_refund).
  • Rating something on an ordered rubric (severity, frustration, quality).
  • You want several independent judgments about the same state in one call.

Use venice-chat instead when you need prose, explanations, multi-turn conversation, tool calling, or open-ended answers.

Endpoints

MethodPathNotes
POST/api/v1/decisionsMain route (operationId: createDecision). API key or x402.
POST/api/v1/systemoneSame behavior as /decisions (createDecisionSystemOne). Mirrors TypeSafe's upstream path so TypeSafe SDKs work with a base-URL swap: TYPESAFE_BASE_URL=https://api.venice.ai/api.
GET/api/v1/models?type=decisionLists decision models with pricing and token limits.

Both POST routes accept Accept-Encoding: gzip, br.

Quick start

bash
curl https://api.venice.ai/api/v1/decisions \
  -H "Authorization: Bearer $VENICE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "jev-latest",
    "state": "My payouts have failed for three days and nobody has replied. Please help ASAP.",
    "questions": {
      "is_urgent": {
        "type": "noul",
        "instructions": "Does this message require urgent attention?"
      },
      "department": {
        "type": "choice",
        "instructions": "Which team should handle this ticket?",
        "criteria": {
          "billing": "Payments, invoices, or refunds",
          "technical": "Bugs, outages, or integrations",
          "sales": "Pricing, upgrades, or new accounts"
        }
      },
      "frustration": {
        "type": "score",
        "instructions": "How frustrated is the customer?",
        "criteria": ["Calm", "Frustrated", "Very angry"]
      }
    }
  }'

Illustrative response (values vary per request):

json
{
  "model": "jev-latest",
  "answers": {
    "is_urgent": { "type": "noul", "noul": 0.95 },
    "department": {
      "type": "choice",
      "choice": "billing",
      "probabilities": { "billing": 0.95, "technical": 0.05, "sales": 0 },
      "confidence": 0.93
    },
    "frustration": {
      "type": "score",
      "score": 1.27,
      "legend": { "0": "Calm", "1": "Frustrated", "2": "Very angry" },
      "probabilities": { "0": 0, "1": 0.73, "2": 0.27 },
      "confidence": 0.6
    }
  },
  "usage": { "input_tokens": 429, "output_tokens": 73 }
}

Request schema

Top level is strict — unknown fields are rejected with 400.

FieldTypeRequiredNotes
modelstringYesjev-latest, or an alias jev-1-13-0 / typesafe-jev. Missing/empty → 400 "model is required"; non-string → 400; unknown → 404 with a suggestion.
statestring | object | arrayYesWhat to evaluate. String must be non-empty; array must have ≥ 1 item; object is free-form JSON (not checked by Venice for emptiness). Use structured JSON for chat logs, records, or app state.
questionsobject (map)YesMap of question_id → question. At least one entry ("At least one question is required"). Answers come back under the same ids. Each question is evaluated in parallel and in isolation against the same state; question ids are not sent to the model, so put all meaning in instructions.
Question objects

Each question is strict (no extra keys) and discriminated by type. instructions on every type accepts a non-empty string, a JSON object, or a non-empty array.

typeinstructionscriteriaVenice-side limits
noulRequired. The yes/no question.Optional object { "true"?: string, "false"?: string } — what a yes (≈1) / no (≈0) means.Any other key inside criteria is silently stripped (not rejected).
choiceRequired. What to decide.Required map option_name → description | null (null = no extra detail).No minimum option count enforced by Venice; upstream may reject degenerate sets.
scoreRequired. What to rate.Required array of level descriptions, ordered lowest → highest.minItems: 2.

Any other type value is rejected with 400.

Token limits

From GET /models?type=decision (model_spec):

  • maxStateTokens: 32000 — state plus the single longest question.
  • maxTotalTokens: 64000 — state plus all questions combined.

Venice does not count tokens before forwarding; these budgets are enforced by TypeSafe. An oversized request therefore passes Venice validation and fails upstream — as a 400 carrying TypeSafe's message if TypeSafe answers 400/422, otherwise as a 500 (see Errors). The generic JSON body cap is 35 MB.

Answer types

Every answer has type. The response schema passes unknown extra fields through, and an answer whose type is not noul/choice/score is forwarded as-is (forward-compat) — branch on type and ignore what you don't recognise.

noul — yes/no probability
json
{
  "refund_requested": {
    "type": "noul",
    "instructions": "Does the customer explicitly request a refund?",
    "criteria": {
      "true": "The customer asks for money to be returned",
      "false": "The customer does not ask for money to be returned"
    }
  }
}
json
{ "refund_requested": { "type": "noul", "noul": 0.88 } }
  • noul: number in [0, 1]; ≈1 strong yes, ≈0 strong no, ≈0.5 uncertain. There is no confidence field on noul answers.
choice — pick one option
json
{
  "request_type": {
    "type": "choice",
    "instructions": "What is the customer's primary request?",
    "criteria": {
      "refund": "Return money already paid",
      "troubleshooting": "Help resolve a product problem",
      "information": "Answer a question without taking action",
      "other": null
    }
  }
}
json
{
  "request_type": {
    "type": "choice",
    "choice": "refund",
    "probabilities": { "refund": 0.9, "troubleshooting": 0.06, "information": 0.03, "other": 0.01 },
    "confidence": 0.85
  }
}
  • choice: the highest-probability option name.
  • probabilities: every option → probability in [0, 1] (sum to 1).
  • confidence: [0, 1], derived from the distribution.
  • Include an other / none option when your options may not cover every state.
score — position on an ordered rubric
json
{
  "severity": {
    "type": "score",
    "instructions": "How severe is the reported issue?",
    "criteria": [
      "Cosmetic or no material impact",
      "Workflow is impaired but a workaround exists",
      "Critical workflow is blocked with no workaround"
    ]
  }
}
json
{
  "severity": {
    "type": "score",
    "score": 1.4,
    "legend": {
      "0": "Cosmetic or no material impact",
      "1": "Workflow is impaired but a workaround exists",
      "2": "Critical workflow is blocked with no workaround"
    },
    "probabilities": { "0": 0.05, "1": 0.5, "2": 0.45 },
    "confidence": 0.55
  }
}
  • Levels are indexed from 0 in the order you gave them; legend and probabilities are keyed by the index as a string.
  • score: probability-weighted (≥ 0), so it can land between levels.
  • confidence: [0, 1], derived from the distribution.

Response

FieldTypeNotes
modelstringAlways the canonical id jev-latest, even if you sent an alias.
answersobjectOne answer per question id (shapes above).
usage.input_tokensinteger ≥ 0Tokens for state + questions. Billed.
usage.output_tokensinteger ≥ 0Tokens produced evaluating the questions. Currently priced at $0.

Headers: x-ratelimit-{limit,remaining,reset}-{requests,tokens}; Content-Encoding when compressed. The spec also lists X-Balance-Remaining for x402 callers, but the server does not currently set it — poll GET /x402/balance/{walletAddress} instead.

JavaScript / Python

No OpenAI SDK method exists for this route — use plain HTTP.

ts
const res = await fetch('https://api.venice.ai/api/v1/decisions', {
  method: 'POST',
  headers: {
    Authorization: `Bearer ${process.env.VENICE_API_KEY}`,
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
    model: 'jev-latest',
    state: { ticket: { subject: 'Duplicate charge', message: 'I was charged twice. Please refund the duplicate.' }, account: { plan: 'pro' } },
    questions: {
      covered: { type: 'noul', instructions: 'Does ticket.message request a refund for a duplicate charge?' },
      priority: { type: 'score', instructions: 'How urgent is this ticket?', criteria: ['Low', 'Medium', 'High'] },
    },
  }),
})
if (!res.ok) throw new Error(`${res.status} ${await res.text()}`)
const { answers } = await res.json()

if (answers.covered.type === 'noul' && answers.covered.noul >= 0.9) {
  // auto-approve
}
python
import os, requests

r = requests.post(
    "https://api.venice.ai/api/v1/decisions",
    headers={"Authorization": f"Bearer {os.environ['VENICE_API_KEY']}"},
    json={
        "model": "jev-latest",
        "state": "Help! My payouts have been failing for 3 days.",
        "questions": {
            "team": {
                "type": "choice",
                "instructions": "Which team should handle this?",
                "criteria": {"billing": "Payments, invoicing, refunds", "technical": "Bugs, outages, integrations"},
            }
        },
    },
    timeout=60,
)
r.raise_for_status()
team = r.json()["answers"]["team"]
route = team["choice"] if team["confidence"] >= 0.8 else "human_review"

Authentication

Both routes accept either (see venice-auth):

  • Authorization: Bearer $VENICE_API_KEY, or
  • SIGN-IN-WITH-X wallet auth for x402 (legacy X-Sign-In-With-X also accepted). Payment headers (X-PAYMENT etc.) are only accepted on /x402/top-up; sending one here → 400 PAYMENT_HEADER_NOT_ACCEPTED. See venice-x402.

With no credentials at all you get a 402 x402 discovery response. The spec's x-payment-info is mode: dynamic, USD, min 0.001 / max 10.00.

API keys whose modelPrivacy is PRIVATE_ONLY or PRIVATE_TEXT are refused (403): Jev is an anonymized (third-party) model, and PRIVATE_TEXT gates decisions as well as text and embeddings.

Pricing & limits

  • Price (live GET /models?type=decision): $0.042 per 1M input tokens (0.042 DIEM); output tokens $0. A 429-input-token request costs ≈ $0.000018. Always read model_spec.pricing for the current number.
  • Charged from usage after a successful response. If the upstream answer is malformed or missing usage, you get 500 and are not charged.
  • Balance is checked before the call; insufficient balance → 402.
  • Rate limits (per account, shared by all its keys; Jev-specific override): Paid tier 100 RPM / 1,000,000 TPM; Partner Tier 1 300 RPM / 10,000,000 TPM. One request is counted before the model runs; tokens (input + output) are metered afterwards. Check yours with GET /api_keys/rate_limits (venice-api-keys).
Show full SKILL.md (542 more words)Show less

Errors

StatusCauseFix
400model missing / empty or not a string → plain { "error": "model is required" } / "model must be a string" (checked before the schema, no issues).Send "model": "jev-latest".
400Venice schema validation failed (missing state/questions, empty questions, bad type, extra field, score with < 2 levels, missing choice criteria). Body: { error: "Invalid request parameters", details, issues }.Fix the field named in issues[].path.
400Upstream TypeSafe 400/422 — a request that passed Venice's schema but TypeSafe rejected. Venice flattens FastAPI detail into { "error": "<loc>: <msg>; …" } (up to 5 items, body. prefix stripped, echoed input never returned). If nothing is extractable: "Invalid request parameters. For assistance, please reach out to support@venice.ai".Read error — it names the field path and TypeSafe's message.
400PAYMENT_HEADER_NOT_ACCEPTEDUse SIGN-IN-WITH-X, not a payment header.
401Auth failed.Check the key / SIWX header.
402No credentials (x402 discovery); insufficient balance ("Insufficient USD or Diem balance…" for keys, structured PAYMENT_REQUIRED for x402); per-key USD/DIEM spend limit reached.API key: add credits at https://venice.ai/settings/api, or raise the key's limit (ADMIN key, PATCH /api_keys). Wallet: POST /x402/top-up (venice-x402).
403Key privacy setting forbids anonymized models; region or provider restriction; API access disabled for the account.Use a key with modelPrivacy: ALL.
404Unknown model.Send jev-latest.
400Non-JSON Content-Type → "'Content-Type' must be 'application/json'" (the spec lists 415, but the server returns 400).Content-Type: application/json.
429Venice rate limit for your account on this model; or TypeSafe capacity (upstream 429/529 → "The model is currently overloaded", with Retry-After, upstream value or 30 s); or the error-budget lockout (50 non-429 4xx responses within a 30 s window, per key + model; this route rejects a user field, so all of a key's decisions requests share one bucket).Honour Retry-After; back off with jitter.
500Any other upstream failure (non-400/422/429/529 status), the 30 s upstream timeout, or a malformed upstream answer. Not charged.Retry with backoff.
503Model marked offline.Retry later.

General retry strategy and body shapes: venice-errors.

Gotchas

  • Beta, one model. GET /models?type=decision currently returns only jev-latest; don't hard-code capabilities beyond what model_spec reports.
  • Not chat. There is no messages, temperature, max_tokens, streaming, or tools. Adding any unknown field is a 400 (strict schema).
  • Questions are isolated. One answer never becomes context for another. If question B depends on A's result, make a second request.
  • Question ids carry no meaning to the model. {"urgent": {...}} with vague instructions won't help — write complete instructions and name the fields in structured state (e.g. "Does ticket.message request a refund covered by refund_policy?").
  • Token budgets are enforced upstream, so Venice validation passes and the failure arrives from TypeSafe. Pre-trim long states yourself.
  • Every 4xx except 429 counts toward the failed-requests error budget on this route (the separate unsupported-feature budget applies only to /chat/completions and /responses), so a client looping on bad requests locks itself out for the rest of the 30 s window.
  • Probabilities vary between requests. Calibrate thresholds on your own data; confidence is not a correctness guarantee. Noul has no confidence — use distance from 0.5.
  • score keys are strings ("0", "1", …) in both legend and probabilities.
  • Branch on answer.type — unknown future answer types are passed through untouched.
  • Anonymized, not private. State is sent to TypeSafe; don't route data that requires Venice-private inference.
  • Model discovery and pricing fields: venice-models.

© veniceai, MIT. Rendered from Markdown: HTML in the file is shown as text, images as links, and headings moved down two levels. Raw file

Files

Just SKILL.md in skills/venice-decisions of veniceai/skills.

Open the folder on GitHubat commit 5eaeac5

Compare with similar skills

Venice Decisions next to the 5 skills that share the most tags, products or categories with it. Stars are the repository's; “used in” counts other GitHub owners with a copy.

Venice Decisions compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
Venice Decisions this skillveniceai/skills144—~4.1kAutomated safety check: PassMIT
DeepTutor CLIHKUDS/DeepTutor41k—~2.8kAutomated safety check: PassApache-2.0
AI Engineering Placement Quizrohitg00/ai-engineering-from-scratch67k—~2kAutomated safety check: PassMIT
Codebase to Coursezarazhangrui/codebase-to-course5.7k—~4.4kAutomated safety check: PassNone
AI Engineering Phase Quizrohitg00/ai-engineering-from-scratch67k—~2.1kAutomated safety check: PassMIT
Scholar EvaluationK-Dense-AI/claude-scientific-writer2.4k2 repos~2.9kAutomated safety check: NotesMIT

Similar skills

  • DeepTutor CLI

    HKUDS/DeepTutor

    Teaches the agent to set up and run DeepTutor from the command line: chat and capabilities, knowledge bases, partners, memory, sessions, notebooks and the server or Web app.

    41k GitHub stars~2.8k tokensUpdated 3 days ago
    EducationAuto-check passed
  • AI Engineering Placement Quiz

    rohitg00/ai-engineering-from-scratch

    Runs a 10-question quiz across five areas to place a learner in the AI Engineering from Scratch curriculum, so they skip what they already know.

    67k GitHub stars~2k tokensUpdated today
    EducationAuto-check passed
  • Codebase to Course

    zarazhangrui/codebase-to-course

    Turns a codebase into an interactive single-page HTML course for non-technical learners, with scroll modules, animated diagrams, quizzes and plain-English code translations.

    5.7k GitHub stars~4.4k tokensUpdated 6 mo ago
    EducationAuto-check passed
  • AI Engineering Phase Quiz

    rohitg00/ai-engineering-from-scratch

    Quizzes you on a completed phase of the AI Engineering from Scratch course, taking a phase number or name and mapping it to that phase's directory.

    67k GitHub stars~2.1k tokensUpdated today
    EducationAuto-check passed
  • Scholar Evaluation

    K-Dense-AI/claude-scientific-writer

    Provide qualitative-first, evidence-traceable developmental review of scholarly works and audit low-stakes research-assessment rubrics with optional local quality controls.

    2.4k GitHub starsUsed in 2 repos~2.9k tokens
    EducationAuto-check: notes
  • Evaluation

    guanyang/open-agent-hub

    This skill should be used when building agent evaluation systems: deterministic checks, regression suites, multi-dimensional rubrics, quality gates, production monitoring, baseline comparison, and…

    977 GitHub starsUsed in 2 repos~4.2k tokens
    EducationAuto-check passed

More from veniceai/skills

All 22 skills in this repo
  • Picks which Venice text model to call for a prompt based on privacy tier, input modality, capabilities and cost, and decides when to escalate from a local agent.

    144 GitHub stars~5.2k tokensUpdated 5 days ago
    Auto-check passed
  • Venice Models API

    veniceai/skills

    Documents Venice's model discovery endpoints, GET /models, /models/traits and /models/compatibility_mapping, so an agent can pick a model by capability, constraint or price.

    144 GitHub stars~4.3k tokensUpdated 5 days ago
    Auto-check passed
  • Venice API Keys

    veniceai/skills

    Manages Venice API keys through the /api_keys endpoints: create, list, update and revoke keys, set spending limits, and read rate limits.

    144 GitHub stars~3.8k tokensUpdated 5 days ago
    Auto-check passed
  • Venice API Overview

    veniceai/skills

    High-level map of the Venice.ai API: base URL, auth modes per endpoint, endpoint categories, response headers, pricing model, error shape and versioning.

    144 GitHub stars~3.5k tokensUpdated 5 days ago
    Auto-check passed
  • Venice Audio Music

    veniceai/skills

    Async music, sound-effect and long-form voice generation via Venice.

    144 GitHub stars~3.1k tokensUpdated 5 days ago
    Auto-check passed
  • Venice Audio Speech

    veniceai/skills

    Generate speech from text via POST /audio/speech, and clone a voice via POST /audio/voices.

    144 GitHub stars~3.6k tokensUpdated 5 days ago
    Auto-check passed

Categories

Questions about Venice Decisions

What does Venice Decisions do?

Call Venice's Beta POST /decisions (and its TypeSafe-compatible alias POST /systemone) to get typed judgments instead of generated text. Venice Decisions is an agent skill from veniceai/skills. Call Venice's Beta POST /decisions (and its TypeSafe-compatible alias POST /systemone) to get typed judgments instead of generated text.

When should I use Venice Decisions?

Venice Decisions fits situations like: tasks that involve Quizzes and assessments; tasks that involve Rate limiting.

How do I install Venice Decisions in Claude Code?

Run `npx skills add veniceai/skills --skill venice-decisions -a claude-code`. Or copy the skill folder (skills/venice-decisions in veniceai/skills) into .claude/skills/venice-decisions in your project. Claude Code loads it when a task matches its description.

How do I install Venice Decisions in Codex?

Run `npx skills add veniceai/skills --skill venice-decisions -a codex`. Or copy the skill folder (skills/venice-decisions in veniceai/skills) into .agents/skills/venice-decisions in your project. Codex loads it when a task matches its description.

Can I use Venice Decisions in Cursor, Gemini CLI or GitHub Copilot?

Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add veniceai/skills --skill venice-decisions -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/venice-decisions, .gemini/skills/venice-decisions, .github/skills/venice-decisions and .opencode/skills/venice-decisions in your project.

What does Venice Decisions need to run?

Going by SKILL.md and its folder, Venice Decisions needs the command-line tools its instructions call (curl) and credentials named VENICE_API_KEY. Our summary lists: Python 3; A credential in VENICE_API_KEY.

Does Venice Decisions access the network?

SKILL.md names 2 domains. In commands or code: api.venice.ai; the agent is likely to contact it when it follows the instructions. As links in the text: venice.ai. This is read from the text; nothing was executed.

Is Venice Decisions safe to install?

Our automated static check of SKILL.md found no risky patterns, such as piping downloads into a shell, reading credential files or hidden Unicode. It is not a guarantee. Review the folder before installing.

What licence does Venice Decisions use?

Venice Decisions is published under the MIT licence (the repository's licence). It allows redistribution, so the full SKILL.md is shown on this page.

How many tokens does Venice Decisions use?

About 4.1k tokens (SKILL.md is roughly 17k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full.

What are the alternatives to Venice Decisions?

Skills that share tags, products or a category with Venice Decisions: DeepTutor CLI (HKUDS/DeepTutor, 41k stars), AI Engineering Placement Quiz (rohitg00/ai-engineering-from-scratch, 67k stars), Codebase to Course (zarazhangrui/codebase-to-course, 5.7k stars) and AI Engineering Phase Quiz (rohitg00/ai-engineering-from-scratch, 67k stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Venice Decisions?

veniceai (a GitHub organization) maintains it in veniceai/skills, which has 144 GitHub stars. The repository holds 22 skills in this directory. The repository was last updated on October 5, 2026.

Source: veniceai/skills on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.