AURA-1 chip design archive: docs, blog, research folders, tiny-gpu work, GDS viewer
7858a76 verified 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
Features, model availability, rate limits, and pricing may change as we iterate. Questions? Email [emilio@wafer.ai](mailto:emilio@wafer.ai).Fast open-source LLMs for Linzumi, Claude Code, Codex, Conductor, OpenClaw, Hermes Agent, Cline, Roo Code, Kilo Code, OpenHands, and other coding agent harnesses.
Set up with: Linzumi · Claude Code · Conductor · Codex · OpenClaw · Hermes Agent · Cline · Roo Code · Kilo Code · OpenHands · 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, Claude Code, Codex, Conductor, OpenClaw, Hermes Agent, Cline, Roo Code, Kilo Code, OpenHands, 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
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 below for the model strings to pass on the OpenAI-compatible endpoint.
For raw curl requests, request fields, and direct API usage, see 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, Claude Code, Codex, Conductor, OpenClaw, Hermes Agent, Cline, Roo Code, Kilo Code, OpenHands, 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.
API Capabilities
Wafer Serverless supports request-scoped privacy enforcement and advanced completion controls:
Getting Started
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. 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). 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.Set Up Linzumi
Linzumi 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.
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.
In the setup screen, select the connected computer and repository folder for the job.
The setup screen shows your available Linzumi Wafer/free-token balance before you send the job.
* `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`.
* **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.
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.
```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>
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>
Claude Code now routes requests through the Wafer endpoint.
Set Up Conductor
Conductor 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.
Download the macOS app from [conductor.build](https://www.conductor.build/) and launch it. 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>
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>
Set Up Codex
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.
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
```
```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.
```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>
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`.
Set Up OpenClaw
**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). ```bash theme={null} curl -fsSL https://openclaw.ai/install.sh | bash ``` <Tab title="Windows (PowerShell)">
```powershell theme={null}
iwr -useb https://openclaw.ai/install.ps1 | iex
```
</Tab>
</Tabs>
```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>
Set Up Hermes Agent
```bash theme={null} curl -fsSL https://raw.githubusercontent.com/NousResearch/hermes-agent/main/scripts/install.sh | bash source ~/.bashrc # or source ~/.zshrc ``` 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
```
Hermes now uses `glm5.2-fast` through the Wafer endpoint by default.
Set Up 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. 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>
* **Context Window Size**: `262144`
* **Max Output Tokens**: `32768`
* **Supports Images**: unchecked
Set Up 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. 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`
* **Context Window Size**: `262144`
* **Max Output Tokens**: `32768`
Set Up 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. 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.
Set Up 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
```
* **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>
```toml theme={null}
[llm]
model = "openai/GLM-5.1"
api_key = "YOUR_WAFER_API_KEY"
base_url = "https://pass.wafer.ai/v1"
```
Set Up 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
```
```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>
Open LibreChat in your browser, select **Wafer** from the endpoint dropdown, and send a message.
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, e.g.
GLM-5.1orQwen3.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 likewfr_…) - Compatibility mode: OpenAI-compatible / OpenAI API
{
"baseUrl": "https://pass.wafer.ai/v1",
"apiKey": "YOUR_WAFER_API_KEY",
"model": "GLM-5.1"
}
Pick any model string from 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/messagesautomatically) - 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)
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).