wafer_AI/docs/serverless/setup.md

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

# Agent Setup

> Fast open-source LLMs for Linzumi, Claude Code, Codex, Conductor, OpenClaw, Hermes Agent, Cline, Roo Code, Kilo Code, OpenHands, and other coding agent harnesses.

<Note>
  Features, model availability, rate limits, and pricing may change as we iterate. Questions? Email [emilio@wafer.ai](mailto:emilio@wafer.ai).
</Note>

**Set up with:** [Linzumi](#set-up-linzumi) · [Claude Code](#set-up-claude-code) · [Conductor](#set-up-conductor) · [Codex](#set-up-codex) · [OpenClaw](#set-up-openclaw) · [Hermes Agent](#set-up-hermes-agent) · [Cline](#set-up-cline) · [Roo Code](#set-up-roo-code) · [Kilo Code](#set-up-kilo-code) · [OpenHands](#set-up-openhands) · [LibreChat](#set-up-librechat)

Wafer builds AI that optimizes AI. We take open models and make them dramatically faster. Wafer Serverless gives you pay-as-you-go access to fast open models — including **`GLM-5.2`**, **`glm5.2-fast`**, **`GLM-5.1`**, **`Kimi-K2.6`**, and more — served at multiples of the speed of generic inference providers.

Wafer Serverless is built for [Linzumi](https://linzumi.com), [Claude Code](https://code.claude.com), [Codex](https://github.com/openai/codex), [Conductor](https://www.conductor.build/), [OpenClaw](https://openclaw.ai), [Hermes Agent](https://hermes-agent.nousresearch.com/), [Cline](https://cline.bot), [Roo Code](https://roocode.com), [Kilo Code](https://kilocode.ai), [OpenHands](https://docs.all-hands.dev/), and other agent harnesses. Wafer exposes both an OpenAI-compatible endpoint and an Anthropic-compatible Messages endpoint, so tools like Claude Code work out of the box. Linzumi also exposes Wafer directly inside its coding-job flow.

Get a Wafer Serverless API key for fast open-source models through a standard API endpoint.

> Get started: [https://app.wafer.ai/signup](https://app.wafer.ai/signup)

## Connection Details

Use your Wafer Serverless API key with these values:

|                                   |                                                                   |
| --------------------------------- | ----------------------------------------------------------------- |
| **OpenAI-compatible endpoint**    | `https://pass.wafer.ai/v1`                                        |
| **Anthropic-compatible endpoint** | `https://pass.wafer.ai/v1/messages`                               |
| **Send your API key as**          | `Authorization: Bearer <key>` (`wfr_…` Serverless keys work here) |
| **Request-scoped ZDR**            | Add `Wafer-ZDR: required` on direct API calls                     |

See [**Models**](#models) below for the `model` strings to pass on the OpenAI-compatible endpoint.

<Note>
  **Claude Code** uses the Anthropic Messages endpoint. Set `ANTHROPIC_BASE_URL=https://pass.wafer.ai` and `ANTHROPIC_API_KEY` to your Wafer key — Claude Code will hit `/v1/messages` automatically. To make sure Claude Code talks to a Wafer model, set `ANTHROPIC_DEFAULT_OPUS_MODEL`, `ANTHROPIC_DEFAULT_SONNET_MODEL`, `ANTHROPIC_DEFAULT_HAIKU_MODEL`, and `CLAUDE_CODE_SUBAGENT_MODEL` to one of the Wafer model IDs in [**Models**](#models) (e.g. `GLM-5.1`). Linzumi is built in: select **Wafer** in Linzumi's **Start coding job** screen instead of pasting an endpoint or API key. All other harnesses (OpenClaw, Cline, Roo Code, etc.) use the OpenAI-compatible endpoint at `https://pass.wafer.ai/v1`.
</Note>

For raw curl requests, request fields, and direct API usage, see [API Reference](/serverless/api-reference).

## What's Included

With a Wafer Serverless API key you get:

* Pay-as-you-go access to Wafer-hosted models, billed per token
* Access through a standard OpenAI-compatible API and an Anthropic-compatible Messages API using your Wafer API key
* Works with [Linzumi](https://linzumi.com), [Claude Code](https://code.claude.com), [Codex](https://github.com/openai/codex), [Conductor](https://www.conductor.build/), [OpenClaw](https://openclaw.ai), [Hermes Agent](https://hermes-agent.nousresearch.com/), [Cline](https://cline.bot), [Roo Code](https://roocode.com), [Kilo Code](https://kilocode.ai), [OpenHands](https://docs.all-hands.dev/), and other agent harnesses
* Reasoning-capable models support explicit thinking on/off controls in Chat Completions
* New fast models as we release them

## Models

| `model` string                | Family                   | Max context tokens | ZDR support | Reasoning      | Notes                              |
| ----------------------------- | ------------------------ | ------------------ | ----------- | -------------- | ---------------------------------- |
| `GLM-5.2`                     | Z.AI flagship            | `1048576`          | Yes         | Yes            | 1M-context general model           |
| `glm5.2-fast`                 | Z.AI fast tier           | `1048576`          | Yes         | Yes            | Low-latency GLM-5.2 tier           |
| `GLM-5.1`                     | Z.AI flagship            | `202752`           | Yes         | Yes            |                                    |
| `Kimi-K2.6`                   | Moonshot Kimi K2.6       | `262144`           | No          | Yes            | Serverless-only                    |
| `Kimi-K3`                     | Moonshot Kimi K3         | `1048576`          | Yes         | Yes            | Self-hosted                        |
| `kimi-k3-fast`                | Moonshot Kimi K3 (fast)  | `1048576`          | Yes         | Yes            | High-TPS tier of Kimi-K3           |
| `DeepSeek-V4-Flash-0731-Fast` | DeepSeek V4 Flash (fast) | `1048576`          | Yes         | Yes            | High-TPS tier of DeepSeek V4 Flash |
| `Qwen3.5-397B-A17B`           | Qwen3.5, 397B MoE        | `262144`           | No          | See models API | Serverless-only                    |

The **Max context tokens** value is the hard cap enforced by the backend — requests where prompt tokens exceed this value return a `400`. If your harness has a **Context Window Size** setting (Cline, Roo Code, Droid, etc.), set it to the exact integer above. Leave \~2–4k of headroom for the model's response when filling context.

Pass any `model` string above to any OpenAI-compatible harness configured against `https://pass.wafer.ai/v1`. Model names are **case-insensitive** — `GLM-5.1` and `glm-5.1` both work. If you pass a model name that doesn't match any available model, the API returns a `404` with the list of available models.

Call `GET https://pass.wafer.ai/v1/models` for the live catalog, capabilities, and pricing before hard-coding model-specific behavior.

For Claude Code and other Anthropic-compatible harnesses, set `ANTHROPIC_DEFAULT_*_MODEL` to one of the model IDs above. See [**Set Up Claude Code**](#set-up-claude-code).

## API Capabilities

Wafer Serverless supports request-scoped privacy enforcement and advanced completion controls:

* [Zero Data Retention](/serverless/zero-data-retention)
* [Reasoning controls](/serverless/api-reference#reasoning-controls)
* [Tokenized Completions and Constrained Decoding](/serverless/tokenized-completions)

## Getting Started

<Steps>
  <Step title="Create an account">
    Go to [app.wafer.ai/signup](https://app.wafer.ai/signup), then mint a Serverless API key from the app. No card is required to create the key.
  </Step>

  <Step title="Get your API key">
    Your API key is shown once after it is minted in the app. You can create multiple named keys per account — see [API Keys](/serverless/api-keys).
  </Step>

  <Step title="Start coding">
    Select Wafer directly inside Linzumi, or use the key in Claude Code, Codex, Conductor, OpenClaw, Cline, Roo Code, Kilo Code, Hermes Agent, OpenHands, or any other supported harness.
  </Step>
</Steps>

## Set Up Linzumi

[Linzumi](https://linzumi.com) has a built-in Wafer agent provider for coding jobs. You do not need to paste `https://pass.wafer.ai/v1`, configure `WAFER_API_KEY`, or add a custom OpenAI-compatible provider inside Linzumi.

<Steps>
  <Step title="Install Linzumi and connect a computer">
    Install the macOS app from [linzumi.com](https://linzumi.com), sign in to your workspace, and make sure your machine appears under **Computers** in the sidebar.

    Linzumi runs coding jobs on a connected computer, so pick the runner that has access to the repo you want the agent to work in.
  </Step>

  <Step title="Start a coding job">
    Click **Start coding job** in the workspace sidebar.

    In the setup screen, select the connected computer and repository folder for the job.
  </Step>

  <Step title="Select Wafer">
    Under **Agent**, choose **Wafer**. The card is labeled **Open models**.

    The setup screen shows your available Linzumi Wafer/free-token balance before you send the job.
  </Step>

  <Step title="Choose model and thinking">
    Linzumi's Wafer model picker currently includes:

    * `GLM-5.2`
    * `glm5.2-fast`
    * `GLM-5.1`
    * `Kimi K2.7 Code`
    * `Kimi K2.6`
    * `Qwen 3.5 397B`

    Use `GLM-5.2` for the default coding-agent path. The **Thinking** picker supports `default`, `Low`, `Medium`, `High`, and `XHigh`.
  </Step>

  <Step title="Set permissions and send">
    Pick approval and filesystem permissions before sending:

    * **Approval**: `On request` or `On failure`
    * **Permissions**: `Read only`, `Workspace write`, or `Full access`

    Use **Read only** for exploration, **Workspace write** for normal repo edits, and reserve **Full access** for jobs that truly need to operate outside the selected workspace.
  </Step>
</Steps>

<Note>
  Quick smoke test: start a read-only Linzumi job with Wafer selected and ask, "Please do not edit files. Confirm which agent provider/model this Linzumi job is using, then stop." If it responds in the Linzumi thread, the Wafer integration is working.
</Note>

## Set Up Claude Code

Wafer exposes an Anthropic-compatible Messages endpoint at `https://pass.wafer.ai/v1/messages`, so Claude Code can connect directly — no proxy needed.

For Claude Code, set `ANTHROPIC_BASE_URL` to `https://pass.wafer.ai`, not `https://pass.wafer.ai/v1`.

<Steps>
  <Step title="Install Claude Code">
    ```bash theme={null}
    npm install -g @anthropic-ai/claude-code
    ```
  </Step>

  <Step title="Configure Wafer as the endpoint">
    Set these environment variables in your shell profile (`~/.zshrc`, `~/.bashrc`, etc.):

    ```bash theme={null}
    export ANTHROPIC_BASE_URL=https://pass.wafer.ai
    export ANTHROPIC_API_KEY=YOUR_WAFER_API_KEY
    ```

    Or add them to `~/.claude/settings.json` for a persistent, per-user config:

    ```json theme={null}
    {
      "env": {
        "ANTHROPIC_BASE_URL": "https://pass.wafer.ai",
        "ANTHROPIC_API_KEY": "YOUR_WAFER_API_KEY"
      }
    }
    ```

    Replace `YOUR_WAFER_API_KEY` with your Wafer Serverless API key.

    <Warning>
      Do not share your API key or commit it to version control.
    </Warning>
  </Step>

  <Step title="Pin a Wafer model">
    Claude Code sends Anthropic model strings (`claude-opus-…`, `claude-sonnet-…`) by default — those don't match a Wafer model. Pin Claude Code to a Wafer model with these env vars:

    For `Qwen3.5-397B-A17B`:

    ```bash theme={null}
    export ANTHROPIC_DEFAULT_OPUS_MODEL="Qwen3.5-397B-A17B"
    export ANTHROPIC_DEFAULT_SONNET_MODEL="Qwen3.5-397B-A17B"
    export ANTHROPIC_DEFAULT_HAIKU_MODEL="Qwen3.5-397B-A17B"
    export CLAUDE_CODE_SUBAGENT_MODEL="Qwen3.5-397B-A17B"
    ```

    For `GLM-5.1`:

    ```bash theme={null}
    export ANTHROPIC_DEFAULT_OPUS_MODEL="GLM-5.1"
    export ANTHROPIC_DEFAULT_SONNET_MODEL="GLM-5.1"
    export ANTHROPIC_DEFAULT_HAIKU_MODEL="GLM-5.1"
    export CLAUDE_CODE_SUBAGENT_MODEL="GLM-5.1"
    ```

    Or in `~/.claude/settings.json`:

    ```json theme={null}
    {
      "env": {
        "ANTHROPIC_BASE_URL": "https://pass.wafer.ai",
        "ANTHROPIC_API_KEY": "YOUR_WAFER_API_KEY",
        "ANTHROPIC_DEFAULT_OPUS_MODEL": "GLM-5.1",
        "ANTHROPIC_DEFAULT_SONNET_MODEL": "GLM-5.1",
        "ANTHROPIC_DEFAULT_HAIKU_MODEL": "GLM-5.1",
        "CLAUDE_CODE_SUBAGENT_MODEL": "GLM-5.1"
      }
    }
    ```

    <Note>
      These env vars follow the same pattern as [OpenRouter's Claude Code integration](https://openrouter.ai/docs/guides/coding-agents/claude-code-integration). They override the model Claude Code sends for opus, sonnet, haiku, and subagent calls.
    </Note>
  </Step>

  <Step title="Start Claude Code">
    ```bash theme={null}
    claude
    ```

    Claude Code now routes requests through the Wafer endpoint.
  </Step>
</Steps>

## Set Up Conductor

[Conductor](https://www.conductor.build/) runs a team of parallel Claude Code agents in isolated Git worktrees on macOS. Because Conductor uses Claude Code under the hood, it picks up Wafer the same way Claude Code does — pin the model to any Wafer model ID from [**Models**](#models).

<Steps>
  <Step title="Install Conductor">
    Download the macOS app from [conductor.build](https://www.conductor.build/) and launch it.
  </Step>

  <Step title="Configure Wafer as the endpoint">
    In Conductor's **Settings → Environment** (or your shell profile, e.g. `~/.zshrc`), set:

    ```bash theme={null}
    export ANTHROPIC_BASE_URL=https://pass.wafer.ai
    export ANTHROPIC_API_KEY=YOUR_WAFER_API_KEY
    ```

    Replace `YOUR_WAFER_API_KEY` with your Wafer Serverless API key.

    <Warning>
      Do not share your API key or commit it to version control.
    </Warning>
  </Step>

  <Step title="Pin a Wafer model">
    Conductor spawns Claude Code, which sends Anthropic model strings by default — those don't match a Wafer model. Pin Claude Code (and therefore Conductor) to a Wafer model with these env vars in the same Environment section:

    For `Qwen3.5-397B-A17B`:

    ```bash theme={null}
    export ANTHROPIC_DEFAULT_OPUS_MODEL="Qwen3.5-397B-A17B"
    export ANTHROPIC_DEFAULT_SONNET_MODEL="Qwen3.5-397B-A17B"
    export ANTHROPIC_DEFAULT_HAIKU_MODEL="Qwen3.5-397B-A17B"
    export CLAUDE_CODE_SUBAGENT_MODEL="Qwen3.5-397B-A17B"
    ```

    For `GLM-5.1`:

    ```bash theme={null}
    export ANTHROPIC_DEFAULT_OPUS_MODEL="GLM-5.1"
    export ANTHROPIC_DEFAULT_SONNET_MODEL="GLM-5.1"
    export ANTHROPIC_DEFAULT_HAIKU_MODEL="GLM-5.1"
    export CLAUDE_CODE_SUBAGENT_MODEL="GLM-5.1"
    ```

    <Note>
      This follows the pattern OpenRouter documents in its [Claude Code integration guide](https://openrouter.ai/docs/guides/coding-agents/claude-code-integration). Because Conductor spawns Claude Code subprocesses, the same env vars override opus, sonnet, haiku, and subagent calls.
    </Note>
  </Step>

  <Step title="Start a run">
    Create a workspace in Conductor, pick a repo, and kick off an agent. Requests now route through Wafer.
  </Step>
</Steps>

## Set Up Codex

[Codex](https://github.com/openai/codex) speaks the **OpenAI Responses API** (`/v1/responses`). Wafer Serverless exposes a native Responses-compatible endpoint at `https://pass.wafer.ai/v1/responses`, so current Codex clients can point directly at Wafer without a local proxy.

<Steps>
  <Step title="Install Codex">
    ```bash theme={null}
    npm install -g @openai/codex
    ```

    Verify Codex picks up the Responses API (`wire_api = "responses"` is the only supported value as of `0.92.0+`):

    ```bash theme={null}
    codex --version
    ```
  </Step>

  <Step title="Verify Wafer's Responses endpoint">
    Export your Wafer Serverless key and make a direct Responses API request:

    ```bash theme={null}
    export WAFER_API_KEY=YOUR_WAFER_API_KEY

    curl -sS https://pass.wafer.ai/v1/responses \
      -H "Content-Type: application/json" \
      -H "Authorization: Bearer $WAFER_API_KEY" \
      -d '{
        "model": "GLM-5.2",
        "input": "Reply with the single word: ready."
      }'
    ```

    A `200` response with an `output` array means the Wafer Responses endpoint is healthy.
  </Step>

  <Step title="Point Codex at Wafer">
    Add a Wafer model provider to `~/.codex/config.toml`:

    ```toml theme={null}
    model = "GLM-5.2"
    model_provider = "wafer"

    [model_providers.wafer]
    name = "Wafer"
    base_url = "https://pass.wafer.ai/v1"
    env_key = "WAFER_API_KEY"
    wire_api = "responses"
    ```

    `env_key` tells Codex which env var to read for the bearer token it sends to Wafer.

    <Note>
      Switch models by changing the top-level `model = "..."` to any model ID from [**Models**](#models), such as `GLM-5.2`, `glm5.2-fast`, or `GLM-5.1`.
    </Note>
  </Step>

  <Step title="Run Codex">
    ```bash theme={null}
    export WAFER_API_KEY=YOUR_WAFER_API_KEY
    codex
    ```

    Codex now sends Responses API traffic directly to Wafer. The footer in the TUI should show the Wafer model ID, for example `GLM-5.2`.
  </Step>
</Steps>

<Note>
  Older local proxies or private Wafer deployments that do not expose `/v1/responses` still need a translation layer such as LiteLLM. The public Serverless endpoint at `pass.wafer.ai` does not.
</Note>

## Set Up OpenClaw

<Note>
  **Model string:** the examples below use `GLM-5.1`. Swap in any [**Models**](#models) ID (`Qwen3.5-397B-A17B` or `GLM-5.1`). Applies to every OpenAI-compatible setup section that follows (OpenClaw, Hermes Agent, Cline, Roo Code, Kilo Code, OpenHands, and the generic section at the bottom).
</Note>

<Steps>
  <Step title="Install OpenClaw">
    <Tabs>
      <Tab title="macOS / Linux">
        ```bash theme={null}
        curl -fsSL https://openclaw.ai/install.sh | bash
        ```
      </Tab>

      <Tab title="Windows (PowerShell)">
        ```powershell theme={null}
        iwr -useb https://openclaw.ai/install.ps1 | iex
        ```
      </Tab>
    </Tabs>
  </Step>

  <Step title="Run setup">
    ```bash theme={null}
    openclaw setup
    ```
  </Step>

  <Step title="Add Wafer as a provider">
    Replace `YOUR_WAFER_API_KEY` with your Wafer Serverless API key:

    ```bash theme={null}
    openclaw config set models.providers.wafer "$(cat <<'EOF'
    {
      "baseUrl": "https://pass.wafer.ai/v1",
      "api": "openai-completions",
      "auth": "api-key",
      "apiKey": "YOUR_WAFER_API_KEY",
      "models": [
        { "id": "Qwen3.5-397B-A17B", "name": "Qwen 3.5 397B" },
        { "id": "GLM-5.1", "name": "GLM 5.1" }
      ]
    }
    EOF
    )"
    openclaw models set wafer/GLM-5.1
    ```

    <Warning>
      Do not share your API key or commit it to version control.
    </Warning>
  </Step>

  <Step title="Test it">
    ```bash theme={null}
    openclaw agent --local --session-id wafer-test --message "Hello"
    ```
  </Step>
</Steps>

## Set Up Hermes Agent

<Steps>
  <Step title="Install Hermes Agent">
    ```bash theme={null}
    curl -fsSL https://raw.githubusercontent.com/NousResearch/hermes-agent/main/scripts/install.sh | bash
    source ~/.bashrc   # or source ~/.zshrc
    ```
  </Step>

  <Step title="Point Hermes at Wafer">
    Replace `YOUR_WAFER_API_KEY` with your Wafer Serverless API key:

    ```bash theme={null}
    hermes config set WAFER_API_KEY YOUR_WAFER_API_KEY
    hermes config set model.default glm5.2-fast
    hermes config set model.provider custom
    hermes config set model.base_url https://pass.wafer.ai/v1
    hermes config set model.api_mode chat_completions
    ```
  </Step>

  <Step title="Start a session">
    ```bash theme={null}
    hermes
    ```

    Hermes now uses `glm5.2-fast` through the Wafer endpoint by default.
  </Step>
</Steps>

## Set Up Cline

<Steps>
  <Step title="Install Cline">
    Install the [Cline extension](https://marketplace.visualstudio.com/items?itemName=saoudrizwan.claude-dev) from the VS Code marketplace, or search "Cline" in VS Code Extensions.
  </Step>

  <Step title="Configure Wafer as a provider">
    1. Open VS Code and click the **Cline** icon in the sidebar
    2. Click the **settings gear** icon in the Cline panel
    3. In the **API Provider** dropdown, select **OpenAI Compatible**
    4. Fill in these fields:

    * **Base URL**: `https://pass.wafer.ai/v1`
    * **API Key**: your Wafer API key
    * **Model ID**: `Qwen3.5-397B-A17B`

    <Warning>
      Do not include `/chat/completions` in the Base URL — Cline appends that automatically.
    </Warning>
  </Step>

  <Step title="Set model info (recommended)">
    Expand **Model Configuration** and set:

    * **Context Window Size**: `262144`
    * **Max Output Tokens**: `32768`
    * **Supports Images**: unchecked
  </Step>

  <Step title="Verify the connection">
    Send a message in the Cline panel. If Cline responds, you're connected.
  </Step>
</Steps>

## Set Up Roo Code

<Steps>
  <Step title="Install Roo Code">
    Install the [Roo Code extension](https://marketplace.visualstudio.com/items?itemName=RooVetGit.Roo-Code) from the VS Code marketplace, or search "Roo Code" in VS Code Extensions.
  </Step>

  <Step title="Configure Wafer as a provider">
    1. Open VS Code and click the **Roo Code** icon in the sidebar
    2. Click the **settings gear** icon in the Roo Code panel
    3. In the **API Provider** dropdown, select **OpenAI Compatible**
    4. Fill in these fields:

    * **Base URL**: `https://pass.wafer.ai/v1`
    * **API Key**: your Wafer API key
    * **Model ID**: `Qwen3.5-397B-A17B`
  </Step>

  <Step title="Set model info (recommended)">
    Optionally configure:

    * **Context Window Size**: `262144`
    * **Max Output Tokens**: `32768`
  </Step>

  <Step title="Start coding">
    Send a message in the Roo Code panel to confirm the connection.
  </Step>
</Steps>

## Set Up Kilo Code

<Steps>
  <Step title="Install Kilo Code">
    Install the [Kilo Code extension](https://marketplace.visualstudio.com/items?itemName=kilocode.Kilo-Code) from the VS Code marketplace, or search "Kilo Code" in VS Code Extensions.
  </Step>

  <Step title="Configure Wafer as a provider">
    1. Open Kilo Code and click the **settings gear** icon
    2. Go to the **Providers** tab
    3. Click **Custom provider** at the bottom
    4. Fill in the dialog:

    * **Provider ID**: `wafer`
    * **Display Name**: `Wafer`
    * **Base URL**: `https://pass.wafer.ai/v1`
    * **API Key**: your Wafer API key
    * **Model**: `Qwen3.5-397B-A17B`

    5. Click **Save**

    If you're on an older version of Kilo Code without the Providers tab, select **OpenAI Compatible** from the API Provider dropdown and enter the same Base URL, API key, and Model ID.
  </Step>

  <Step title="Start coding">
    Send a message in the Kilo Code panel to confirm the connection.
  </Step>
</Steps>

## Set Up OpenHands

<Steps>
  <Step title="Install OpenHands">
    Follow the [OpenHands installation guide](https://docs.all-hands.dev/). The quickest way:

    ```bash theme={null}
    docker pull docker.all-hands.dev/all-hands-ai/runtime:0.44-nikolaik
    docker run -it --rm \
      -p 3000:3000 \
      -v /var/run/docker.sock:/var/run/docker.sock \
      docker.all-hands.dev/all-hands-ai/openhands:0.44
    ```
  </Step>

  <Step title="Configure Wafer as the LLM (UI)">
    1. Open the OpenHands UI (usually at `http://localhost:3000`)
    2. Click the **settings gear** icon
    3. Click **Advanced** to expand advanced options
    4. Set these fields:

    * **Custom Model**: `openai/GLM-5.1`
    * **Base URL**: `https://pass.wafer.ai/v1`
    * **API Key**: your Wafer API key

    <Warning>
      The `openai/` prefix is required. OpenHands uses litellm under the hood, and this prefix tells it to use the OpenAI-compatible completion path.
    </Warning>
  </Step>

  <Step title="Alternative: config.toml">
    If you prefer file-based config, create or edit `config.toml` in the project root:

    ```toml theme={null}
    [llm]
    model = "openai/GLM-5.1"
    api_key = "YOUR_WAFER_API_KEY"
    base_url = "https://pass.wafer.ai/v1"
    ```
  </Step>

  <Step title="Start coding">
    Open a conversation in the OpenHands UI to confirm the connection.
  </Step>
</Steps>

## Set Up LibreChat

<Steps>
  <Step title="Install LibreChat">
    Follow the [LibreChat installation guide](https://www.librechat.ai/docs/installation). The quickest way is Docker:

    ```bash theme={null}
    git clone https://github.com/danny-avila/LibreChat.git
    cd LibreChat
    cp .env.example .env
    docker compose up -d
    ```
  </Step>

  <Step title="Add Wafer as a provider">
    Edit `librechat.yaml` in the project root and add a Wafer endpoint:

    ```yaml theme={null}
    endpoints:
      custom:
        - name: "Wafer"
          baseURL: "https://pass.wafer.ai/v1"
          apiKey: "${WAFER_API_KEY}"
          iconURL: "https://avatars.githubusercontent.com/u/213847495?s=200&v=4"
          models:
            default:
              - "Qwen3.5-397B-A17B"
              - "GLM-5.1"
            fetch: false
          titleConvo: true
          modelDisplayLabel: "Wafer"
    ```

    Set your API key in your `.env` file:

    ```bash theme={null}
    WAFER_API_KEY=YOUR_WAFER_API_KEY
    ```

    Replace `YOUR_WAFER_API_KEY` with your Wafer Serverless API key.

    <Warning>
      Do not share your API key or commit it to version control.
    </Warning>

    <Note>
      The `default` list above exposes all Wafer models in LibreChat's model picker. Drop any IDs you don't want to surface.
    </Note>
  </Step>

  <Step title="Restart and verify">
    ```bash theme={null}
    docker compose restart
    ```

    Open LibreChat in your browser, select **Wafer** from the endpoint dropdown, and send a message.
  </Step>
</Steps>

## Use Wafer with Other Harnesses

Most agent harnesses only need these settings:

**OpenAI-compatible harnesses** (Cline, Roo Code, Kilo Code, OpenClaw, OpenHands, etc.):

* **Base URL**: `https://pass.wafer.ai/v1`
* **Model**: any ID from [**Models**](#models), e.g. `GLM-5.1` or `Qwen3.5-397B-A17B`
* **Authentication**: your Wafer Serverless API key (same token in `Authorization: Bearer …` headers or in the client's API-key field — keys look like `wfr_…`)
* **Compatibility mode**: OpenAI-compatible / OpenAI API

```json theme={null}
{
  "baseUrl": "https://pass.wafer.ai/v1",
  "apiKey": "YOUR_WAFER_API_KEY",
  "model": "GLM-5.1"
}
```

Pick any `model` string from [**Models**](#models).

**Anthropic-compatible harnesses** (Claude Code, Conductor, or any tool using the Anthropic Messages API):

* **Base URL**: `https://pass.wafer.ai` (the tool appends `/v1/messages` automatically)
* **Authentication**: your Wafer API key via `ANTHROPIC_API_KEY`
* **Model**: pin a Wafer model via `ANTHROPIC_DEFAULT_*_MODEL` (the harness's default Anthropic model strings don't match a Wafer model)

```bash theme={null}
export ANTHROPIC_BASE_URL=https://pass.wafer.ai
export ANTHROPIC_API_KEY=YOUR_WAFER_API_KEY
export ANTHROPIC_DEFAULT_OPUS_MODEL="GLM-5.1"
export ANTHROPIC_DEFAULT_SONNET_MODEL="GLM-5.1"
export ANTHROPIC_DEFAULT_HAIKU_MODEL="GLM-5.1"
export CLAUDE_CODE_SUBAGENT_MODEL="GLM-5.1"
```

If the harness asks for a provider name, you can label it `Wafer`. Pass your Wafer Serverless API key wherever the harness expects an Anthropic/API key (`ANTHROPIC_API_KEY`).

## FAQ

<AccordionGroup>
  <Accordion title="What models do I get?">
    See [**Models**](#models) for the current public catalog. Call `GET https://pass.wafer.ai/v1/models` for live availability and per-model pricing.
  </Accordion>

  <Accordion title="Can I use Wafer Serverless with any model?">
    Use the [**Models**](#models) IDs with `https://pass.wafer.ai/v1`.
  </Accordion>

  <Accordion title="How do I get access?">
    Sign up at [app.wafer.ai/signup](https://app.wafer.ai/signup), then mint a Serverless key from the app.
  </Accordion>

  <Accordion title="Do I need a special model ID?">
    For OpenAI-compatible harnesses, use a `model` string from [**Models**](#models) with `https://pass.wafer.ai/v1`. Model names are **case-insensitive** for the IDs above. For Claude Code (Anthropic-compatible), pin a Wafer model via `ANTHROPIC_DEFAULT_OPUS_MODEL` / `ANTHROPIC_DEFAULT_SONNET_MODEL` / `ANTHROPIC_DEFAULT_HAIKU_MODEL` / `CLAUDE_CODE_SUBAGENT_MODEL`.
  </Accordion>

  <Accordion title="Does Linzumi need a Wafer API key or base URL?">
    No. Linzumi exposes Wafer directly in the **Start coding job** flow. Choose **Wafer** under **Agent**, pick a model, and send the job. Use `https://pass.wafer.ai/v1` and a Wafer API key only for the other OpenAI-compatible harnesses on this page.
  </Accordion>

  <Accordion title="Why does Codex need a LiteLLM proxy?">
    It doesn't for the public Serverless endpoint. Codex requires the OpenAI Responses API (`/v1/responses`), and Wafer exposes that endpoint natively at `https://pass.wafer.ai/v1/responses`. A LiteLLM proxy is only needed for older private deployments or custom gateways that do not expose `/v1/responses`.
  </Accordion>

  <Accordion title="Will more models be added?">
    Yes. We're optimizing the best coding models and adding them to the Serverless catalog.
  </Accordion>
</AccordionGroup>