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 WebUILibreChatLobeChatDifyLiteLLMHaystackLangflowbig-AGIKilo, 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.

Refreshing the model list after a new launch

The helper fetches GET /v1/models?available=true on every run and rewrites the multi-model configs from that live snapshot, so the registered model list reflects whichever models are launched at the moment the helper executes. Re-running the same command after a new model launches adds it to OpenCode’s opencode.json, Continue’s config.yaml, the Qwen Code settings.json provider list, and the goose custom provider JSON without any other edits. Aider, OpenHands, Claude Code, Codex CLI, Hermes Agent, and OpenClaw do not maintain a multi-model registry in their config, so those tools always read whichever model your code passes at request time, which means no helper re-run is needed for those tools when a new model launches.

$
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

Hands-off auto-refresh (installed by default)

The setup command installs a platform-native scheduled task that re-fetches the EmpirioLabs model list every 6 hours so newly launched models appear in OpenCode, Qwen Code, Continue, and goose without any manual step. The job runs on its own, in the background, with no shell session required:

• Linux: a marked entry in your user crontab (visible with crontab -l)
• macOS: a user LaunchAgent at ~/Library/LaunchAgents/ai.empiriolabs.refresh.plist
• Windows: a Task Scheduler task named “EmpirioLabs Auto Refresh”

The job reads the API key from ~/.empiriolabs/.empiriolabs-api-key (mode 600 on POSIX) and only rewrites configs that already exist on disk, so it never creates files in unrelated directories. Logs (macOS) and stdout (Linux/Windows) go to ~/.empiriolabs/refresh.log.

Pass --no-auto-refresh to the setup command to opt out, or run the helper later with --uninstall-auto-refresh to remove the scheduled task and clean up the marker entries.

$
python3 "$script" --scope project --tools opencode,aider,qwen-code,openhands --model qwen3-max --no-auto-refresh

$
curl -fsSL https://docs.empiriolabs.ai/integrations/setup.py | python3 - --uninstall-auto-refresh

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
}

reasoning_effort accepts none, low, medium, high, and max on every reasoning-capable model. EmpirioLabs normalizes the value into the selected model’s supported reasoning fields, so the same effort string works across model families regardless of whether the model service expects reasoning_effort, enable_thinking, or thinking_budget natively.

1
{
2
  "model": "deepseek-v4-pro",
3
  "messages": [
4
    { "role": "user", "content": "Solve this carefully." }
5
  ],
6
  "reasoning_effort": "max"
7
}

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 the EmpirioLabs API base 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.

Dify

Dify can use EmpirioLabs through the marketplace model provider plugin. Install the plugin, then add your EmpirioLabs API key in the model provider settings.

After installing:

1. Go to Settings > Model Provider.
2. Choose the installed provider.
3. Enter your API key.
4. Select a predefined model, or add another model ID. The full list of model IDs is available from GET /v1/models.

LiteLLM

EmpirioLabs is a built-in LiteLLM provider, so the SDK and the LiteLLM Proxy can route to any EmpirioLabs chat model with the empiriolabs/ prefix. On LiteLLM versions that predate the provider, use the OpenAI-compatible fallback below.

1
import os
2
import litellm
3
4
os.environ["EMPIRIOLABS_API_KEY"] = "sk-empiriolabs-your_key_here"
5
6
response = litellm.completion(
7
    model="empiriolabs/qwen3-7-plus",
8
    messages=[{"role": "user", "content": "Hello!"}],
9
)

1
model_list:
2
  - model_name: qwen3-7-plus
3
    litellm_params:
4
      model: empiriolabs/qwen3-7-plus
5
      api_key: os.environ/EMPIRIOLABS_API_KEY

Older LiteLLM versions (or image generation) can use the OpenAI-compatible route directly:

1
import os
2
import litellm
3
4
response = litellm.image_generation(
5
    prompt="A glass cathedral at sunset, dramatic lighting",
6
    model="openai/seedream-5-0-lite",
7
    api_base="https://api.empiriolabs.ai/v1",
8
    api_key=os.environ["EMPIRIOLABS_API_KEY"],
9
    extra_body={"sync": True},
10
)

The sync: true field makes the image endpoint return the finished OpenAI-shaped response instead of the default async job envelope. LiteLLM’s own provider page for EmpirioLabs is at docs.litellm.ai/docs/providers/empiriolabs.

Haystack

Haystack (by deepset) natively supports EmpirioLabs. Point Haystack’s OpenAI components at https://api.empiriolabs.ai/v1 with your EmpirioLabs key, then use any EmpirioLabs chat or embedding model inside a pipeline. Use OpenAIChatGenerator for chat, since the plain OpenAIGenerator is deprecated.

1
import os
2
from haystack.components.generators.chat import OpenAIChatGenerator
3
from haystack.dataclasses import ChatMessage
4
from haystack.utils import Secret
5
6
os.environ["EMPIRIOLABS_API_KEY"] = "sk-empiriolabs-your_key_here"
7
8
generator = OpenAIChatGenerator(
9
    api_key=Secret.from_env_var("EMPIRIOLABS_API_KEY"),
10
    api_base_url="https://api.empiriolabs.ai/v1",
11
    model="qwen3-max",
12
)
13
14
response = generator.run(messages=[ChatMessage.from_user("Reply with one sentence.")])
15
print(response["replies"][0].text)

1
import os
2
from haystack.components.embedders import OpenAITextEmbedder
3
from haystack.utils import Secret
4
5
os.environ["EMPIRIOLABS_API_KEY"] = "sk-empiriolabs-your_key_here"
6
7
embedder = OpenAITextEmbedder(
8
    api_key=Secret.from_env_var("EMPIRIOLABS_API_KEY"),
9
    api_base_url="https://api.empiriolabs.ai/v1",
10
    model="text-embedding-v4",
11
)
12
13
result = embedder.run(text="EmpirioLabs gives you frontier models behind one API.")
14
print(len(result["embedding"]))

Haystack’s integration page for EmpirioLabs is at haystack.deepset.ai/integrations/empiriolabs.

Langflow

EmpirioLabs AI is available for Langflow as an extension bundle, published as the lfx-empiriolabs package. It adds EmpirioLabs chat models and image generation as Langflow components.

Once the bundle is installed, add the EmpirioLabs AI model component (or EmpirioLabs AI Image Generation for images) to your flow, enter your API key, and pick a model from the live catalog.

big-AGI

big-AGI supports EmpirioLabs AI as an OpenAI-compatible provider.

1. In big-AGI, open Models and add a provider.
2. Choose the OpenAI compatible type.
3. Set the API host to https://api.empiriolabs.ai/v1 and paste your API key. EmpirioLabs AI also appears in the provider suggestions.
4. Load the model list to pull the EmpirioLabs catalog.

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

EmpirioLabs is a built-in provider in goose, so you can pick it directly without writing any custom provider files. It is listed in the goose providers documentation.

Configure it from the goose CLI:

$
goose configure

1. Select Configure Providers.
2. Choose EmpirioLabs from the provider list.
3. Enter your API key when prompted. goose stores it as EMPIRIOLABS_API_KEY.
4. Select the EmpirioLabs model you want, for example qwen3-max.

Then start a session:

$
goose session

Auto-register every model

If you prefer the model picker populated from the live catalog and refreshed as new models launch, the setup helper writes a goose custom provider that lists every chat-capable model:

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

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.