Integrations

Most tools only need three values: an API key, a base URL, and a model ID. EmpirioLabs exposes OpenAI-compatible chat completions plus an Anthropic-style Messages endpoint, so setup is usually a provider dropdown and one URL change.

OpenCodeClaude CodeClineQwen CodeCodex CLIAiderContinueOpenHandsHermes AgentOpenClawgooseZedSillyTavernPersonaLLMJanitor AITypingMindOpen WebUILibreChatLobeChatKilo, Roo, Cursor

Fastest setup

Use this when you want a working setup without hand-editing config files. The command fetches the helper script from the docs site, runs it with Python, and writes only the scopes you choose. For tools that support local persisted config, the helper stores the key in gitignored project files so reopened app sessions do not depend on a shell export.

$
export EMPIRIOLABS_API_KEY="sk-empiriolabs-your_key_here"
$
script="${TMPDIR:-/tmp}/empirio-integrations-setup.py"
$
curl -fsSL "https://docs.empiriolabs.ai/integrations/setup.py" -o "$script"
$
python3 "$script" \
>
  --scope project \
>
  --tools opencode,aider,qwen-code,openhands \
>
  --model qwen3-max

$
export EMPIRIOLABS_API_KEY="sk-empiriolabs-your_key_here"
$
python3 empirio-integrations-setup.py --scope project --tools opencode,aider,qwen-code,openhands --model qwen3-max

What the helper writes

By default the helper fetches the live /v1/models?available=true catalog and writes every chat-capable model (text, multimodal, code, reasoning) into tools whose configs natively support a multi-model picker (OpenCode, Continue, Qwen Code, goose). The --model flag selects the default within that populated set. Pass --no-populate-models if you want only the default model registered.

The helper validates tool names and exits with an error for unknown values. If a selected tool does not match the chosen scope, the helper prints a note. For example, --scope project --tools codex does not write Codex config because Codex is a user-level config.

Integrations not listed in this table are manual UI or app-level setups. Use the connection values below for Cline, Zed, Kilo Code, Roo Code, Cursor-style fields, chat frontends, and hosted web UIs.

Connection values

Thinking and reasoning controls

EmpirioLabs exposes reasoning controls only on models that list them in their model page or machine-readable schema. Do not send these fields to every model by default.

For OpenAI-compatible Chat Completions and Responses, supported controls can include enable_thinking, thinking_budget, or reasoning_effort, depending on the model:

1
{
2
  "model": "qwen3-max-thinking",
3
  "messages": [
4
    { "role": "user", "content": "Answer briefly." }
5
  ],
6
  "enable_thinking": false
7
}

For the Anthropic-style Messages endpoint, use Anthropic-style thinking when the model supports thinking:

1
{
2
  "model": "qwen3-max-thinking",
3
  "messages": [
4
    { "role": "user", "content": "Work through this carefully." }
5
  ],
6
  "thinking": {
7
    "type": "enabled",
8
    "budget_tokens": 1024
9
  }
10
}

Tool support varies:

Smoke test

Run this before configuring a larger tool. If this works, your key, credits, network, and model ID are good.

$
export EMPIRIOLABS_API_KEY="sk-empiriolabs-your_key_here"
$
$
curl "https://api.empiriolabs.ai/v1/chat/completions" \
>
  -H "Authorization: Bearer $EMPIRIOLABS_API_KEY" \
>
  -H "Content-Type: application/json" \
>
  -d '{
>
    "model": "qwen3-max",
>
    "messages": [
>
      { "role": "user", "content": "Reply with one sentence." }
>
    ]
>
  }'

To list current model IDs:

$
curl "https://api.empiriolabs.ai/v1/models?available=true" \
>
  -H "Authorization: Bearer $EMPIRIOLABS_API_KEY"

Chat and roleplay frontends

Use this section for BYOK chat apps, roleplay tools, and shared web UIs. These tools normally do not need the helper script. Use your EmpirioLabs API key, pick a chat model such as qwen3-max, and keep secrets in the app’s local settings or environment variables.

SillyTavern

SillyTavern is a local roleplay and character chat frontend. EmpirioLabs works through its custom OpenAI-compatible Chat Completion source.

