Integrations

What actually changes

An integration comes down to two lines in a tool's settings: the gateway address and your key. Same client, same library, same requests, same parameter names.

The output ceiling does not change that either: on Chat Completions max_tokens or max_completion_tokens is optional, and a request stating neither is answered under the published default of 32768 output tokens. A client that never sent one does not have to start. What that looks like in a request.

The key is issued in the console and lives in an environment variable — usually KUMO_API_KEY. The tool either reads it itself or you paste the value into its settings form.

1. 1Take a keyThe keys screen in the console; the secret is shown once.
2. 2Find the provider settingA config file for some tools, a settings screen for others.
3. 3Put in the address and the keyLeave the rest of the configuration alone.
4. 4Make one test callThen find it in the console log.

A test call spends money like any other: an empty wallet answers 402 — top it up first.

Two dialects

The gateway speaks both protocols at once, and the protocol decides exactly one thing — which base URL you write down.

• OpenAI-compatible — base URL https://api.kumorouter.com/v1, ending in /v1. The client appends /chat/completions, /responses, /embeddings to it.
• Anthropic-compatible — base URL https://api.kumorouter.com, the bare origin, with no /v1. Clients of that protocol append /v1/messages themselves, so an address that already carries /v1 produces a path with v1 twice — and a 404.

That is a typical cause of a 404 from an otherwise valid key, but not the only one: an unknown model ID also produces a 404. When you are unsure which dialect a tool speaks, look at which SDK it pulls in; if the address and dialect are right and the 404 persists, check the model name against the catalog.

How the key header is written → How a model is named →

Every recipe

Below is one recipe per tool — its settings file or its settings screen, with a copy button — taken from the same source as the full connection guide, which adds the install, launch, model and thinking steps. The model in them comes from the picker, and every place a key goes reads <KUMO_TOKEN>. Each recipe also carries a prompt that lets your coding agent do the setup.

{
  "env": {
    "ANTHROPIC_BASE_URL": "https://api.kumorouter.com",
    "ANTHROPIC_AUTH_TOKEN": "<KUMO_TOKEN>",
    "ANTHROPIC_DEFAULT_OPUS_MODEL": "<model>",
    "ANTHROPIC_DEFAULT_SONNET_MODEL": "<model>",
    "ANTHROPIC_DEFAULT_HAIKU_MODEL": "<model>"
  },
  "model": "<model>"
}

Set up Claude Code on this machine to use Kumo, an AI gateway that speaks the Anthropic Messages API.
Default model: <model>.
Never print the API key back in your replies or logs. Ask before overwriting any existing file.

1. Install
Install Claude Code with the official installer. Check it with claude --version.
On macOS/Linux run:
```
curl -fsSL https://claude.ai/install.sh | bash
```
On Windows run:
```
irm https://claude.ai/install.ps1 | iex
```

2. Connect to Kumo
Save this file as your user settings. If it already exists, merge the env block and the model line into it. Claude Code sends the key as a bearer token to the Kumo address.
Write the file `~/.claude/settings.json` (macOS/Linux) or `%USERPROFILE%\.claude\settings.json` (Windows). If it already exists, back it up and merge these settings into it instead of replacing unrelated ones:
```
{
  "env": {
    "ANTHROPIC_BASE_URL": "https://api.kumorouter.com",
    "ANTHROPIC_AUTH_TOKEN": "<KUMO_TOKEN>",
    "ANTHROPIC_DEFAULT_OPUS_MODEL": "<model>",
    "ANTHROPIC_DEFAULT_SONNET_MODEL": "<model>",
    "ANTHROPIC_DEFAULT_HAIKU_MODEL": "<model>"
  },
  "model": "<model>"
}
```

3. Launch
Start Claude Code in your project folder; /status shows the address in use. If a model answers 400 about beta fields, add CLAUDE_CODE_DISABLE_EXPERIMENTAL_BETAS=1 to the env block.
Run:
```
claude
```

4. Models
Switch models with /model in a session, or start with claude --model. These models answer over the Anthropic protocol:
Run:
```
claude --model <model>
```
Models available through Kumo: <model>.

5. Thinking (optional)
Thinking is on by default. Set the effort with /effort, toggle thinking with Alt+T, or keep the choice in settings.json with alwaysThinkingEnabled and effortLevel.
Kumo accepts this setting but does not pass it to the model yet: the model reasons with its own default budget.
Run:
```
/effort high
```

Official docs: https://code.claude.com/docs/en/setup , https://code.claude.com/docs/en/llm-gateway-connect , https://code.claude.com/docs/en/llm-gateway-protocol , https://code.claude.com/docs/en/model-config , https://code.claude.com/docs/en/env-vars , https://code.claude.com/docs/en/settings

Step-by-step guides

A prompt for your agent

You do not have to do the setup by hand. There is already a coding agent on your machine — hand it the connection details and it will find the config file, back it up, show you a diff and check the result.

The platform's prompts are English by design: an agent follows an instruction most reliably in the language most of its examples were written in. They are not prose to read — they are text to copy.

Goal: connect <TOOL> on this computer to Kumo — a gateway compatible with the OpenAI and
Anthropic APIs — by changing only the provider configuration: the endpoint and the API key.
Nothing about how I use the tool should change.

Connection details:
- OpenAI-compatible base URL: https://api.kumorouter.com/v1
- Anthropic-compatible base URL: https://api.kumorouter.com
      ^ the bare origin, no /v1: Anthropic-style clients append /v1/messages themselves.
- Auth header: Authorization: Bearer <KUMO_API_KEY>
      ^ my key, read from the KUMO_API_KEY environment variable.
- Model ID to configure: <model>

Rules:
- You are running on my computer: read the real files before editing them, and never guess a
  path you have not verified exists.
- Back up every config file you touch and show me a diff BEFORE writing.
- Add Kumo alongside what I already have — do not delete other providers, profiles or keys.
- Never print my key in full into the chat, a log, or a file that is committed to git.
- If the installed version documents different key names, follow the INSTALLED version and
  tell me what was different.
- If the tool cannot be pointed at a custom endpoint, say so plainly and stop. Do not invent
  a setting.

Steps:
1. Confirm the tool is installed here and report its version.
2. Work out which dialect it speaks — OpenAI or Anthropic — and take the matching base URL.
3. Find where its model provider is configured, show me what is there now, and back it up.
4. Set the base URL, the key from the environment variable, and the model ID.
5. Verify: make one test call, then make the tool itself answer one prompt.

Done when: the tool answers a test prompt through Kumo, and the request appears in the Kumo
console on the Logs page.

Reply: list every file you changed, what you set in it, and paste the test output.

Start with Claude Code → Check your key →