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

# Coding agents

> Connect OpenCode, OMP, Kilo, Cline, pi, Hermes, or OpenClaw to Pareto.

Connect your coding agent directly with your Pareto endpoint and key.

Each successful test included a real file-read tool call. Results apply to the tested versions and connection settings, not every client feature.

| Client   | Version tested | Result                                                             |
| -------- | -------------- | ------------------------------------------------------------------ |
| OpenCode | 1.18.23        | Connection and tool call passed on September 12, 2026.             |
| OMP      | 18.0.6         | Connection and tool call passed on September 12, 2026.             |
| Kilo     | 7.6.2          | Connection and tool call passed. See the context-limit note below. |
| Cline    | 3.0.61         | Passed.                                                            |
| pi       | 0.85.1         | Passed with the JSON configuration below.                          |
| Hermes   | 0.21.1         | Passed.                                                            |
| OpenClaw | 2026.9.4       | Passed with the JSON configuration below.                          |

Setting names can differ in other client versions.

## Connection values

| Setting    | Value                                |
| ---------- | ------------------------------------ |
| API format | OpenAI Chat Completions              |
| Base URL   | `https://api.paretoinference.com/v1` |
| API key    | Your Pareto API key                  |
| Model ID   | `z-ai/glm-5.3-flash`                 |