1. Open SillyTavern and click the plug icon to open API Connections.
2. Set API type to Chat Completion.
3. Set Chat Completion Source to Custom (OpenAI-compatible).
4. Set Custom Endpoint / Base URL to https://api.empiriolabs.ai/v1.
5. Paste your EmpirioLabs API key into the custom API key field.
6. Click Connect, then choose a model from the dropdown or type a model ID such as qwen3-max.

If the model dropdown is empty but your smoke test works, type the model ID manually. If a roleplay sampler causes a request error, remove non-standard extra parameters and retry with standard chat settings first.

PersonaLLM

PersonaLLM is an iOS roleplay and character chat app with bring-your-own-key provider settings. EmpirioLabs works through PersonaLLM’s custom text engine.

1. From the home screen, tap the three-dot menu in the top left.
2. Open Settings.
3. Open Text Engine.
4. Choose Custom.
5. Set the base URL to https://api.empiriolabs.ai/v1.
6. Paste your EmpirioLabs API key.
7. In the models field, tap the button on the right to fetch the live model list.
8. Choose a chat model such as qwen3-max or glm-5-1, then save the text engine settings.

Janitor AI

Janitor AI can call EmpirioLabs through its Proxy configuration. Use this path when you want to keep using Janitor’s chat UI while bringing your own EmpirioLabs key.

1. Open a Janitor AI chat.
2. Click using janitor or the menu button near the top of the chat.
3. Open API Settings.
4. Select the Proxy tab.
5. In Proxy Configurations, click + New.
6. Set Name to EmpirioLabs.
7. Set Model to qwen3-max, or another model ID from GET /v1/models?available=true.
8. Set Proxy URL to https://api.empiriolabs.ai/v1/chat/completions.
9. Paste your EmpirioLabs API key into API Key.
10. Leave Custom Prompt blank unless you already use one for that character or chat.
11. Click Add, save the settings, then refresh the Janitor AI page before sending the next message.

TypingMind

TypingMind supports custom chat models where you provide an endpoint, model ID, and optional headers.

1. Open Models from the left sidebar.
2. Open Model Settings, then click Add Custom Models.
3. Use API type OpenAI Chat Completions API if the form asks.
4. Set Endpoint API to https://api.empiriolabs.ai/v1/chat/completions.
5. Set Model ID to qwen3-max or another available model.
6. Add header Authorization: Bearer sk-empiriolabs-your_key_here, or paste the key into TypingMind’s API key field if the form provides one.
7. Click Test, then Add Model.

Open WebUI

Open WebUI can connect to OpenAI-compatible providers from the admin connection screen.

1. Open Admin Settings.
2. Go to Connections and add a new OpenAI connection.
3. Set URL to https://api.empiriolabs.ai/v1.
4. Paste your EmpirioLabs API key.
5. If model discovery is slow or too broad, add model IDs such as qwen3-max to the Model IDs filter.
6. Save, then choose the EmpirioLabs model in chat.

For server launches, set:

$
OPENAI_API_BASE_URL=https://api.empiriolabs.ai/v1
$
OPENAI_API_KEY=sk-empiriolabs-your_key_here

LibreChat

LibreChat supports custom OpenAI-compatible endpoints through librechat.yaml. Use an environment variable for one shared deployment key, or user_provided if each user should bring their own key in the UI.

1
version: 1.3.5
2
cache: true
3
endpoints:
4
  custom:
5
    - name: "EmpirioLabs"
6
      apiKey: "${EMPIRIOLABS_API_KEY}"
7
      baseURL: "https://api.empiriolabs.ai/v1"
8
      models:
9
        default: ["qwen3-max"]
10
        fetch: true
11
      titleConvo: true
12
      titleModel: "qwen3-max"
13
      modelDisplayLabel: "EmpirioLabs"

$
EMPIRIOLABS_API_KEY=sk-empiriolabs-your_key_here

For BYOK multi-user deployments, change apiKey to:

1
apiKey: "user_provided"

Restart LibreChat after changing librechat.yaml.

LobeChat

For self-hosted LobeChat, use the OpenAI provider with an EmpirioLabs proxy URL:

$
OPENAI_API_KEY=sk-empiriolabs-your_key_here
$
OPENAI_PROXY_URL=https://api.empiriolabs.ai/v1
$
OPENAI_MODEL_LIST=+qwen3-max,+glm-5-1,+deepseek-v4-pro:variant2

