Integration docs

One entry point to every model

There's no need to wire up each vendor separately. Your tool sends its usual request, the gateway spots the target model, translates the protocol and hands the result back — your code barely changes.

The same key works across editors, CLIs and chat clients. Usage, balance and call history all roll up to one account, so budgeting and debugging happen in a single place.

First call in three steps

From key in hand to first response usually takes a few minutes.

1. 01

   Fund your account

   Register, open a monthly card or top up, and confirm you have usable credit.

2. 02

   Create a key

   On the API keys page, make a key, name it for its purpose and pick a model group.

3. 03

   Drop it into your client

   Paste the address and key into your tool, pick a model and send a test message.

Codex

OpenAI's coding agent — available as a CLI, desktop app and VS Code extension; works with any OpenAI-compatible service, configured once and reused for the long haul.

1. 01

   Install and verify

   Install globally with npm (be sure to include the @openai/ prefix — don't grab a similarly named package by mistake); on macOS you can also use Homebrew. After installing, print the version to confirm the command is ready.

   Copy

   # npm (all platforms)
   npm install -g @openai/codex
   
   # macOS Homebrew
   brew install --cask codex
   
   # Verify
   codex --version

2. 02

   Find the config file

   Codex reads .codex/config.toml in your home directory; create it by hand if it doesn't exist. To move it elsewhere, set the CODEX_HOME environment variable.

   Windows

   %USERPROFILE%\.codex\config.toml

   macOS

   ~/.codex/config.toml

   Linux

   ~/.codex/config.toml

3. 03

   Write the provider config

   Add XylemNode as a model source. Three things to note: base_url must include /v1 manually; Codex currently only speaks the Responses protocol, so keep wire_api set to responses; reference the key via env_key rather than writing it in plain text.

   Copy

   model = "gpt-5.5"
   model_provider = "xylemnode"
   
   [model_providers.xylemnode]
   name = "XylemNode"
   base_url = "https://api.xylemnode.com/v1"
   wire_api = "responses"
   env_key = "XYLEMNODE_API_KEY"

4. 04

   Set the key

   Store the key in the environment variable named by env_key above. On Windows, run setx and reopen the terminal for it to take effect.

   Copy

   # Windows (PowerShell / CMD)
   setx XYLEMNODE_API_KEY "sk-your-key"
   
   # macOS / Linux
   export XYLEMNODE_API_KEY="sk-your-key"

5. 05

   Launch and test

   Reopen the terminal, run codex and send a simple prompt to confirm the connection. You can also switch models on the fly at launch.

   Copy

   codex
   
   # Pick a model for this run
   codex --model gpt-5.5

Claude Code

Anthropic's command-line coding assistant, speaking the native Anthropic protocol; point it at XylemNode to call it with the same key.

1. 01

   Install and verify

   The official recommendation is the native install script, no Node required; the npm route still works but is no longer recommended. After installing, print the version to confirm.

   Copy

   # macOS / Linux / WSL (recommended)
   curl -fsSL https://claude.ai/install.sh | bash
   
   # Windows PowerShell (recommended)
   irm https://claude.ai/install.ps1 | iex
   
   # npm route (still works, no longer recommended)
   npm install -g @anthropic-ai/claude-code
   
   # Verify
   claude --version

2. 02

   Find the config file

   Claude Code reads its config from settings.json. Put it in the user-level file to reuse across all projects, or place one in a project root to apply only there (project-level takes precedence over user-level).

   Windows

   %USERPROFILE%\.claude\settings.json

   macOS

   ~/.claude/settings.json

   Linux

   ~/.claude/settings.json

   Project-level

   <project-root>/.claude/settings.json

3. 03

   Write the config

   In the env block of settings.json, set three fields: endpoint, auth token and default model. The address uses the native protocol — no /v1 needed, Claude Code fills in the request path itself.

   Copy

   {
     "env": {
       "ANTHROPIC_BASE_URL": "https://api.xylemnode.com",
       "ANTHROPIC_AUTH_TOKEN": "sk-your-key",
       "ANTHROPIC_MODEL": "gpt-5.5"
     }
   }

4. 04

   Or use system env vars

   If you'd rather not edit a file, set the same three as system environment variables — same effect. On Windows, run setx and reopen the terminal.

   Copy

   # Windows (PowerShell / CMD)
   setx ANTHROPIC_BASE_URL "https://api.xylemnode.com"
   setx ANTHROPIC_AUTH_TOKEN "sk-your-key"
   setx ANTHROPIC_MODEL "gpt-5.5"
   
   # macOS / Linux
   export ANTHROPIC_BASE_URL="https://api.xylemnode.com"
   export ANTHROPIC_AUTH_TOKEN="sk-your-key"
   export ANTHROPIC_MODEL="gpt-5.5"

5. 05

   Launch and test

   From your project directory run claude and send a simple message to confirm; use /status to see the current endpoint and model.

   Copy

   claude
   
   # Non-interactive quick check
   claude -p "Reply with OK only"

Gemini CLI

Google's command-line AI agent, speaking the native Gemini protocol; set a few environment variables to route requests to XylemNode.

1. 01

   Install and verify

   Install globally with npm (recommended); on macOS you can use Homebrew, or run it install-free with npx for a quick try. After installing, print the version to confirm.

   Copy

   # npm (recommended, all platforms)
   npm install -g @google/gemini-cli
   
   # macOS Homebrew
   brew install gemini-cli
   
   # Run without installing
   npx @google/gemini-cli
   
   # Verify
   gemini --version

2. 02

   Set environment variables

   Gemini CLI connects to custom services via environment variables — set three: endpoint, API key and default model. For the endpoint, the service domain is enough.

   Copy

   # Windows (PowerShell / CMD)
   setx GOOGLE_GEMINI_BASE_URL "https://api.xylemnode.com"
   setx GEMINI_API_KEY "sk-your-key"
   setx GEMINI_MODEL "gpt-5.5"
   
   # macOS / Linux
   export GOOGLE_GEMINI_BASE_URL="https://api.xylemnode.com"
   export GEMINI_API_KEY="sk-your-key"
   export GEMINI_MODEL="gpt-5.5"

3. 03

   Or use a .env file

   If you'd rather not set system variables, put these in a .env file that Gemini CLI loads on start. User-level applies everywhere; project-level applies only to that project.

   Windows

   %USERPROFILE%\.gemini\.env

   macOS / Linux

   ~/.gemini/.env

   Project-level

   <project-root>/.gemini/.env

   Copy

   GOOGLE_GEMINI_BASE_URL=https://api.xylemnode.com
   GEMINI_API_KEY=sk-your-key
   GEMINI_MODEL=gpt-5.5

4. 04

   Launch and test

   Reopen the terminal and run gemini. You can also pick a model for the run with -m and do a non-interactive check with -p.

   Copy

   gemini
   
   # Pick a model for this run / non-interactive check
   gemini -m gpt-5.5 -p "Reply with OK only"

OpenCode

An AI coding agent in your terminal, working with any OpenAI-compatible service; config and key live in separate files, so the key never slips into version control.

1. 01

   Install and verify

   Install with the official script or globally via npm, then print the version to confirm. On Windows, OpenCode runs best under WSL, where its config follows the Linux paths inside WSL.

   Copy

   # Official script (macOS / Linux / WSL)
   curl -fsSL https://opencode.ai/install | bash
   
   # Or via npm (all platforms)
   npm install -g opencode-ai
   
   # Verify
   opencode --version

2. 02

   Find the config files

   OpenCode keeps 'provider definitions' and 'keys' separate: opencode.json holds provider definitions (supports .jsonc with comments), while keys live in auth.json. Below are the opencode.json locations; you can also place one in a project root to apply only there.

   Windows

   %USERPROFILE%\.config\opencode\opencode.json

   macOS / Linux

   ~/.config/opencode/opencode.json

   Project-level

   <project-root>/opencode.json

3. 03

   Define the provider

   Add a provider in opencode.json (note it's singular provider, not providers). Use the @ai-sdk/openai-compatible adapter; baseURL follows the OpenAI-compatible format and must include /v1; list the model ids you want under models. Don't put the key here.

   Copy

   {
     "$schema": "https://opencode.ai/config.json",
     "provider": {
       "xylemnode": {
         "npm": "@ai-sdk/openai-compatible",
         "options": { "baseURL": "https://api.xylemnode.com/v1" },
         "models": { "gpt-5.5": {} }
       }
     }
   }

4. 04

   Add the key

   Put the key in a separate auth.json, using the same key name as the provider above. The easiest way is to run opencode auth login and let it write the entry; you can also edit it by hand (on macOS/Linux at ~/.local/share/opencode/auth.json).

   Copy

   {
     "xylemnode": { "type": "api", "key": "sk-your-key" }
   }

5. 05

   Pick a model and test

   Restart OpenCode, use /models to see what's available, switch to a XylemNode model with /model, and send a message to confirm.

   Copy

   /models
   /model xylemnode/gpt-5.5

Cursor

An AI-native code editor with built-in support for OpenAI-compatible services; enter the address and key to swap the default model for XylemNode's.

1. 01

   Open model settings

   Open Cursor settings and go to the Models tab. To avoid clashing with the built-in models, first turn off the ones enabled by default.

2. 02

   Add a custom model

   In the model list, click 'Add model' and enter the model name you want by hand (e.g. gpt-5.5); it must match an available model in the console.

3. 03

   Override the Base URL and add the key

   Find the OpenAI API Key section, tick 'Override OpenAI Base URL', and enter the address and key. It uses the OpenAI-compatible format, so the address needs /v1; click Verify once, then save when it passes.

   Copy

   Base URL: https://api.xylemnode.com/v1
   API Key:  sk-your-key
   Model:    gpt-5.5

4. 04

   Pick a model and test

   After saving, start a new chat, select the gpt-5.5 you just added from the model dropdown, and send a message to confirm.

OpenClaw

A self-hosted AI gateway that connects chat entry points like Telegram, Discord and Slack to a coding agent; the model source is customizable — just set it to XylemNode.

1. 01

   Install

   Install globally with npm (Node 22.14 or newer recommended). After installing, run openclaw setup once for basic initialization, then check the version to confirm.

   Copy

   npm install -g openclaw
   openclaw --version

2. 02

   Find the config file

   OpenClaw keeps its config in a single JSON5 file (comments and trailing commas allowed). If it doesn't exist, run openclaw setup to generate it; to relocate it, set OPENCLAW_CONFIG_PATH.

   Windows

   %USERPROFILE%\.openclaw\openclaw.json

   macOS

   ~/.openclaw/openclaw.json

   Linux

   ~/.openclaw/openclaw.json

3. 03

   Write the provider config

   Add XylemNode as a model source and set it as the default. baseUrl uses the OpenAI-compatible format and needs /v1; keep api set to openai-completions; the key can be written directly or referenced with ${ENV_VAR}.

   Copy

   {
     "agents": {
       "defaults": {
         "model": { "primary": "xylemnode/gpt-5.5" }
       }
     },
     "models": {
       "mode": "merge",
       "providers": {
         "xylemnode": {
           "baseUrl": "https://api.xylemnode.com/v1",
           "apiKey": "sk-your-key",
           "api": "openai-completions",
           "models": [
             { "id": "gpt-5.5", "name": "GPT-5.5" }
           ]
         }
       }
     }
   }

4. 04

   Restart the gateway and verify

   Restart the gateway after changes so they take effect, then list models to confirm XylemNode loaded; openclaw doctor can health-check your config.

   Copy

   openclaw gateway restart
   openclaw models list
   
   # Health-check the config
   openclaw doctor

CC Switch

A desktop app that centrally manages provider configs for tools like Claude Code, Codex, Gemini CLI and OpenCode: add or remove visually and switch in one click, sparing you manual edits to each tool's config.

1. 01

   Install

   Download and install from CC Switch's official GitHub (farion1231/cc-switch) Releases for your OS. It's completely free and open source — fake paid sites have appeared recently, so stick to the official repo and never enter details on any 'CC Switch' site that asks for payment or login.

2. 02

   Add the XylemNode provider

   Click the + in the top-right to open the add panel. XylemNode is an OpenAI-compatible service reusable across tools, so the 'Universal Provider' is recommended: fill in the three fields below, then check the tools to sync (Claude Code / Codex / Gemini). The domain is enough for the address — CC Switch appends /v1 and other paths per tool automatically.

   Name

   XylemNode

   Endpoint

   https://api.xylemnode.com

   API Key

   sk-your-key

3. 03

   Fetch and pick models

   Once the address and key are set, click 'Fetch Models' next to the model box — it uses your key to call /v1/models and pull the list; pick the model you want (e.g. gpt-5.5). If nothing loads, enter the model name by hand.

4. 04

   Save and enable

   For the Universal Provider, click 'Save and sync' to write to all checked tools at once; then click 'Enable' on the provider card to switch to XylemNode. After that, use the system tray to switch quickly between tools.

Cline

An open-source AI coding agent in VS Code that reads and writes across files and runs commands. It natively supports OpenAI-compatible providers — one base URL and key connects it to XylemNode.

1. 01

   Install the extension

   In the editor, press Ctrl/Cmd+Shift+X to open the Extensions panel, search for Cline, and install the one by saoudrizwan. After installing, a Cline icon appears in the left activity bar — open it for the chat panel.

2. 02

   Choose the OpenAI-compatible provider

   In the Cline panel, click the gear ⚙️ in the top-right to open settings, and switch the API Provider dropdown to 'OpenAI Compatible'. That's what lets you enter a custom address instead of going through official OpenAI.

3. 03

   Enter connection details

   Fill in the three fields below. Note Cline's Base URL needs /v1 and should stop there — don't paste a full path like /chat/completions.

   Base URL

   https://api.xylemnode.com/v1

   API Key

   sk-your-key

   Model ID

   gpt-5.5

4. 04

   Verify and start

   Click 'Verify' to confirm connectivity, then return to the chat panel to start. To change models later, just edit the Model ID — the Base URL and key stay untouched.

Continue

An open-source AI coding assistant for VS Code and JetBrains — chat, autocomplete and edit in one. It manages models with a single config.yaml; set provider to openai and change apiBase to connect XylemNode.

1. 01

   Install the extension

   In VS Code, press Ctrl/Cmd+Shift+X, search for Continue and install; JetBrains users search Continue in the Plugins marketplace. After installing, a Continue icon appears in the sidebar — open it for the panel.

2. 02

   Open config.yaml

   Open the Continue sidebar and click the gear ⚙️ in the top-right to open config.yaml; you can also edit the file directly in your home directory. Newer versions use YAML — the old config.json is deprecated.

   macOS / Linux

   ~/.continue/config.yaml

   Windows

   %USERPROFILE%\.continue\config.yaml

3. 03

   Add the XylemNode model

   Add an entry to the models list in config.yaml: set provider to openai and point apiBase at XylemNode with /v1. The name / version / schema at the top of the file are auto-generated by Continue — leave them as is.

   Copy

   models:
     - name: XylemNode
       provider: openai
       model: gpt-5.5
       apiBase: https://api.xylemnode.com/v1
       apiKey: sk-your-key

4. 04

   Select the model and start

   After saving, return to the Continue panel and select XylemNode from the model dropdown to chat and edit. To change models later, edit only the model line — apiBase and apiKey stay untouched.

Aider

An open-source AI pair-programming tool in your terminal that edits code in your local git repo and commits automatically. Via LiteLLM it supports OpenAI-compatible endpoints — set the env vars and prefix the model name with openai/ to use XylemNode.

1. 01

   Install

   The official recommendation is aider-install for a one-step setup — it installs aider in an isolated environment without polluting system Python. Print the version afterward to confirm.

   Copy

   # Install (all platforms)
   python -m pip install aider-install
   aider-install
   
   # Verify
   aider --version

2. 02

   Configure the endpoint and key

   Hand aider the XylemNode endpoint and key via environment variables; the address needs /v1. On Windows, run setx and reopen the terminal for it to take effect.

   Copy

   # Windows (PowerShell / CMD)
   setx OPENAI_API_BASE "https://api.xylemnode.com/v1"
   setx OPENAI_API_KEY "sk-your-key"
   # reopen the terminal after setx
   
   # macOS / Linux
   export OPENAI_API_BASE="https://api.xylemnode.com/v1"
   export OPENAI_API_KEY="sk-your-key"

3. 03

   Enter the project and pick a model

   Switch to your git project directory and launch with the model name prefixed by openai/. That prefix tells aider (via LiteLLM) to request in OpenAI-compatible mode; the model name after the prefix must exactly match one in the console's /v1/models.

   Copy

   cd /path/to/your/project
   aider --model openai/gpt-5.5

SillyTavern

A locally self-hosted chat frontend focused on role-play and multi-turn conversation. It doesn't run models itself — it connects to a backend; choose the Custom (OpenAI-compatible) source under Chat Completion, enter the address and key, and you're on XylemNode.

1. 01

   Install and launch

   SillyTavern runs on your machine (Node.js required). After following the official install guide, launch it on Windows by double-clicking Start.bat, or on macOS/Linux with ./start.sh; the official Launcher or Docker also work. Once running, open the local address shown in the terminal (default http://localhost:8000) in your browser.

2. 02

   Open API connections and choose the custom source

   Click API Connections (the plug icon) at the top, switch the API type to Chat Completion, then set Chat Completion Source to Custom (OpenAI-compatible).

3. 03

   Enter the address and key

   At the custom endpoint, enter XylemNode's address (with /v1) and your key.

   Custom Endpoint (Base URL)

   https://api.xylemnode.com/v1

   API Key

   sk-your-key

4. 04

   Pick a model and connect

   XylemNode implements /v1/models, so SillyTavern populates the model dropdown automatically — pick one (e.g. gpt-5.5); if nothing loads, type the model ID in the text box. Click Connect, then use Test Message to send one and verify.

Open WebUI

A self-hosted, ChatGPT-style web interface for multiple users that centrally manages several model connections. It talks to backends over the OpenAI protocol — just add XylemNode as an OpenAI connection.

1. 01

   Deploy and open

   Docker is the official first choice. After pulling and running the image, open http://localhost:3000 in your browser and create an admin account on first visit. pip, Kubernetes and other methods are also supported.

   Copy

   # Pull the image
   docker pull ghcr.io/open-webui/open-webui:main
   
   # Run (maps the UI to local port 3000)
   docker run -d -p 3000:8080 -v open-webui:/app/backend/data --name open-webui ghcr.io/open-webui/open-webui:main

2. 02

   Add an OpenAI connection

   Go to ⚙️ Admin Settings → Connections → OpenAI and click ➕ Add Connection. Open WebUI groups every OpenAI-protocol service under the OpenAI type, and XylemNode uses that too.

3. 03

   Enter the address and key

   Enter XylemNode's address (with /v1) and key, then save. It calls /v1/models to populate the available models automatically.

   URL

   https://api.xylemnode.com/v1

   API Key

   sk-your-key

4. 04

   Pick a model and chat

   After saving, return to the chat view and select a XylemNode model (e.g. gpt-5.5) from the model menu at the top to start chatting.

Dify

An open-source platform for building LLM apps with visual orchestration of agents, workflows and RAG. Through its OpenAI-API-compatible provider it connects any OpenAI-compatible service — enter the address and key to use XylemNode as a model source.

1. 01

   Prepare Dify

   Sign up for Dify Cloud (cloud.dify.ai) to start right away; or self-host — clone the official repo, bring up the services with Docker Compose and open the local address in your browser to log in.

2. 02

   Install the OpenAI-API-compatible provider

   Go to Settings → Model Providers in the top-right and find and install OpenAI-API-compatible from the list or plugin marketplace. It's made for connecting all kinds of OpenAI-compatible endpoints.

3. 03

   Add the XylemNode model

   On that provider's card, click 'Add model' and fill in the table below. The API endpoint URL needs /v1, and the model name must match the console.

   Model type

   LLM

   Model name

   gpt-5.5

   API Key

   sk-your-key

   API endpoint URL

   https://api.xylemnode.com/v1

4. 04

   Save and use

   After saving, you can set it as the default reasoning model under 'System Model Settings' in the top-right; then you can select the XylemNode model when orchestrating apps.

Coze Studio (open-source)

The open-source, self-hosted edition of Coze for visually building AI agents and workflows. Its model service supports 'third-party API relay' — choose the openai protocol and enter a /v1 address to connect XylemNode.

1. 01

   Deploy the open-source Coze Studio

   The Coze cloud platform (coze.cn / coze.com) uses platform-hosted models and can't connect custom endpoints; the one that connects XylemNode is the open-source Coze Studio. Following the official docs, clone the repo and deploy it with Docker Compose.

2. 02

   Open Model Management

   In your browser, open the Model Management page in the admin console and click Add Model.

   Model management URL

   http://localhost:8888/admin/#model-management

3. 03

   Fill in as a third-party relay

   XylemNode counts as 'other third-party API relay': choose the openai protocol, enter the domain with /v1 as the address (not /chat/completions), then add the key and model name.

   Protocol

   openai

   Base URL

   https://api.xylemnode.com/v1

   API Key

   sk-your-key

   Model name

   gpt-5.5

4. 04

   Save and use

   After saving, the model ID is globally unique — don't change it once live (doing so breaks calls). From then on you can select this model when creating agents or workflows.

Cherry Studio

A cross-platform, open-source desktop AI client (Windows / macOS / Linux) that gathers many models in one interface. Add a custom provider of the OpenAI type to bring XylemNode in.

1. 01

   Install

   Download the installer for your OS from Cherry Studio's official repo / site, install and open it.

2. 02

   Create an OpenAI-type provider

   Go to Settings → Model Services, click 'Add' at the bottom of the list, give it a label (e.g. XylemNode), choose provider type OpenAI, and confirm.

3. 03

   Enter the key and API address

   Enter the key and API address. This differs from other tools: enter only the domain for the API address — Cherry Studio appends /v1/chat/completions automatically, so don't add /v1 yourself or it will double up.

   API key

   sk-your-key

   API address

   https://api.xylemnode.com

4. 04

   Add models and enable

   Click 'Manage' at the bottom-left to auto-fetch models and add them with + (or type a model name by hand, e.g. gpt-5.5). Use 'Check' next to the key box to test, then flip the switch in the top-right to enable this provider.

Qwen Code

Tongyi's terminal AI coding agent (a Gemini CLI fork) aimed at code understanding and automation. It supports the OpenAI-compatible protocol — set the env vars to use XylemNode.

1. 01

   Install

   Install globally with npm (Node.js 20+ required). Print the version afterward to confirm.

   Copy

   # Install
   npm install -g @qwen-code/qwen-code@latest
   
   # Verify
   qwen --version

2. 02

   Configure the endpoint and key

   Hand qwen the XylemNode key, address and model via environment variables; the address includes /v1. On Windows, run setx and reopen the terminal.

   Copy

   # Windows (PowerShell / CMD)
   setx OPENAI_API_KEY "sk-your-key"
   setx OPENAI_BASE_URL "https://api.xylemnode.com/v1"
   setx OPENAI_MODEL "gpt-5.5"
   # reopen the terminal after setx
   
   # macOS / Linux
   export OPENAI_API_KEY="sk-your-key"
   export OPENAI_BASE_URL="https://api.xylemnode.com/v1"
   export OPENAI_MODEL="gpt-5.5"

3. 03

   Launch and choose auth

   Run qwen in your project directory. On first launch, use /auth and choose Custom Provider / OpenAI — it prefills API Key, Base URL and Model from the env vars above; press Enter to confirm and start.

   Copy

   cd /path/to/your/project
   qwen

work-buddy

A local-first agent runtime for knowledge workers, running on top of Claude Code and Obsidian, that gathers scattered notes, tasks, calendar entries and browser tabs into reusable multi-step workflows. It never talks to a model directly — every request goes out through Claude Code, so pointing Claude Code at XylemNode routes all of its workflows the same way.

1. 01

   Have Claude Code ready first

   work-buddy is an extension layer over Claude Code, and Claude Code (CLI or Desktop) is the one hard prerequisite. Obsidian is optional — the core runs without it — but you need a vault to reach the task and calendar capabilities.

   Copy

   # Confirm Claude Code is ready
   claude --version

2. 02

   Point Claude Code at XylemNode

   This step decides which model work-buddy actually uses. Set the endpoint, token and model name in Claude Code's settings.json; it speaks the native Anthropic protocol, so the address carries no /v1. Skip this if you already followed the Claude Code section on this page.

   Copy

   {
     "env": {
       "ANTHROPIC_BASE_URL": "https://api.xylemnode.com",
       "ANTHROPIC_AUTH_TOKEN": "sk-your-key",
       "ANTHROPIC_MODEL": "gpt-5.5"
     }
   }

3. 03

   Install work-buddy

   Download the latest installer from GitHub releases and run it. It bundles its own Python (around 1 GB of dependencies), the background services are already running once it finishes, and it adds a Start Menu launcher plus a system-tray icon. Only a Windows installer is available today; macOS and Linux builds are still in preparation, and on those platforms you can install from source with uv as described in the repo's CONTRIBUTING.

   Installer

   github.com/KadenMc/work-buddy/releases/latest

   MCP gateway

   localhost:5126

   Dashboard

   localhost:5127

4. 04

   Open it in Claude Code and run setup

   Open work-buddy's install folder in Claude Code and it connects to the local MCP gateway automatically. Then run the guided setup and an agent walks you through picking features and wiring up your own tools and preferences.

   Copy

   /wb-setup guided

5. 05

   Everyday use

   The common workflows are slash commands inside Claude Code (the full catalog lives in the official handbook); the background services are managed with the wbuddy command, and the tray icon can also start or stop them and open the dashboard.

   Copy

   # Inside a Claude Code session
   /wb-morning        # briefing, priorities and a day plan
   /wb-task-triage    # batch-decide on your task inbox
   
   # From any terminal
   wbuddy status                    # background service health
   wbuddy start | stop | restart    # control the background services
   wbuddy launch                    # start if needed, then open the dashboard

Common questions