Experiential

Get started

  • Overview
  • Quickstart
  • Setup prompts
  • The core loop
  • Authentication

Guides

  • Coding agents
  • Models
  • Anthropic API
  • Errors

Billing & usage

  • Credits & billing
  • Telemetry

Reference

  • API reference
OverviewQuickstartSetup promptsThe core loopAuthenticationCoding agentsModelsAnthropic APIErrorsCredits & billingTelemetryAPI reference
Docs
Status
PreviousAuthenticationNextModels

Guides

Coding agents

Point Claude Code, Conductor, Codex, OpenCode, Cline, Cursor, or any OpenAI-compatible agent at the gateway: one base URL, one key, every model in your catalog, and all usage in one place.

Before you start

  1. Mint a key in Settings, API keys and export it: export EXPLABS_API_KEY=xpl_...
  2. Pick a model slug. GET https://api-pr-1028.preview.experientiallabs.ai/v1/models lists every slug your key can call; the snippets below use examples from the public catalog.
The export keyword is load-bearing. A plain EXPLABS_API_KEY=xpl_... line in a shell file sets a shell-local variable: echo ${EXPLABS_API_KEY:+set} prints set, yet child processes — codex, claude, anything you launch — see nothing and fail with "Missing environment variable". If you keep the key in an env file sourced from .zshrc, use the export form there too; login shells read .zprofile instead.

Every agent below works the same way: its provider configuration gets the base URL https://api-pr-1028.preview.experientiallabs.ai/v1, the key rides as Authorization: Bearer, and models are named by bare slug. Streaming is SSE on both Chat Completions and the Responses API.

Every agent below opens on a Prompt tab: paste it into that agent and it wires itself up, verifies the key, and reports what it changed. Switch to Manual setup to do it by hand. One prompt that works in any of them lives at Setup prompts.

Test in isolation first

A botched switch or a bad token must never take down the sessions you already have open. Prove the lane in a throwaway environment first, and only touch the config your real sessions read once it passes. The cheapest pre-flight for any agent is two curls — list models, then buy one tiny completion:

shell
curl --fail-with-body "https://api-pr-1028.preview.experientiallabs.ai/v1/models" \
  -H "Authorization: Bearer $EXPLABS_API_KEY"
curl --fail-with-body "https://api-pr-1028.preview.experientiallabs.ai/v1/chat/completions" \
  -H "Authorization: Bearer $EXPLABS_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"model": "qwen3.8-27b", "messages": [{"role": "user", "content": "reply with the single word: ok"}]}'

The curl smoke proves the key, not the agent. Coding agents send their full tool inventory — every MCP server and plugin tool schema — with every request, and tool schemas are exactly where gateway and provider strictness differences bite: a bare hello can pass while the first real session fails. So each agent's isolated test below runs the real client with your real tool surface and one actual tool round-trip, without writing to its real configuration — a session that completes with your tools listed is the pass criterion. Run it before you edit anything, and again whenever you rotate a key.

OpenAI Codex CLI

Codex configures custom gateways as a model_providers entry in ~/.codex/config.toml. Current Codex releases speak only the Responses API (wire_api = "responses" is the sole supported value since early 2026), which the gateway serves at /v1/responses.

Paste this into the agent. It wires itself up, then proves the key works.

prompt
I pasted this into you myself, wire THIS coding agent up to my Experiential
Labs gateway, so my model calls route through https://api-pr-1028.preview.experientiallabs.ai and show up in my usage.


Ground rules: never print my full key (first 8 characters at most), ask me
before you edit any config file or shell profile, and if you cannot do a step
(no file access, settings live in a GUI), print the exact manual steps for me
instead. Print what you're doing at each step.