Then restart LobeChat and choose an enabled EmpirioLabs model in the model selector.

OpenCode

The helper can write this automatically:

$
python3 empirio-integrations-setup.py --tools opencode --model qwen3-max

Manual setup:

1
{
2
  "$schema": "https://opencode.ai/config.json",
3
  "provider": {
4
    "empiriolabs": {
5
      "npm": "@ai-sdk/openai-compatible",
6
      "name": "EmpirioLabs",
7
      "options": {
8
        "baseURL": "https://api.empiriolabs.ai/v1",
9
        "apiKey": "{file:.empiriolabs-api-key}"
10
      },
11
      "models": {
12
        "qwen3-max": {
13
          "name": "EmpirioLabs Qwen3-Max"
14
        },
15
        "qwen3-max-thinking": {
16
          "name": "EmpirioLabs Qwen3-Max-Thinking",
17
          "reasoning": true
18
        }
19
      }
20
    }
21
  }
22
}

$
printf '%s' 'sk-empiriolabs-your_key_here' > .empiriolabs-api-key
$
printf '\n.empiriolabs-api-key\n' >> .gitignore
$
opencode

In OpenCode, run /models and choose the EmpirioLabs provider. The file-backed key keeps working after you close and reopen OpenCode.

Claude Code

The helper can write the user-level settings automatically:

$
python3 empirio-integrations-setup.py --scope user --tools claude-code --model qwen3-max

Claude Code is not an OpenAI-chat-completions client. It talks to LLM gateways through the Anthropic Messages shape, which EmpirioLabs exposes at /v1/messages.

$
export EMPIRIOLABS_API_KEY="sk-empiriolabs-your_key_here"
$
$
# Claude Code sends ANTHROPIC_AUTH_TOKEN as a Bearer token.
$
export ANTHROPIC_AUTH_TOKEN="$EMPIRIOLABS_API_KEY"
$
$
# Claude Code appends /v1/messages itself, so do not include /v1 here.
$
export ANTHROPIC_BASE_URL="https://api.empiriolabs.ai"
$
$
export ANTHROPIC_CUSTOM_MODEL_OPTION="qwen3-max"
$
export ANTHROPIC_CUSTOM_MODEL_OPTION_NAME="EmpirioLabs Qwen3-Max"
$
export ANTHROPIC_MODEL="qwen3-max"
$
$
claude

Persistent user-level setup:

1
{
2
  "env": {
3
    "ANTHROPIC_AUTH_TOKEN": "sk-empiriolabs-your_key_here",
4
    "ANTHROPIC_BASE_URL": "https://api.empiriolabs.ai",
5
    "ANTHROPIC_CUSTOM_MODEL_OPTION": "qwen3-max",
6
    "ANTHROPIC_CUSTOM_MODEL_OPTION_NAME": "EmpirioLabs Qwen3-Max",
7
    "ANTHROPIC_MODEL": "qwen3-max"
8
  }
9
}

Cline

In the Cline extension UI:

1. Open Cline settings.
2. Set API Provider to OpenAI Compatible.
3. Set Base URL to https://api.empiriolabs.ai/v1.
4. Paste your EmpirioLabs API key.
5. Enter a model ID such as qwen3-max.
6. Click Verify, then start a new task.

For Cline CLI:

$
npm install -g cline
$
$
export EMPIRIOLABS_API_KEY="sk-empiriolabs-your_key_here"
$
$
cline auth \
>
  -p openai \
>
  -k "$EMPIRIOLABS_API_KEY" \
>
  -b "https://api.empiriolabs.ai/v1" \
>
  -m "qwen3-max"
$
$
cline "Inspect this repository and suggest the safest next refactor."

Qwen Code

The helper can write project or user settings automatically:

$
python3 empirio-integrations-setup.py --scope project --tools qwen-code --model qwen3-max

Launch Qwen Code directly with EmpirioLabs as the OpenAI-compatible provider:

$
export EMPIRIOLABS_API_KEY="sk-empiriolabs-your_key_here"
$
$
qwen \
>
  --auth-type openai \
>
  --openaiApiKey "$EMPIRIOLABS_API_KEY" \
>
  --openaiBaseUrl "https://api.empiriolabs.ai/v1" \
