# Coding tools

Coding agents that let you choose where their model requests go can run on Nymbot. Each one needs a base URL, a key and a model id; this page gives the exact settings for each.

## Before you start

You need an API key, made in the app's **API** menu (see [API keys](https://nymbot.ai/docs/api/#keys)). Each tool speaks one of the API's three formats, and that decides its base URL:

| Tool | Format | Base URL |
| --- | --- | --- |
| Claude Code | [Anthropic Messages](https://nymbot.ai/docs/api-chat/#messages) | `https://nymbot.ai/api` |
| Codex CLI | [Responses](https://nymbot.ai/docs/api-chat/#responses) | `https://nymbot.ai/api/v1` |
| Cline, Kilo Code, Roo Code, Continue | [Chat Completions](https://nymbot.ai/docs/api-chat/#chat-completions) | `https://nymbot.ai/api/v1` |

Model ids come from [the model list](https://nymbot.ai/docs/api-chat/#models), `GET https://nymbot.ai/api/v1/models`, which needs no key. The examples below use `anthropic/claude-sonnet-5` and, for a model from another maker, `moonshotai/kimi-k3`. Check that the model you pick is still listed.

- **Pick a model that can call tools.** These agents read files, edit them and run commands by calling tools, on every step. Use a model whose entry has `capabilities.tools` set to `true`. `nymbot/auto` refuses any request with tools (`400` `unsupported_tool`), so it does not work with any of them.
- **Copy the model's limits into the tool.** Most tools ask for a context window and a maximum output. Take them from `context_length` and `max_output_tokens` in the model list. A tool that asks for more output than the model allows is not refused; the request is lowered to the model's maximum.
- **Steps arrive whole.** A request with tools runs in one piece and is then sent back as a stream, with keep-alive pings while the model works. Streaming works in every tool below, but each step appears at once rather than word by word.

> **Give each tool its own key**
>
> Make a separate key for each tool, with a daily cap. A coding agent makes many model calls for one task, each carrying the conversation so far, so a single task can cost far more than a chat message. A cap on the key is the simplest way to know the most a tool can spend, and revoking it stops that tool alone.

## Claude Code

Claude Code talks to Nymbot through its gateway settings. Set these in the shell you start it from:

Shell

```
export ANTHROPIC_BASE_URL=https://nymbot.ai/api
export ANTHROPIC_AUTH_TOKEN=sk-nymbot-...
export ANTHROPIC_DEFAULT_OPUS_MODEL=anthropic/claude-opus-5
export ANTHROPIC_DEFAULT_SONNET_MODEL=anthropic/claude-sonnet-5
export ANTHROPIC_DEFAULT_HAIKU_MODEL=anthropic/claude-haiku-4.5
claude
```

- The base URL is exactly `https://nymbot.ai/api`: no `/v1` and no slash at the end, since Claude Code adds `/v1/messages` itself.
- The key goes in `ANTHROPIC_AUTH_TOKEN`, which Claude Code sends as `Authorization: Bearer`. While it is set, a saved claude.ai login is not used for these requests and your subscription's limits do not apply.
- Pin the model slots. By default Claude Code asks for Anthropic's newest model names, and Nymbot answers a Claude name only with the same or a newer version from its catalog, never an older one; a version the catalog does not carry yet returns `404`. Pointing `opus`, `sonnet` and `haiku` at catalog ids avoids that. If you use the `fable` alias, set `ANTHROPIC_DEFAULT_FABLE_MODEL` the same way.
- Pinning the Haiku slot also moves Claude Code's background work, such as session titles, to that cheaper model. Without it, that work runs on your main model.

Start Claude Code and run `/status`. The **Status** tab should show an `Anthropic base URL` line with `https://nymbot.ai/api` and an `Auth token` line naming `ANTHROPIC_AUTH_TOKEN`.

To keep the settings for every session, put them in the `env` block of `~/.claude/settings.json` (`%USERPROFILE%\.claude\settings.json` on Windows) instead. Never put the key in a project's `.claude/settings.json`, which is committed with the project.

settings.json

```
{
  "env": {
    "ANTHROPIC_BASE_URL": "https://nymbot.ai/api",
    "ANTHROPIC_AUTH_TOKEN": "sk-nymbot-...",
    "ANTHROPIC_DEFAULT_OPUS_MODEL": "anthropic/claude-opus-5",
    "ANTHROPIC_DEFAULT_SONNET_MODEL": "anthropic/claude-sonnet-5",
    "ANTHROPIC_DEFAULT_HAIKU_MODEL": "anthropic/claude-haiku-4.5"
  }
}
```

A few more settings are worth knowing:

- **Output length.** Set `CLAUDE_CODE_MAX_OUTPUT_TOKENS` to the model's `max_output_tokens`, so Claude Code plans its replies for the limit the model really has.
- **The model picker.** With `CLAUDE_CODE_ENABLE_GATEWAY_MODEL_DISCOVERY=1`, Claude Code reads Nymbot's model list at startup and adds the Claude models in it to `/model`.
- **Leave the advisor off.** Claude Code's advisor is a tool that runs on Anthropic's own servers, which Nymbot cannot run, and a request carrying it is refused. Don't turn it on with `/advisor`, or set `CLAUDE_CODE_DISABLE_ADVISOR_TOOL=1` to remove it entirely.
- **Leave MCP tool search off.** Claude Code turns it off for a custom base URL, and Nymbot cannot take the tool references it sends, so don't set `ENABLE_TOOL_SEARCH=true`. MCP tools still work; they are loaded up front instead.

Claude Code can also run on a model that is not Claude: point the model slots at another catalog id, such as `moonshotai/kimi-k3`, and set `CLAUDE_CODE_MAX_CONTEXT_TOKENS` to that model's `context_length`, since Claude Code cannot know it. Anthropic does not support Claude Code on other models, so expect rough edges.

## Claude Code in VS Code

The VS Code extension runs the same Claude Code, but checks for credentials before it starts, so give it the settings in VS Code's own user settings. Run **Preferences: Open User Settings (JSON)** and add:

settings.json

```
{
  "claudeCode.disableLoginPrompt": true,
  "claudeCode.environmentVariables": [
    { "name": "ANTHROPIC_BASE_URL", "value": "https://nymbot.ai/api" },
    { "name": "ANTHROPIC_AUTH_TOKEN", "value": "sk-nymbot-..." },
    { "name": "ANTHROPIC_DEFAULT_OPUS_MODEL", "value": "anthropic/claude-opus-5" },
    { "name": "ANTHROPIC_DEFAULT_SONNET_MODEL", "value": "anthropic/claude-sonnet-5" },
    { "name": "ANTHROPIC_DEFAULT_HAIKU_MODEL", "value": "anthropic/claude-haiku-4.5" }
  ]
}
```

**Disable Login Prompt** stops the extension asking you to sign in to Anthropic. Everything in [Claude Code](#claude-code) above applies to the extension too; settings in `~/.claude/settings.json` reach it as well, but the extension's login check reads only its own setting.

## Codex CLI

Codex uses the Responses API. Add Nymbot as a provider in `~/.codex/config.toml`:

config.toml

```
model = "anthropic/claude-sonnet-5"
model_provider = "nymbot"
model_context_window = 1000000

[model_providers.nymbot]
name = "Nymbot"
base_url = "https://nymbot.ai/api/v1"
env_key = "NYMBOT_API_KEY"
wire_api = "responses"

[features]
multi_agent = false
```

Then set `NYMBOT_API_KEY` in your environment and run `codex`.

- **`multi_agent = false` is required.** Codex's multi-agent tools come as a group of tools that Nymbot cannot take, and while they are on every request is refused with `400` `unsupported_tool`. Nymbot takes function tools and web search only; if Codex reports `unsupported_tool`, a feature or MCP server that adds another kind of tool is on.
- **Pick a model that is not one of OpenAI's own.** For model ids it recognizes as OpenAI's, such as `openai/gpt-5.6-sol`, Codex switches to a request format Nymbot cannot read, and the request is refused. Claude, Kimi and the other catalog models work.
- `model_context_window` tells Codex the model's context size, from `context_length` in the model list; otherwise it assumes 272,000 tokens.
- Codex offers the model a web search tool, which Nymbot runs with its own [web search](https://nymbot.ai/docs/api-chat/#web-search) when the question needs it. Set `web_search = "disabled"` at the top of the file to turn it off.
- Nymbot does not store responses. Codex already sends the whole conversation each time, so nothing needs to change.

## Cline

In Cline's settings in VS Code:

1. Set **API Provider** to **OpenAI Compatible**.
2. Set **Base URL** to `https://nymbot.ai/api/v1`.
3. Paste your key into **OpenAI Compatible API Key**.
4. Pick the model under **Model ID**. Cline loads the list from Nymbot once the URL and key are in; you can also type an id such as `anthropic/claude-sonnet-5`.

Open **Model Configuration** and fill in **Context Window Size** and **Max Output Tokens** from the model list, and tick **Supports Images** if the model has `capabilities.vision`, so Cline manages its context correctly.

## Kilo Code

In the VS Code extension, open **Settings**, go to the **Providers** tab, scroll to the bottom and click **Custom provider**. Fill in:

- **Provider ID**: `nymbot`
- **Display name**: `Nymbot`
- **Provider API**: **OpenAI Compatible**
- **Base URL**: `https://nymbot.ai/api/v1`
- **API key**: your key
- **Models**: pick them from the list Kilo loads from Nymbot

Click **Submit**, and the models appear in the model picker. For the CLI, or to set a model's limits and tool support, define the provider in `~/.config/kilo/kilo.json` instead:

kilo.json

```
{
  "provider": {
    "nymbot": {
      "npm": "@ai-sdk/openai-compatible",
      "env": ["NYMBOT_API_KEY"],
      "options": {
        "baseURL": "https://nymbot.ai/api/v1"
      },
      "models": {
        "claude-sonnet-5": {
          "id": "anthropic/claude-sonnet-5",
          "name": "Claude Sonnet 5",
          "tool_call": true,
          "limit": { "context": 1000000, "output": 64000 }
        }
      }
    }
  },
  "model": "nymbot/claude-sonnet-5"
}
```

`id` is the Nymbot model id and the key above it is Kilo's own name for it, used in `"model"` as `nymbot/…`. Take `limit` from the model list; without it Kilo cannot manage the context.

## Roo Code

Roo Code was discontinued on May 15, 2026. If you still have it installed, it works with Nymbot like this: set **API Provider** to **OpenAI Compatible**, **Base URL** to `https://nymbot.ai/api/v1`, put your key in **API Key** and a model id in **Model**. Roo Code only works through tool calls, so the model must have `capabilities.tools`. Under the model configuration, set **Max Output Tokens**, **Context Window** and **Image Support** from the model list.

## Continue

Continue's final release is 2.0.0 and it is no longer maintained, but the extension and its CLI still work. Add Nymbot models to `~/.continue/config.yaml` (`%USERPROFILE%\.continue\config.yaml` on Windows):

config.yaml

```
name: My Config
version: 0.0.1
schema: v1
models:
  - name: Claude Sonnet 5 (Nymbot)
    provider: openai
    model: anthropic/claude-sonnet-5
    apiBase: https://nymbot.ai/api/v1
    apiKey: sk-nymbot-...
    roles:
      - chat
      - edit
      - apply
    capabilities:
      - tool_use
      - image_input
    defaultCompletionOptions:
      contextLength: 1000000
      maxTokens: 64000
  - name: Nymbot embeddings
    provider: openai
    model: "@cf/baai/bge-m3"
    apiBase: https://nymbot.ai/api/v1
    apiKey: sk-nymbot-...
    roles:
      - embed
```

- `capabilities` tells Continue what the model can do, since it cannot tell from a Nymbot id. `tool_use` is what Agent mode needs; leave out `image_input` for a model without `capabilities.vision`.
- The second entry uses a Nymbot [embedding model](https://nymbot.ai/docs/api-media/#embeddings) for Continue's codebase search.

## What the tools send

A coding agent sends the model whatever it works with: your instructions, the files it opens, the output of the commands it runs. Through Nymbot, all of that is an ordinary API request, with the protections and limits described in [what the API can see](https://nymbot.ai/docs/api/#privacy): it is not end-to-end encrypted, Nymbot does not store it, and the model's provider sees it.

- The tools keep their own histories on your machine, and some talk to their makers besides. Claude Code, for one, still sends its telemetry to Anthropic when it runs on Nymbot; set `CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC=1` to stop that and its other background traffic. Its WebFetch tool still checks each domain with Anthropic unless you set `skipWebFetchPreflight` to `true` in its settings.
- Keys in settings files are only as safe as the file. Keep them out of anything you commit, and read them from the environment where the tool allows it.