1. Get my key. Use EXPLABS_API_KEY from my environment if it is set; otherwise
   ask me to paste one (I can mint it at https://pr-1028.preview.experientiallabs.ai/settings/api-keys). It looks
   like xpl_ followed by 40 hex characters.


2. Prove the key works before touching any config:
   GET https://api-pr-1028.preview.experientiallabs.ai/v1/models with header "Authorization: Bearer <key>" -> 200 and
   the model slugs I can call. Remember the list; I'll pick models from it.


3. Apply the OpenAI Codex CLI integration:
   First prove the lane in a throwaway home so my real ~/.codex (config,
   sessions, auth) stays untouched, and test with my REAL tool surface: you
   send every mcp_servers/plugin tool schema on each request, and tool schemas
   are where provider strictness bites, so a bare hello proves too little.
   Copy ~/.codex into a fresh "$(mktemp -d)", append ONLY the
   [model_providers.explabs] table below to that copy's config.toml, then run
     CODEX_HOME=<that dir> codex exec -m "<slug I pick>" \
       -c model_provider=explabs -c model_reasoning_effort=max \
       "list your available tools, then read ./README.md and reply with its
       first heading"
   Pass only if it completes with my MCP/plugin tools listed and a real tool
   use. Then add the whole block to ~/.codex/config.toml (create it if
   missing, show me the diff before writing) and tell me to start a new Codex
   session:
     model = "<slug I pick>"
     model_provider = "explabs"
     model_reasoning_effort = "max"   # reasoning models; "ultra" is rejected
     [model_providers.explabs]
     name = "Experiential Labs"
     base_url = "https://api-pr-1028.preview.experientiallabs.ai/v1"
     env_key = "EXPLABS_API_KEY"
     wire_api = "responses"
   Leave requires_openai_auth unset, and make sure EXPLABS_API_KEY is exported
   where I launch you (export KEY=..., a plain KEY=... line is invisible to
   child processes like me).


4. Verify end to end. Make one tiny completion with the surface you configured
   ("reply with the single word: ok", small max output), via your own next
   model call if you now route through the gateway, otherwise via curl with my
   key. Then tell me it landed and that I can watch every call at
   https://pr-1028.preview.experientiallabs.ai/telemetry.


5. Recap exactly what you changed (files and values, key shown as xpl_ prefix
   only) so I can undo it later.

Prove the lane in a throwaway CODEX_HOME before touching your real one. Copy your real ~/.codex into it — the test must ride your real mcp_servers and plugin tool schemas, and the copy leaves your config, sessions, and auth untouched:

shell
export EXPLABS_API_KEY=xpl_...   # export, not a plain assignment
CODEX_HOME="$(mktemp -d)"
cp -R ~/.codex/. "$CODEX_HOME"/ 2>/dev/null || true   # real config + MCP servers, copied
cat >> "$CODEX_HOME/config.toml" <<'EOF'


[model_providers.explabs]
name = "Experiential Labs"
base_url = "https://api-pr-1028.preview.experientiallabs.ai/v1"
env_key = "EXPLABS_API_KEY"
wire_api = "responses"
EOF
CODEX_HOME="$CODEX_HOME" codex -m gpt-5.6-sol \
  -c model_provider=explabs -c model_reasoning_effort=max

In that session, run one prompt that exercises tools — "list your available tools, then read ./README.md and reply with its first heading" — and pass only when it completes with your MCP and plugin tools listed. Then add the same provider table plus the model lines to ~/.codex/config.toml and start a new Codex session:

~/.codex/config.toml
model = "gpt-5.6-sol"
model_provider = "explabs"
model_reasoning_effort = "max"


[model_providers.explabs]
name = "Experiential Labs"
base_url = "https://api-pr-1028.preview.experientiallabs.ai/v1"
env_key = "EXPLABS_API_KEY"
wire_api = "responses"

Codex reads the key from the EXPLABS_API_KEY environment variable, so it must be exported (not plain-assigned) in the shell that launches it. Leave requires_openai_auth unset: setting it forces a ChatGPT login instead of your gateway key. model_reasoning_effort = "max" is the top tier and where encrypted reasoning items flow; the provider rejects ultra.

Codex continues turns with previous_response_id. The gateway honors continuation on any worker instance and retains continuations for 24 hours; an expired id returns 400 continuation_unavailable and Codex resends the conversation. store: false skips gateway retention (that response cannot be continued from); nothing is stored with the upstream provider either way. On native OpenAI routes the gateway also honors include=["reasoning.encrypted_content"] with full round-trip, reasoning.summary, and every effort the provider supports — an unsupported effort rejects with the supported set.

OpenCode

OpenCode takes a custom provider in opencode.json (per-project at the repo root, or global at ~/.config/opencode/opencode.json) using the @ai-sdk/openai-compatible package, which targets /v1/chat/completions.

Paste this into the agent. It wires itself up, then proves the key works.

prompt
I pasted this into you myself, wire THIS coding agent up to my Experiential
Labs gateway, so my model calls route through https://api-pr-1028.preview.experientiallabs.ai and show up in my usage.


Ground rules: never print my full key (first 8 characters at most), ask me
before you edit any config file or shell profile, and if you cannot do a step
(no file access, settings live in a GUI), print the exact manual steps for me
instead. Print what you're doing at each step.


1. Get my key. Use EXPLABS_API_KEY from my environment if it is set; otherwise
   ask me to paste one (I can mint it at https://pr-1028.preview.experientiallabs.ai/settings/api-keys). It looks
   like xpl_ followed by 40 hex characters.


2. Prove the key works before touching any config:
   GET https://api-pr-1028.preview.experientiallabs.ai/v1/models with header "Authorization: Bearer <key>" -> 200 and
   the model slugs I can call. Remember the list; I'll pick models from it.


3. Apply the OpenCode integration:
   Write the provider block into this project's opencode.json (or
   ~/.config/opencode/opencode.json if I prefer global, ask):
     {"provider": {"explabs": {"npm": "@ai-sdk/openai-compatible",
      "name": "Experiential Labs",
      "options": {"baseURL": "https://api-pr-1028.preview.experientiallabs.ai/v1", "apiKey": "{env:EXPLABS_API_KEY}"},
      "models": {"<slug>": {"name": "<slug>"}}}}
   Fill limit.context/limit.output and cost ({"input": $/1M, "output": $/1M},
   i.e. the catalog's *_micro_usd_per_million / 1000000) for each slug from
   GET https://api-pr-1028.preview.experientiallabs.ai/api/models/<slug> so my context window and spend display are right.


4. Verify end to end. Make one tiny completion with the surface you configured
   ("reply with the single word: ok", small max output), via your own next
   model call if you now route through the gateway, otherwise via curl with my
   key. Then tell me it landed and that I can watch every call at
   https://pr-1028.preview.experientiallabs.ai/telemetry.


5. Recap exactly what you changed (files and values, key shown as xpl_ prefix
   only) so I can undo it later.
opencode.json
{
  "$schema": "https://opencode.ai/config.json",
  "model": "explabs/gpt-5.5",
  "provider": {
    "explabs": {
      "npm": "@ai-sdk/openai-compatible",
      "name": "Experiential Labs",
      "options": {
        "baseURL": "https://api-pr-1028.preview.experientiallabs.ai/v1",
        "apiKey": "{env:EXPLABS_API_KEY}"
      },
      "models": {
        "gpt-5.5": {
          "name": "GPT-5.5",
          "limit": {
            "context": 1050000,
            "output": 128000
          },
          "cost": {
            "input": 5,
            "output": 30
          }
        }
      }
    }
  }
}

Models you list here appear in the /models picker automatically. Set limit.context and limit.outputfrom the catalog's values (GET https://api-pr-1028.preview.experientiallabs.ai/api/models/<slug>), since OpenCode cannot infer them for a custom gateway. Set costto dollars per million tokens — the catalog's input_micro_usd_per_million and output_micro_usd_per_million divided by 1,000,000 — or OpenCode shows no spend for a custom provider.

Cline (VS Code)

Cline is configured in the extension's settings UI, not a file.

Paste this into the agent. It wires itself up, then proves the key works.

prompt
I pasted this into you myself, wire THIS coding agent up to my Experiential
Labs gateway, so my model calls route through https://api-pr-1028.preview.experientiallabs.ai and show up in my usage.


Ground rules: never print my full key (first 8 characters at most), ask me
before you edit any config file or shell profile, and if you cannot do a step
(no file access, settings live in a GUI), print the exact manual steps for me
instead. Print what you're doing at each step.


1. Get my key. Use EXPLABS_API_KEY from my environment if it is set; otherwise
   ask me to paste one (I can mint it at https://pr-1028.preview.experientiallabs.ai/settings/api-keys). It looks
   like xpl_ followed by 40 hex characters.


2. Prove the key works before touching any config:
   GET https://api-pr-1028.preview.experientiallabs.ai/v1/models with header "Authorization: Bearer <key>" -> 200 and
   the model slugs I can call. Remember the list; I'll pick models from it.


3. Apply the Cline integration:
   Your settings live in the VS Code UI, so print these for me to set by hand:
   API Provider "OpenAI Compatible"; Base URL https://api-pr-1028.preview.experientiallabs.ai/v1; API Key = my key (no
   Bearer prefix); Model ID = a slug from step 2; and per-model context window /
   max output tokens from https://api-pr-1028.preview.experientiallabs.ai/api/models/<slug>.


4. Verify end to end. Make one tiny completion with the surface you configured
   ("reply with the single word: ok", small max output), via your own next
   model call if you now route through the gateway, otherwise via curl with my
   key. Then tell me it landed and that I can watch every call at
   https://pr-1028.preview.experientiallabs.ai/telemetry.


5. Recap exactly what you changed (files and values, key shown as xpl_ prefix
   only) so I can undo it later.
  1. Open Cline's settings and set API Provider to OpenAI Compatible.
  2. Base URL: https://api-pr-1028.preview.experientiallabs.ai/v1
  3. API Key: your xpl_... key (no Bearer prefix).
  4. Model ID: a slug from /v1/models, e.g. claude-opus-5.
  5. Set the model's context window and max output tokens in Cline's per-model fields from the catalog's values; Cline cannot infer them for models it does not recognize.

Cursor

Cursor is configured in its settings UI, and needs a paid Cursor plan: the Free plan serves only Auto (Cursor-hosted routing) and refuses named models, which is what custom models are. With your own key, Cursor still builds every request on its own servers and relays it to the gateway with your key attached, so calls originate from Cursor's infrastructure and land in your usage like any other traffic on that key.

Paste this into the agent. It wires itself up, then proves the key works.

prompt
I pasted this into you myself, wire THIS coding agent up to my Experiential
Labs gateway, so my model calls route through https://api-pr-1028.preview.experientiallabs.ai and show up in my usage.


Ground rules: never print my full key (first 8 characters at most), ask me
before you edit any config file or shell profile, and if you cannot do a step
(no file access, settings live in a GUI), print the exact manual steps for me
instead. Print what you're doing at each step.


1. Get my key. Use EXPLABS_API_KEY from my environment if it is set; otherwise
   ask me to paste one (I can mint it at https://pr-1028.preview.experientiallabs.ai/settings/api-keys). It looks
   like xpl_ followed by 40 hex characters.


2. Prove the key works before touching any config:
   GET https://api-pr-1028.preview.experientiallabs.ai/v1/models with header "Authorization: Bearer <key>" -> 200 and
   the model slugs I can call. Remember the list; I'll pick models from it.


3. Apply the Cursor integration:
   Your gateway settings live in the Cursor Settings UI, so print these for me
   to set by hand. First tell me the prerequisite: a paid Cursor plan (the Free
   plan serves only Auto and refuses named models, which custom models are).
   Then: in Cursor Settings -> Models -> API Keys, put my key in
   "OpenAI API Key" (no Bearer prefix), enable "Override OpenAI Base URL" and
   set it to https://api-pr-1028.preview.experientiallabs.ai/v1. Add each slug I pick as a custom model
   name in the models list; custom models ride the override in OpenAI format,
   so any catalog slug works. Warn me plainly: Cursor relays requests through
   its own servers, Tab autocomplete stays on Cursor's models, and if a chat
   answers 400 invalid_parameter naming temperature or top_p, that model pins
   its sampling (the Claude 5 family pins temperature to 1) — pick a
   different slug.


4. Verify end to end. Make one tiny completion with the surface you configured
   ("reply with the single word: ok", small max output), via your own next
   model call if you now route through the gateway, otherwise via curl with my
   key. Then tell me it landed and that I can watch every call at
   https://pr-1028.preview.experientiallabs.ai/telemetry.


5. Recap exactly what you changed (files and values, key shown as xpl_ prefix
   only) so I can undo it later.
  1. Open Cursor Settings, Models, API Keys.
  2. Put your xpl_... key in OpenAI API Key (no Bearer prefix).
  3. Enable Override OpenAI Base URL and set it to https://api-pr-1028.preview.experientiallabs.ai/v1.
  4. Add each slug you want as a custom model name in the models list, e.g. claude-opus-5. Custom models ride the override in OpenAI format, so any catalog slug works.
Tab autocomplete and Cursor's own hosted models stay on Cursor's backend regardless of the override; the gateway carries the chat and agent panel. If a chat answers 400 invalid_parameter naming temperature or top_p, that model pins its sampling (the Claude 5 family pins temperature to 1) and Cursor sent a value outside the pin — pick a different slug.

Any other OpenAI-compatible tool

Tools built on the official OpenAI SDKs (and most terminal agents, including Blackbox and Grok Build) honor the standard environment pair; nothing else changes:

Paste this into the agent. It wires itself up, then proves the key works.

prompt
I pasted this into you myself, wire THIS coding agent up to my Experiential
Labs gateway, so my model calls route through https://api-pr-1028.preview.experientiallabs.ai and show up in my usage.


Ground rules: never print my full key (first 8 characters at most), ask me
before you edit any config file or shell profile, and if you cannot do a step
(no file access, settings live in a GUI), print the exact manual steps for me
instead. Print what you're doing at each step.


1. Get my key. Use EXPLABS_API_KEY from my environment if it is set; otherwise
   ask me to paste one (I can mint it at https://pr-1028.preview.experientiallabs.ai/settings/api-keys). It looks
   like xpl_ followed by 40 hex characters.


2. Prove the key works before touching any config:
   GET https://api-pr-1028.preview.experientiallabs.ai/v1/models with header "Authorization: Bearer <key>" -> 200 and
   the model slugs I can call. Remember the list; I'll pick models from it.


3. Apply the Any other OpenAI-compatible tool integration:
   Export OPENAI_BASE_URL="https://api-pr-1028.preview.experientiallabs.ai/v1" and OPENAI_API_KEY="<my key>" wherever I
   launch you, and name models by slug. If your own config wants the values
   instead, it needs the same three: base URL https://api-pr-1028.preview.experientiallabs.ai/v1, my key, and a slug.


4. Verify end to end. Make one tiny completion with the surface you configured
   ("reply with the single word: ok", small max output), via your own next
   model call if you now route through the gateway, otherwise via curl with my
   key. Then tell me it landed and that I can watch every call at
   https://pr-1028.preview.experientiallabs.ai/telemetry.


5. Recap exactly what you changed (files and values, key shown as xpl_ prefix
   only) so I can undo it later.
shell
export OPENAI_BASE_URL="https://api-pr-1028.preview.experientiallabs.ai/v1"
export OPENAI_API_KEY="xpl_..."

If a tool asks for the values in its own config instead, it needs the same three: base URL https://api-pr-1028.preview.experientiallabs.ai/v1, the key, and a model slug.

Claude Code

The gateway serves the Anthropic Messages API at /v1/messages, so Claude Code connects like any LLM gateway: point ANTHROPIC_BASE_URL at it (no /v1 suffix; Claude Code appends the path) and pass your key as ANTHROPIC_API_KEY. Any catalog slug works as the model, not just Claude models. Use ANTHROPIC_API_KEY, not ANTHROPIC_AUTH_TOKEN: on a machine already signed in to claude.ai or the Console, the OAuth session can win over ANTHROPIC_AUTH_TOKEN, and the gateway then receives an OAuth token instead of your key — a 401 "gateway key is invalid".

Paste this into the agent. It wires itself up, then proves the key works.

prompt
I pasted this into you myself, wire THIS coding agent up to my Experiential
Labs gateway, so my model calls route through https://api-pr-1028.preview.experientiallabs.ai and show up in my usage.


Ground rules: never print my full key (first 8 characters at most), ask me
before you edit any config file or shell profile, and if you cannot do a step
(no file access, settings live in a GUI), print the exact manual steps for me
instead. Print what you're doing at each step.


1. Get my key. Use EXPLABS_API_KEY from my environment if it is set; otherwise
   ask me to paste one (I can mint it at https://pr-1028.preview.experientiallabs.ai/settings/api-keys). It looks
   like xpl_ followed by 40 hex characters.


2. Prove the key works before touching any config:
   GET https://api-pr-1028.preview.experientiallabs.ai/v1/models with header "Authorization: Bearer <key>" -> 200 and
   the model slugs I can call. Remember the list; I'll pick models from it.


3. Apply the Claude Code integration:
   You cannot repoint yourself mid-session, and switching auth under a running
   session causes mixed-state errors. First prove the lane without touching any
   config, via one isolated subprocess run from this project (so my MCP servers
   and plugins load and their tool schemas ride the request — tool schemas are
   where provider strictness bites, so a bare hello proves too little):
     ANTHROPIC_BASE_URL="https://api-pr-1028.preview.experientiallabs.ai" ANTHROPIC_API_KEY="<my key>" \
       ANTHROPIC_MODEL="<slug I pick>" \
       claude -p "list your available tools, then read ./README.md and reply
       with its first heading"
   Pass only if that run completes with tools listed and a real tool use.
   Then offer me two placements and apply the one I pick:
   (a) append to my shell profile, or (b) print for one-off use:
     export ANTHROPIC_BASE_URL="https://api-pr-1028.preview.experientiallabs.ai"        # no /v1 suffix
     export ANTHROPIC_API_KEY="<my key>"
     export ANTHROPIC_MODEL="<slug I pick>"
   Use ANTHROPIC_API_KEY, never ANTHROPIC_AUTH_TOKEN: an existing claude.ai
   sign-in can outrank AUTH_TOKEN and send the gateway an OAuth token instead.
   Then tell me to start a NEW session from a shell with those set. Warn me
   plainly: image pastes are rejected (the lane is text-only), and extended
   thinking flows only when the slug routes to Anthropic end to end.


4. Verify end to end. Make one tiny completion with the surface you configured
   ("reply with the single word: ok", small max output), via your own next
   model call if you now route through the gateway, otherwise via curl with my
   key. Then tell me it landed and that I can watch every call at
   https://pr-1028.preview.experientiallabs.ai/telemetry.


5. Recap exactly what you changed (files and values, key shown as xpl_ prefix
   only) so I can undo it later.

One env-prefixed run proves the lane without touching ~/.claude/settings.json, your shell profile, or any running session. Run it from a project where your MCP servers and plugins are enabled, so their tool schemas ride the request, and make it do one real tool round-trip:

shell
cd <a project with your MCP servers and plugins enabled>
ANTHROPIC_BASE_URL="https://api-pr-1028.preview.experientiallabs.ai" ANTHROPIC_API_KEY="xpl_..." \
  ANTHROPIC_MODEL="claude-opus-5" \
  claude -p "list your available tools, then read ./README.md and reply with its first heading"

A run that completes with your tools listed is the pass criterion. Then make it permanent. Claude Code reads auth at startup, and switching it under a running session causes mixed-state errors — always start a new session after changing these variables:

shell
export ANTHROPIC_BASE_URL="https://api-pr-1028.preview.experientiallabs.ai"
export ANTHROPIC_API_KEY="xpl_..."
export ANTHROPIC_MODEL="claude-opus-5"
claude

The [1m] model suffix works through the gateway: set ANTHROPIC_MODEL="<slug>[1m]" (or /model <slug>[1m]in-session) to run against the model's 1M-token context window, on models that serve one.

Extended thinking works on all-Anthropic routes: the thinkingconfig passes through verbatim and thinking/redacted-thinking blocks round-trip with signatures intact; on any other route those are rejected rather than silently dropped. The Messages lane remains a translation onto the gateway's chat surface, with four visible limits: image and document blocks are rejected because the chat surface is text-only, tool_result.is_error=true requires a native Anthropic-only route, sampling controls are forwarded into the exact route gate when the installed runtime supports that contract and otherwise rejected before dispatch, and /v1/messages/count_tokens answers an explicit 404 not_found_error (Claude Code estimates locally).

Conductor

Conductor (the Mac app that runs parallel Claude Code agents in git worktrees) delegates provider configuration to Claude Code's environment contract, so it uses the same three variables. Set them in Settings, Environment under the Claude Code section:

Paste this into the agent. It wires itself up, then proves the key works.

prompt
I pasted this into you myself, wire THIS coding agent up to my Experiential
Labs gateway, so my model calls route through https://api-pr-1028.preview.experientiallabs.ai and show up in my usage.


Ground rules: never print my full key (first 8 characters at most), ask me
before you edit any config file or shell profile, and if you cannot do a step
(no file access, settings live in a GUI), print the exact manual steps for me
instead. Print what you're doing at each step.


1. Get my key. Use EXPLABS_API_KEY from my environment if it is set; otherwise
   ask me to paste one (I can mint it at https://pr-1028.preview.experientiallabs.ai/settings/api-keys). It looks
   like xpl_ followed by 40 hex characters.


2. Prove the key works before touching any config:
   GET https://api-pr-1028.preview.experientiallabs.ai/v1/models with header "Authorization: Bearer <key>" -> 200 and
   the model slugs I can call. Remember the list; I'll pick models from it.


3. Apply the Conductor integration:
   Print these for me to put in Settings -> Environment (Claude Code section),
   or write them to this repo's .conductor/settings.local.toml under
   [environment_variables] if I prefer (make sure that file is
   git-ignored before writing my key into it):
     ANTHROPIC_BASE_URL = "https://api-pr-1028.preview.experientiallabs.ai"
     ANTHROPIC_API_KEY = "<my key>"
   The key rides ANTHROPIC_API_KEY, never ANTHROPIC_AUTH_TOKEN: an existing
   claude.ai sign-in can outrank AUTH_TOKEN, and a set API key also stops
   Claude Code from trying to authenticate with Anthropic directly.


4. Verify end to end. Make one tiny completion with the surface you configured
   ("reply with the single word: ok", small max output), via your own next
   model call if you now route through the gateway, otherwise via curl with my
   key. Then tell me it landed and that I can watch every call at
   https://pr-1028.preview.experientiallabs.ai/telemetry.


5. Recap exactly what you changed (files and values, key shown as xpl_ prefix
   only) so I can undo it later.
Conductor → Settings → Environment
ANTHROPIC_BASE_URL=https://api-pr-1028.preview.experientiallabs.ai
ANTHROPIC_API_KEY=xpl_...

The key rides ANTHROPIC_API_KEY, not ANTHROPIC_AUTH_TOKEN, for the same reason as the Claude Code section above: an existing claude.ai sign-in can outrank ANTHROPIC_AUTH_TOKEN, and a set API key also keeps Claude Code from authenticating with Anthropic directly. To scope the gateway to one repository instead, put the same variables in .conductor/settings.local.toml (machine-local, so the key stays out of the shared config):

.conductor/settings.local.toml
[environment_variables]
ANTHROPIC_BASE_URL = "https://api-pr-1028.preview.experientiallabs.ai"
ANTHROPIC_API_KEY = "xpl_..."
Conductor's per-chat model picker lists stock Claude aliases; to route a picker alias to a different catalog slug, remap it with ANTHROPIC_MODEL or the ANTHROPIC_DEFAULT_*_MODEL variables in the same environment block. The Claude Code lane limits above apply unchanged.

Rotate a key safely

Keys are independent: minting a new one never disturbs the old one, and an agent mid-task keeps working on the old key until you revoke it. Rotation is safe as long as you keep the order:

  1. Mint the new key in Settings, API keys.
  2. Verify it with the agent's isolated, tool-exercising test (at minimum the curl smoke) — never by editing your real config.
  3. Swap it into the agent's config and start a new session on it.
  4. Only then revoke the old key.
Never overwrite or revoke the old key before the replacement has passed its isolated test. Swapping an unverified token into a live config bricks the agent mid-work: every new request fails auth until you fix the config by hand.

Watch what your agents spend

Every call an agent makes lands in the same usage stream as the rest of your traffic. Humans read it at Logs and Credits; agents read their own via GET https://api-pr-1028.preview.experientiallabs.ai/api/gateway/usage/daily. Mint one key per agent to see spend broken out per tool.

  • Error handling is uniform across agents: see Errors for the stable codes and the retry playbook.
  • Which models an agent can reach, and how each is paid for, is the catalog and lanes story in Models.