>
  --model "qwen3-max"

For persistent project setup:

1
{
2
  "model": {
3
    "name": "qwen3-max"
4
  },
5
  "security": {
6
    "auth": {
7
      "selectedType": "openai"
8
    }
9
  },
10
  "env": {
11
    "EMPIRIOLABS_API_KEY": "sk-empiriolabs-your_key_here"
12
  },
13
  "modelProviders": {
14
    "openai": [
15
      {
16
        "id": "qwen3-max",
17
        "name": "EmpirioLabs Qwen3-Max",
18
        "envKey": "EMPIRIOLABS_API_KEY",
19
        "baseUrl": "https://api.empiriolabs.ai/v1"
20
      }
21
    ]
22
  }
23
}

Add .qwen/settings.json to .gitignore if you store the key there.

Codex CLI

The helper can write the user-level provider block automatically:

$
python3 empirio-integrations-setup.py --scope user --tools codex --model qwen3-max

Add EmpirioLabs as a custom model provider in ~/.codex/config.toml:

1
model = "qwen3-max"
2
model_provider = "empiriolabs"
3
4
[model_providers.empiriolabs]
5
name = "EmpirioLabs"
6
base_url = "https://api.empiriolabs.ai/v1"
7
env_key = "EMPIRIOLABS_API_KEY"
8
wire_api = "responses"

Then launch Codex with your key in the environment:

$
export EMPIRIOLABS_API_KEY="sk-empiriolabs-your_key_here"
$
codex

Use this path with EmpirioLabs models that support POST /v1/responses.

Aider

The helper can write a project-local Aider config automatically:

$
python3 empirio-integrations-setup.py --tools aider --model qwen3-max

Aider uses the OpenAI-compatible environment variables. Prefix the model with openai/.

$
export OPENAI_API_BASE="https://api.empiriolabs.ai/v1"
$
export OPENAI_API_KEY="sk-empiriolabs-your_key_here"
$
$
aider --model openai/qwen3-max

Continue

The helper can write the user-level Continue config automatically:

$
python3 empirio-integrations-setup.py --scope user --tools continue --model qwen3-max

Continue’s OpenAI provider can target any OpenAI-compatible endpoint by setting apiBase. Put secrets in .env or Continue’s secret store rather than committing them into config.yaml.

1
name: EmpirioLabs
2
version: 0.0.1
3
schema: v1
4
5
models:
6
  - name: EmpirioLabs Qwen3-Max
7
    provider: openai
8
    model: qwen3-max
9
    apiBase: https://api.empiriolabs.ai/v1
10
    apiKey: ${{ secrets.EMPIRIOLABS_API_KEY }}
11
    capabilities:
12
      - tool_use

Add the secret in one of Continue’s supported .env locations:

$
EMPIRIOLABS_API_KEY=sk-empiriolabs-your_key_here

OpenHands

The helper can write a project-local OpenHands config automatically:

$
python3 empirio-integrations-setup.py --tools openhands --model qwen3-max

OpenHands exposes provider settings in the UI and passes them through to its LLM layer.

For environment-based launches:

$
export LLM_MODEL="openai/qwen3-max"
$
export LLM_BASE_URL="https://api.empiriolabs.ai/v1"
$
export LLM_API_KEY="sk-empiriolabs-your_key_here"

For persistent project setup:

1
[llm]
2
model = "openai/qwen3-max"
3
api_key = "sk-empiriolabs-your_key_here"
4
base_url = "https://api.empiriolabs.ai/v1"

Run OpenHands with:

$
openhands --config-file openhands.empiriolabs.toml

Add openhands.empiriolabs.toml to .gitignore if you store the key there.

Hermes Agent

The helper can write the user-level Hermes sidecar automatically:

$
python3 empirio-integrations-setup.py --scope user --tools hermes --model qwen3-max

Hermes has an interactive model wizard. Choose Custom endpoint, then enter:

Manual config:

1
custom_providers:
2
  - name: empiriolabs
3
    base_url: https://api.empiriolabs.ai/v1
4
    key_env: EMPIRIOLABS_API_KEY
5
6
model:
7
  provider: custom:empiriolabs
8
  default: qwen3-max

$
EMPIRIOLABS_API_KEY=sk-empiriolabs-your_key_here

