> ## Documentation Index
> Fetch the complete documentation index at: https://docs.venice.ai/llms.txt
> Use this file to discover all available pages before exploring further.

# Venice Skills

> Official Venice Agent Skills that load endpoint knowledge into Claude Code, Cursor, Codex, OpenCode, Hermes, and Cline so coding agents call Venice correctly.

[Venice Skills](https://github.com/veniceai/skills) is the canonical collection of [Agent Skills](https://platform.claude.com/docs/en/agents-and-tools/agent-skills/overview) for the Venice API. Each skill is a self-contained folder with a `SKILL.md` that an LLM agent loads on demand to work correctly against a specific surface area of the API.

<Card title="GitHub: veniceai/skills" icon="github" href="https://github.com/veniceai/skills">
  19 skills covering the full Venice API. MIT licensed. Kept in sync with the public [`swagger.yaml`](/api-reference/api-spec).
</Card>

<CardGroup cols={3}>
  <Card title="19 Skills" icon="layer-group">
    One per Venice API surface area
  </Card>

  <Card title="Runtime-agnostic" icon="plug">
    Works with Claude Code, Cursor, Codex, OpenCode, Hermes, Cline, and any other Agent Skills host
  </Card>

  <Card title="Spec-synced" icon="rotate">
    Derived from Venice's OpenAPI spec, with CI checks for drift
  </Card>
</CardGroup>

## Why skills?

Without skills, your agent has to discover Venice's quirks the hard way: `venice_parameters`, model-type enums, 402 payment-required flows, video queue/retrieve lifecycle, character slugs, and so on. Skills bundle that knowledge into focused, on-demand files so the agent only loads what it needs for the current task.

Each `SKILL.md` includes:

* The endpoint(s) it covers
* Required headers, parameters, and response shapes
* A curl example plus a minimal SDK example
* A "gotchas" section with the things real integrators trip over

## Skill catalog

| Skill                        | Covers                                                                                  |
| ---------------------------- | --------------------------------------------------------------------------------------- |
| `venice-api-overview`        | Base URL, auth modes, response headers, pricing model, versioning                       |
| `venice-auth`                | Bearer API keys + Sign-In-With-X / x402 wallet authentication                           |
| `venice-chat`                | `/chat/completions` with `venice_parameters`, multimodal, tools, reasoning, streaming   |
| `venice-responses`           | `/responses`, the OpenAI-compatible Responses API (Alpha)                               |
| `venice-embeddings`          | `/embeddings` models, encoding formats, dimensions                                      |
| `venice-image-generate`      | `/image/generate`, `/images/generations`, `/image/styles`                               |
| `venice-image-edit`          | `/image/edit`, `/image/multi-edit`, `/image/upscale`, `/image/background-remove`        |
| `venice-audio-speech`        | `/audio/speech` TTS models, voices, formats, streaming                                  |
| `venice-audio-music`         | `/audio/quote`, `/audio/queue`, `/audio/retrieve`, `/audio/complete`                    |
| `venice-audio-transcription` | `/audio/transcriptions` with Whisper, Parakeet, Scribe, Wizper, xAI STT                 |
| `venice-video`               | `/video/*` generation + transcription                                                   |
| `venice-models`              | `/models`, `/models/traits`, `/models/compatibility_mapping`                            |
| `venice-characters`          | `/characters*` + `venice_parameters.character_slug`                                     |
| `venice-api-keys`            | CRUD `/api_keys`, rate limits, Web3 key generation                                      |
| `venice-billing`             | `/billing/balance`, `/billing/usage`, `/billing/usage-analytics`                        |
| `venice-x402`                | `/x402/*` wallet credits, USDC on Base or Solana                                        |
| `venice-crypto-rpc`          | `/crypto/rpc/*` JSON-RPC proxy with 1×/2×/4× pricing                                    |
| `venice-augment`             | `/augment/text-parser`, `/augment/scrape`, `/augment/search`                            |
| `venice-errors`              | Error shapes, 402 payment required, 422 content policy, 429 rate limits, retry strategy |

## Install

Each skill is just a folder with a `SKILL.md` that starts with YAML frontmatter:

```yaml theme={"system"}
---
name: venice-chat
description: When the agent should load this skill and what's in it
---
```

Drop the `skills/` folder (or any subset) into whichever path your runtime watches.

<Tabs>
  <Tab title="Claude Code">
    Project-local:

    ```bash theme={"system"}
    git clone https://github.com/veniceai/skills.git
    cp -r skills/skills/* .claude/skills/
    ```

    Or global, for every project on your machine:

    ```bash theme={"system"}
    git clone https://github.com/veniceai/skills.git ~/src/venice-skills
    ln -s ~/src/venice-skills/skills ~/.claude/skills/venice
    ```
  </Tab>

  <Tab title="Cursor">
    Project-local:

    ```bash theme={"system"}
    git clone https://github.com/veniceai/skills.git .cursor/skills-venice
    ```

    Or copy individual skills:

    ```bash theme={"system"}
    cp -r skills/venice-chat .cursor/skills/
    ```
  </Tab>

  <Tab title="Codex">
    ```bash theme={"system"}
    git clone https://github.com/veniceai/skills.git ~/src/venice-skills
    ln -s ~/src/venice-skills/skills ~/.codex/skills/venice
    ```

    For project-local installs, target `.codex/skills/` instead.
  </Tab>

  <Tab title="OpenCode">
    ```bash theme={"system"}
    git clone https://github.com/veniceai/skills.git ~/src/venice-skills
    ln -s ~/src/venice-skills/skills ~/.config/opencode/skills/venice
    ```

    OpenCode also reads `.opencode/skills/`, `.claude/skills/`, and `.agents/skills/` from the project root.
  </Tab>

  <Tab title="Hermes Agent">
    Hermes has a built-in installer for Venice skills:

    ```bash theme={"system"}
    hermes skills install veniceai/skills
    ```

    Or symlink directly:

    ```bash theme={"system"}
    git clone https://github.com/veniceai/skills.git ~/src/venice-skills
    ln -s ~/src/venice-skills/skills ~/.hermes/skills/venice
    ```
  </Tab>

  <Tab title="Cline">
    ```bash theme={"system"}
    git clone https://github.com/veniceai/skills.git .clinerules/skills-venice
    ```
  </Tab>
</Tabs>

### Path reference

| Runtime        | Project-local                                                   | Global                                        |
| -------------- | --------------------------------------------------------------- | --------------------------------------------- |
| Claude Code    | `.claude/skills/`                                               | `~/.claude/skills/`                           |
| Codex          | `.codex/skills/`                                                | `~/.codex/skills/` (or `$CODEX_HOME/skills/`) |
| OpenCode       | `.opencode/skills/` (also `.claude/skills/`, `.agents/skills/`) | `~/.config/opencode/skills/`                  |
| Hermes Agent   | `$HERMES_OPTIONAL_SKILLS_DIR`                                   | `~/.hermes/skills/`                           |
| Cursor         | `.cursor/skills/`                                               | `~/.cursor/skills/`                           |
| Cline          | `.clinerules/skills/`                                           | n/a                                           |
| Other runtimes | `.agents/skills/` (convention)                                  | `~/.agents/skills/`                           |

<Tip>
  Runtimes that define extra frontmatter fields (`version`, `platforms`, `metadata.*`, `compatibility`, …) are required by spec to ignore unknown fields, so the same skill file works everywhere without forks.
</Tip>

### As a git submodule

If you want pinned versions in your own repo:

```bash theme={"system"}
git submodule add https://github.com/veniceai/skills.git vendor/venice-skills
```

Then symlink or copy the subsets you want into your agent's skill path.

## How agents load them

The agent discovers each `SKILL.md` by its frontmatter `name` and `description`. When the user asks something that matches a skill's purpose, the agent loads that one file into context (not the whole catalog), so the prompt stays small and the answer stays accurate.

For example, an agent that needs to generate music will load `venice-audio-music` and immediately know:

* That music goes through the queue/retrieve/complete lifecycle, not a synchronous endpoint
* Which models are available and their per-minute pricing
* How to call `/audio/quote` for cost estimation first
* What the polling backoff should look like

Without the skill, the agent might try to call `/audio/speech` for music and get a useless response.

## Authoring a new skill

1. Copy `template/` to `skills/<your-skill>/`.
2. Fill in the frontmatter and body. Keep `description` concrete, since it's what an agent uses to decide when to load the skill.
3. Link related skills at the bottom for cross-navigation.
4. Open a PR against [`veniceai/skills`](https://github.com/veniceai/skills).

See the repository's `CONTRIBUTING.md` for style conventions (short first paragraph, explicit endpoint tables, curl + one SDK example, "gotchas" section, ≤ 500 lines).

## Resources

<CardGroup cols={2}>
  <Card title="GitHub" icon="github" href="https://github.com/veniceai/skills">
    Source code, contributing guide, and skill template
  </Card>

  <Card title="Venice MCP Server" icon="plug" href="/guides/integrations/venice-mcp">
    Pair skills with the official MCP server for runtime tool access
  </Card>

  <Card title="Agent Skills Spec" icon="arrow-up-right-from-square" href="https://platform.claude.com/docs/en/agents-and-tools/agent-skills/overview">
    Learn the underlying format
  </Card>

  <Card title="Venice API Spec" icon="book" href="/api-reference/api-spec">
    The OpenAPI source of truth these skills are derived from
  </Card>
</CardGroup>