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

# Agent skills

> Install the Concentrate AI skills library so Claude Code, Cursor, OpenCode, and other agents write correct Concentrate API code from documentation-grounded context.

AI coding agents guess at API shapes they don't know. The Concentrate skills library replaces the guess with documentation-grounded context: install it once, and your agent writes Responses API calls, picks models from the live catalog, and respects data-control boundaries without you pasting docs into the chat.

Skills are contextual and load automatically. When a request matches a skill's triggers, your agent pulls in that skill and applies it; the rest of the time it stays out of the way.

<Info>
  Skills follow the open [Agent Skills](https://agentskills.io) standard, so the same library works across every agent that implements it. For agents with a plugin system, install through the plugin so skills auto-update.
</Info>

## Quick start

<Tabs>
  <Tab title="Claude Code">
    ```text theme={null}
    /plugin marketplace add concentrate-ai/skills-library
    /plugin install concentrate@concentrate
    ```

    Run both commands inside Claude Code. Confirm the install with `/plugin list`.
  </Tab>

  <Tab title="GitHub CLI">
    Install every skill in the library:

    ```bash theme={null}
    gh skill install concentrate-ai/skills-library
    ```

    Or install just one:

    ```bash theme={null}
    gh skill install concentrate-ai/skills-library concentrate-models
    ```
  </Tab>

  <Tab title="Cursor">
    Go to **Settings → Rules → Add Rule → Remote Rule (GitHub)** and enter `concentrate-ai/skills-library`.
  </Tab>

  <Tab title="OpenCode">
    ```bash theme={null}
    mkdir -p ~/.config/opencode/skills
    git clone https://github.com/concentrate-ai/skills-library.git /tmp/concentrate-skills
    cp -r /tmp/concentrate-skills/skills/* ~/.config/opencode/skills/
    rm -rf /tmp/concentrate-skills
    ```

    Copied skills don't auto-update. Re-run the commands to pick up changes.
  </Tab>
</Tabs>

Set your API key in the environment so the agent never writes a literal key into your source:

```bash theme={null}
export CONCENTRATE_API_KEY="sk-cn-v1-..."
```

## What's in the library

Six skills, each scoped to one area of the platform and grounded in the pages linked below.

| Skill                       | Covers                                                                                                              | Docs                                                       |
| --------------------------- | ------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------- |
| `concentrate-responses`     | Responses API requests, stateful turns, function tools, structured JSON, web search, SSE streaming, caching, errors | [Create response](/docs/api-reference/endpoint/create-response) |
| `concentrate-models`        | Live catalog discovery, provider prefixes, capabilities, pricing, auto routing, fallbacks                           | [List models](/docs/api-reference/endpoint/list-models)         |
| `concentrate-multimodal`    | Image inputs, base64 and URL sources, per-provider format and resolution limits                                     | [Multi-modal](/docs/api-reference/endpoint/multi-modal)         |
| `concentrate-data-controls` | Zero Data Retention, request logging, PII redaction with `redact-v1`, BYOK routing and billing                      | [ZDR](/docs/api-reference/endpoint/zero-data-retention)         |
| `concentrate-integrations`  | Client setup for Claude Code, Claude Desktop, Cursor, and OpenAI-compatible SDKs, plus gateway migrations           | [Integrations overview](/docs/integrations/overview)            |
| `concentrate-alerts`        | Spend anomalies, error spikes, entity limits, dormant keys, balance alerts, recurring reports                       | [Alerts overview](/docs/alerts/overview)                        |

## What the skills prevent

Each skill carries explicit boundaries, so the agent avoids the mistakes that are easy to make against a multi-provider gateway.

* **Wrong tool schema.** Responses function tools use top-level `name` and `parameters`. The nested Chat Completions `function` shape is rejected with a 400, and the skill keeps the agent on the correct one.
* **Doubled base paths.** Anthropic-native clients append `/v1` themselves, so they take `https://api.concentrate.ai`. Passing the `/v1` URL produces `/v1/v1/...` and 404s.
* **Stale model lists.** The catalog changes. Skills query it live instead of recalling a model table from training data.
* **Capability assumptions.** Image, PDF, tool, structured-output, and ZDR support are properties of a model *and* provider pair, never inferable from a model family name.
* **Invented endpoints.** Agents are told to use only documented surfaces rather than inventing embeddings, batch, or fine-tuning routes.

## Live model queries

`concentrate-models` ships a dependency-free Python script that reads the public catalog endpoints. It needs no API key, so an agent can explore models before you've configured anything.

```bash theme={null}
python3 <skill-path>/scripts/concentrate_models.py list --search claude
python3 <skill-path>/scripts/concentrate_models.py list --capability input.image --sort context
python3 <skill-path>/scripts/concentrate_models.py show gpt-4o
python3 <skill-path>/scripts/concentrate_models.py compare gpt-4o claude-sonnet-4-6
python3 <skill-path>/scripts/concentrate_models.py providers
```

Add `--json` when the output feeds another program.

<Tip>
  `show` reports per-provider context windows, pricing, and ZDR status for one model. That per-provider view is what makes ZDR decisions correct, since the combined [list models](/docs/api-reference/endpoint/list-models) response omits the `zdr` field.
</Tip>

## Example usage

Ask in plain language. The agent loads the matching skill and applies it.

**"Set up a Concentrate call with a weather tool."**

`concentrate-responses` loads, and the agent produces the correct Responses tool shape:

```bash theme={null}
curl https://api.concentrate.ai/v1/responses \
  -H "Authorization: Bearer $CONCENTRATE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-4o",
    "max_output_tokens": 200,
    "input": "What is the weather in Paris? Use the tool.",
    "tools": [{
      "type": "function",
      "name": "get_weather",
      "description": "Get weather for a city",
      "parameters": {
        "type": "object",
        "properties": { "city": { "type": "string" } },
        "required": ["city"]
      }
    }]
  }'
```

**"Which models support image input with the largest context?"**

`concentrate-models` loads, and the agent queries the live catalog rather than answering from memory:

```bash theme={null}
python3 <skill-path>/scripts/concentrate_models.py list --capability input.image --sort context
```

**"Can I use this model under ZDR?"**

`concentrate-data-controls` loads, and the agent inspects the specific model and provider pair, accepting only providers whose `zdr` field is an object.

## Reading the output

Responses can contain reasoning and tool-call items alongside text, so extract by item `type` rather than by array position:

```javascript theme={null}
function outputText(response) {
  return response.output
    .filter((item) => item.type === "message")
    .flatMap((item) => item.content ?? [])
    .filter((part) => part.type === "output_text")
    .map((part) => part.text)
    .join("");
}
```

The response also reports the resolved `model`, `usage`, and `cost`. Log those when routing or spend matters; the resolved model tells you which provider actually served the request.

## Repository

The library is open source at [concentrate-ai/skills-library](https://github.com/concentrate-ai/skills-library) under the MIT license. Skill instructions are grounded in these docs, so corrections here flow into agent behavior.

If a skill produces wrong or outdated guidance, open an issue on the repository or email [support@concentrate.ai](mailto:support@concentrate.ai).