OpenClaw

The helper can write a user-level OpenClaw sidecar automatically:

$
python3 empirio-integrations-setup.py --scope user --tools openclaw --model qwen3-max

The safest setup is the OpenClaw wizard:

$
openclaw configure --section model

Choose a custom or OpenAI-compatible provider and use:

For manual JSON5 config, use this as a sidecar or merge it into OpenClaw’s config:

1
{
2
  secrets: {
3
    providers: {
4
      default: { source: "env" }
5
    },
6
    defaults: {
7
      env: "default"
8
    }
9
  },
10
  models: {
11
    mode: "merge",
12
    providers: {
13
      empiriolabs: {
14
        baseUrl: "https://api.empiriolabs.ai/v1",
15
        apiKey: { source: "env", provider: "default", id: "EMPIRIOLABS_API_KEY" },
16
        authHeader: true,
17
        api: "openai-completions",
18
        models: [
19
          {
20
            id: "qwen3-max",
21
            name: "EmpirioLabs Qwen3-Max",
22
            input: ["text"],
23
            contextWindow: 256000
24
          }
25
        ]
26
      }
27
    }
28
  },
29
  agents: {
30
    defaults: {
31
      model: {
32
        primary: "empiriolabs/qwen3-max"
33
      }
34
    }
35
  }
36
}

Run openclaw config validate after manual edits.

goose

The helper can write the user-level goose custom provider automatically:

$
python3 empirio-integrations-setup.py --scope user --tools goose --model qwen3-max

goose supports custom OpenAI-compatible providers. The helper writes this as empiriolabs.json in the goose custom provider directory.

1
{
2
  "name": "empiriolabs",
3
  "engine": "openai",
4
  "display_name": "EmpirioLabs",
5
  "description": "EmpirioLabs OpenAI-compatible API",
6
  "api_key_env": "EMPIRIOLABS_API_KEY",
7
  "base_url": "https://api.empiriolabs.ai/v1/chat/completions",
8
  "models": [
9
    {
10
      "name": "qwen3-max",
11
      "context_limit": 256000
12
    }
13
  ],
14
  "supports_streaming": true,
15
  "requires_auth": true
16
}

$
export EMPIRIOLABS_API_KEY="sk-empiriolabs-your_key_here"
$
goose session start --provider empiriolabs

Zed

Zed supports OpenAI-compatible providers in the Agent Panel. Use the UI’s Add Provider flow, or edit settings:

1
{
2
  "language_models": {
3
    "openai_compatible": {
4
      "EmpirioLabs": {
5
        "api_url": "https://api.empiriolabs.ai/v1",
6
        "available_models": [
7
          {
8
            "name": "qwen3-max",
9
            "display_name": "EmpirioLabs Qwen3-Max",
10
            "max_tokens": 256000,
11
            "capabilities": {
12
              "tools": true,
13
              "images": false,
14
              "parallel_tool_calls": false,
15
              "prompt_cache_key": false
16
            }
17
          }
18
        ]
19
      }
20
    }
21
  }
22
}

Add the API key through the Agent Panel so Zed stores it in the OS credential store.

Kilo Code, Roo Code, Cursor, and similar IDEs

Use this table anywhere a tool exposes OpenAI Compatible, Custom OpenAI, or Override OpenAI Base URL.

Kilo Code and Roo-style VS Code extensions normally expose this as an API configuration profile. Roo Code’s public docs and product notices indicate a shutdown/archive path on May 15, 2026, so prefer Cline or Kilo Code for new team-wide templates unless your team already depends on Roo.

Cursor’s custom API key behavior depends on the version and feature surface. If your Cursor build only accepts provider API keys and does not expose a custom base URL for the feature you want, it cannot be pointed directly at EmpirioLabs for that feature.

Troubleshooting

Keep agents grounded

When an AI coding assistant is implementing an EmpirioLabs integration for you, give it the machine-readable docs bundle first:

Tell the agent to use https://docs.empiriolabs.ai/ai-agent-api-reference-context.md as the API reference, https://docs.empiriolabs.ai/ai-agent-docs-context.md for model and pricing details, and GET https://api.empiriolabs.ai/v1/models/{model_id} for live model metadata.

That prevents the agent from guessing endpoint shapes, stale model IDs, or parameter names.