Get your key from the [Pareto dashboard](https://paretoinference.com/dashboard). Keep it outside source control. Use the base URL above, not the full `/chat/completions` URL.

## OpenCode

1. Make your Pareto key available as `PARETO_API_KEY` in the environment that starts OpenCode.
2. Merge this configuration into `~/.config/opencode/opencode.json`. Keep your existing providers and settings.

```json theme={"system"}
{
  "$schema": "https://opencode.ai/config.json",
  "model": "pareto/z-ai/glm-5.3-flash",
  "small_model": "pareto/z-ai/glm-5.3-flash",
  "provider": {
    "pareto": {
      "npm": "@ai-sdk/openai-compatible",
      "name": "Pareto Inference",
      "options": {
        "baseURL": "https://api.paretoinference.com/v1",
        "apiKey": "{env:PARETO_API_KEY}"
      },
      "models": {
        "z-ai/glm-5.3-flash": {
          "name": "GLM 5.3 Flash"
        }
      }
    }
  }
}
```

3. Run `opencode models pareto`.
4. Confirm that the command lists `pareto/z-ai/glm-5.3-flash`.
5. Start OpenCode.

In `pareto/z-ai/glm-5.3-flash`, `pareto` selects the OpenCode provider. OpenCode sends `z-ai/glm-5.3-flash` to Pareto. This configuration uses Pareto for `model` and `small_model`. See OpenCode's [custom-provider guide](https://opencode.ai/docs/providers/#custom-provider).

## OMP

OMP is the Oh My Pi coding agent. It is separate from the pi client below.

1. Make your Pareto key available as `PARETO_API_KEY` in the environment that starts OMP.
2. Merge this configuration into `~/.omp/agent/models.yml`. Keep your existing providers.

```yaml theme={"system"}
providers:
  pareto:
    baseUrl: https://api.paretoinference.com/v1
    api: openai-completions
    apiKey: PARETO_API_KEY
    authHeader: true
    models:
      - id: z-ai/glm-5.3-flash
        name: GLM 5.3 Flash (Pareto)
```

3. Run `omp models pareto`.
4. Confirm that the command lists `z-ai/glm-5.3-flash`.
5. Start OMP with the Pareto model.

```bash theme={"system"}
omp --model pareto/z-ai/glm-5.3-flash
```

The `apiKey` value names the environment variable. The `authHeader` value sends the key as a bearer token. See OMP's [provider guide](https://omp.sh/docs/providers).

## Kilo

These steps use Kilo's provider settings UI.

1. Open Kilo **Settings**.
2. Open **Providers**.
3. Select **Custom provider**.
4. Set **Provider ID** to `pareto`.
5. Set **Display name** to `Pareto`.
6. Select **OpenAI Compatible** for **Provider API**.
7. Enter the Pareto base URL and your key.
8. Add or select `z-ai/glm-5.3-flash` under **Models**.
9. Save the provider and select this model for your session.

Use **OpenAI Compatible**, not **OpenAI Responses**. See [Kilo's provider guide](https://kilo.ai/docs/ai-providers/openai-compatible).

<Note>
  In the reported Kilo test, the custom model's context and output limits resolved to `0`. This disables automatic context compaction. Successful connection does not resolve this issue. Pareto has not yet published the deployment limits needed to complete this configuration. Do not use guessed values. See [Kilo's custom-model guide](https://kilo.ai/docs/code-with-ai/agents/custom-models).
</Note>

## Cline

1. Open Cline's settings.
2. Select **OpenAI Compatible** for **API Provider**.
3. Set **Base URL** to `https://api.paretoinference.com/v1`.
4. Enter your Pareto **API Key**.
5. Set **Model** or **Model ID** to `z-ai/glm-5.3-flash`.
6. Save the settings.

Azure Identity Authentication is not needed for Pareto. See [Cline's provider guide](https://docs.cline.bot/provider-config/openai-compatible).

## pi

1. Make your Pareto key available as `PARETO_API_KEY` in the environment that starts pi.
2. Add the `pareto` provider below to `~/.pi/agent/models.json`. Keep any existing providers.

```json theme={"system"}
{
  "providers": {
    "pareto": {
      "baseUrl": "https://api.paretoinference.com/v1",
      "api": "openai-completions",
      "apiKey": "$PARETO_API_KEY",
      "models": [
        { "id": "z-ai/glm-5.3-flash", "name": "GLM 5.3 Flash (Pareto)" }
      ]
    }
  }
}
```

3. Start pi from that environment.
4. Run `/model` and select **GLM 5.3 Flash (Pareto)**.

pi reloads this file when you open `/model`. The `$` in `$PARETO_API_KEY` tells pi to read the environment variable. See [pi's custom-model guide](https://github.com/earendil-works/pi/blob/main/packages/coding-agent/docs/models.md).

## Hermes

1. Run this command in your terminal, outside an active Hermes chat:

```bash theme={"system"}
hermes model
```

2. Select **Custom endpoint (self-hosted / VLLM / etc.)**.
3. Enter `https://api.paretoinference.com/v1` as the API base URL.
4. Enter your Pareto API key.
5. Enter `z-ai/glm-5.3-flash` as the model name.
6. Choose **Chat Completions** for API compatibility, or accept **Auto-detect**. Auto-detect worked with the Pareto URL in the reported test.
7. Enter a display name, such as `Pareto`.
8. If the wizard asks for context length, use a confirmed Pareto deployment limit. Do not enter a guessed value. Pareto has not yet published this value.
9. Complete the setup and start a new Hermes session.

Use `hermes model` to add the endpoint. The `/model` command inside a chat switches between providers that are already configured. See [Hermes' custom-provider guide](https://hermes-agent.nousresearch.com/docs/integrations/providers).

## OpenClaw

1. Make `PARETO_API_KEY` available to the OpenClaw process. A background service must receive the variable in its own environment.
2. Merge this configuration into `~/.openclaw/openclaw.json`. Keep your existing providers and other settings.

```json theme={"system"}
{
  "agents": {
    "defaults": {
      "model": { "primary": "pareto/z-ai/glm-5.3-flash" }
    }
  },
  "models": {
    "mode": "merge",
    "providers": {
      "pareto": {
        "baseUrl": "https://api.paretoinference.com/v1",
        "apiKey": "${PARETO_API_KEY}",
        "api": "openai-completions",
        "models": [
          { "id": "z-ai/glm-5.3-flash", "name": "GLM 5.3 Flash (Pareto)" }
        ]
      }
    }
  }
}
```

3. Start a new session after OpenClaw loads the configuration.

The `pareto/` prefix selects the provider inside OpenClaw. The API model ID remains `z-ai/glm-5.3-flash`. Use `openai-completions` for this connection. See [OpenClaw's custom-provider guide](https://docs.openclaw.ai/concepts/model-providers/) and [configuration guide](https://docs.openclaw.ai/gateway/configuration).

## Check the connection

After each setup, send a short message and confirm that the selected model replies. Then use a test folder and ask the agent to read a small text file. Confirm that the tool runs and the agent uses its result.

A text reply alone does not verify tool calling. If either check fails, see [Troubleshooting](/errors). Send the client version and error details to your Pareto contact. Do not send your API key.

## Other API formats

Codex 0.154.0 failed the reported direct-connection test. Its custom providers use `wire_api = "responses"`, and Pareto returned HTTP 404 for `/v1/responses`.

Claude Code using `ANTHROPIC_BASE_URL` expects an Anthropic Messages-compatible endpoint. Pareto exposes OpenAI Chat Completions, so a translating gateway is required for that connection. This does not establish official Anthropic support for non-Claude models. See [Claude Code's gateway protocol](https://code.claude.com/docs/en/llm-gateway-protocol).

We do not provide a tested direct Pareto setup guide for either app.

A [router](/integrations/routers) can provide format translation if it supports the app's API. Check that specific connection before use.
