Skip to content

Agents

Twenty-eight agents, nine shapes of entry, and one installer that writes them all

The installer writes one excellent entry into each agent's own config, in that agent's own shape. Here is every shape, every agent and every file, with the prompt to paste and the undo.

excellent install-agent-mcps

The installer runs it for you when your CLI has it, and says so when it skips it. macOS today; Windows and Linux are not supported yet.

28

agents configured by the installer, 27 by their own file and OpenClaw by its own command

9

shapes of entry, from the common mcpServers block to goose's extensions

3

refused: the config is known, but Excellent cannot verify the server's working directory

12

detected only: the agent has no MCP config Excellent can write

28 configured · 15 left alone

Pick an agent

Configured by the installer28

Detected, not configured15

~ · zsh
~excellent install-agent-mcps
Claude Code: linked — Wrote 'excellent' server to /Users/you/.claude.json. Restart or reload Claude Code to pick it up.
Restart or reload the newly configured agents before using Excellent.
 
~cat ~/.claude.json
{
"mcpServers": {
"excellent": {
"type": "stdio",
"command": "/absolute/path/to/node",
"args": [
"/absolute/path/to/@excellent-so/cli/dist/server.js"
],
"cwd": "/absolute/path/to/@excellent-so/cli/dist",
"env": {}
}
}
}
 
~excellent install-agent-mcps
Claude Code: already-linked — The Excellent MCP server is already configured.
~

Lines, paths and entries are the installer’s own, read from its source; /Users/you stands for your home folder. Names and marks belong to their owners. Shown to say Excellent works with these agents, with no endorsement implied.

The nine shapes

Scroll for all nine · pick a mark to open its row
  1. JSON17 agents

    mcpServers, with type: "stdio"

    17 files
    {
    "mcpServers": {
    "excellent": {
    "type": "stdio",
    "command": "/absolute/path/to/node",
    "args": [
    "/absolute/path/to/@excellent-so/cli/dist/server.js"
    ],
    "cwd": "/absolute/path/to/@excellent-so/cli/dist",
    "env": {}
    }
    }
    }
  2. TOML3 agents

    a [mcp_servers.excellent] table

    3 files
    [mcp_servers.excellent]
    command = "/absolute/path/to/node"
    args = [ "/absolute/path/to/@excellent-so/cli/dist/server.js" ]
    cwd = "/absolute/path/to/@excellent-so/cli/dist"
    env = {}
  3. JSON2 agents

    mcp, a local server with command as one array

    2 files
    {
    "mcp": {
    "excellent": {
    "type": "local",
    "command": [
    "/absolute/path/to/node",
    "/absolute/path/to/@excellent-so/cli/dist/server.js"
    ],
    "cwd": "/absolute/path/to/@excellent-so/cli/dist",
    "environment": {},
    "enabled": true
    }
    }
    }
  4. JSON1 agent

    amp.mcpServers (one literal dotted key)

    ~/.config/amp/settings.json
    {
    "amp.mcpServers": {
    "excellent": {
    "command": "/absolute/path/to/node",
    "args": [
    "/absolute/path/to/@excellent-so/cli/dist/server.js"
    ],
    "cwd": "/absolute/path/to/@excellent-so/cli/dist",
    "env": {}
    }
    }
    }
  5. JSON1 agent

    mcp, with type: "stdio"

    ~/.config/crush/crush.json
    {
    "mcp": {
    "excellent": {
    "type": "stdio",
    "command": "/absolute/path/to/node",
    "args": [
    "/absolute/path/to/@excellent-so/cli/dist/server.js"
    ],
    "cwd": "/absolute/path/to/@excellent-so/cli/dist",
    "env": {}
    }
    }
    }
  6. YAML1 agent

    extensions, as a goose stdio extension

    ~/.config/goose/config.yaml
    extensions:
    excellent:
    type: "stdio"
    name: "Excellent"
    enabled: true
    cmd: "/absolute/path/to/node"
    cwd: "/absolute/path/to/@excellent-so/cli/dist"
    args:
    - "/absolute/path/to/@excellent-so/cli/dist/server.js"
    env_keys: []
    envs: {}
    timeout: 300
  7. YAML1 agent

    mcp_servers, in YAML

    ~/.hermes/config.yaml
    mcp_servers:
    excellent:
    command: "/absolute/path/to/node"
    cwd: "/absolute/path/to/@excellent-so/cli/dist"
    args:
    - "/absolute/path/to/@excellent-so/cli/dist/server.js"
    env: {}
  8. Vendor CLI1 agent

    OpenClaw's own mcp set command

    ~ · zsh
    # the installer runs OpenClaw's own MCP command
    ~$openclaw mcp set excellent '{"command":"/absolute/path/to/node","args":["/absolute/path/to/@excellent-so/cli/dist/server.js"],"cwd":"/absolute/path/to/@excellent-so/cli/dist","env":{},"transport":"stdio"}'
  9. JSON1 agent

    mcpServers, with transport: "stdio"

    ~/.rovodev/mcp_config.json
    {
    "mcpServers": {
    "excellent": {
    "transport": "stdio",
    "command": "/absolute/path/to/node",
    "args": [
    "/absolute/path/to/@excellent-so/cli/dist/server.js"
    ],
    "cwd": "/absolute/path/to/@excellent-so/cli/dist",
    "env": {}
    }
    }
    }

01The sheet

Every agent on one sheet, and each row opens to its prompt and its entry

The entries use two placeholders. The installer fills them in for you; to add an entry by hand, replace them with what these two commands print.

/absolute/path/to/node

The Node that ran the installer, as an absolute real path.

node -p process.execPath
/absolute/path/to/@excellent-so/cli/dist

The dist folder of the installed package, which holds server.js.

echo "$(npm root -g)/@excellent-so/cli/dist"

The CLI on npm today, 0.1.0 (checked October 23, 2026), predates install-agent-mcps: the installer skips this step, says so, and changes no agent config. Every row below carries the entry and a setup prompt to add it by hand, and the setup doc walks through it.

Claude CodeAnthropic~/.claude.jsonJSONmcpServersClaude Code: linked

Claude Code

Anthropic JSON · ~/.claude.json

Set up Excellent (excellent.so) in Claude Code for me. First run: curl -fsSL https://excellent.so/install.sh | sh
If its output has a line starting "Claude Code: linked" or "Claude Code: already-linked", skip to the last step.
Otherwise open ~/.claude.json (create it as {} if it is missing) and add this under the top-level "mcpServers" object, creating that object if needed and keeping everything else in the file unchanged:
"excellent": {"type":"stdio","command":"/absolute/path/to/node","args":["/absolute/path/to/@excellent-so/cli/dist/server.js"],"cwd":"/absolute/path/to/@excellent-so/cli/dist","env":{}}
Replace /absolute/path/to/node with the output of `node -p process.execPath`, and /absolute/path/to/@excellent-so/cli/dist with the output of `echo "$(npm root -g)/@excellent-so/cli/dist"`.
Last step: tell me to restart Claude Code, because it only sees the new server after a restart.

Paste it into Claude Code. It runs the installer and looks for Claude Code: linked, or adds the entry by hand.

Install
curl -fsSL https://excellent.so/install.sh | shIt runs excellent install-agent-mcps, which writes the entry and prints Claude Code: linked.
Restart
Restart Claude Code afterwards: it only sees the new server after a restart.
Undo
Delete the "excellent" entry under "mcpServers" in ~/.claude.json, then restart Claude Code.
Config file
  • macOS~/.claude.json
  • Linuxthe same pathnot supported yet
  • Windows%USERPROFILE%\.claude.jsonnot supported yet
Format
JSON, under mcpServers as excellent
Detected by
the claude binary
Source
packages/core/src/agent-clis.ts:564
Claude Code docs

Claude Code on its own page

CursorAnysphere~/.cursor/mcp.jsonJSONmcpServersCursor Agent: linked

Cursor

Anysphere JSON · ~/.cursor/mcp.json

Set up Excellent (excellent.so) in Cursor for me. First run: curl -fsSL https://excellent.so/install.sh | sh
If its output has a line starting "Cursor Agent: linked" or "Cursor Agent: already-linked", skip to the last step.
Otherwise open ~/.cursor/mcp.json (create it as {} if it is missing) and add this under the top-level "mcpServers" object, creating that object if needed and keeping everything else in the file unchanged:
"excellent": {"type":"stdio","command":"/absolute/path/to/node","args":["/absolute/path/to/@excellent-so/cli/dist/server.js"],"cwd":"/absolute/path/to/@excellent-so/cli/dist","env":{}}
Replace /absolute/path/to/node with the output of `node -p process.execPath`, and /absolute/path/to/@excellent-so/cli/dist with the output of `echo "$(npm root -g)/@excellent-so/cli/dist"`.
Last step: tell me to restart Cursor, because it only sees the new server after a restart.

Paste it into Cursor. It runs the installer and looks for Cursor Agent: linked, or adds the entry by hand.

Install
curl -fsSL https://excellent.so/install.sh | shIt runs excellent install-agent-mcps, which writes the entry and prints Cursor Agent: linked.
Restart
Restart Cursor afterwards: it only sees the new server after a restart.
Undo
Delete the "excellent" entry under "mcpServers" in ~/.cursor/mcp.json, then restart Cursor.
Config file
  • macOS~/.cursor/mcp.json
  • Linuxthe same pathnot supported yet
  • Windows%USERPROFILE%\.cursor\mcp.jsonnot supported yet
Format
JSON, under mcpServers as excellent
Detected by
the cursor-agent binary or Cursor.app
Source
packages/core/src/agent-clis.ts:771
Cursor docs

Cursor on its own page

CodexOpenAI~/.codex/config.tomlTOML[mcp_servers.excellent]Codex: linked

Codex

OpenAI TOML · ~/.codex/config.toml

Set up Excellent (excellent.so) in Codex for me. First run: curl -fsSL https://excellent.so/install.sh | sh
If its output has a line starting "Codex: linked" or "Codex: already-linked", skip to the last step.
Otherwise add this block to ~/.codex/config.toml (create the file if it is missing; if it already has an [mcp_servers.excellent] block, replace only that block):
[mcp_servers.excellent]
command = "/absolute/path/to/node"
args = [ "/absolute/path/to/@excellent-so/cli/dist/server.js" ]
cwd = "/absolute/path/to/@excellent-so/cli/dist"
env = {}
Replace /absolute/path/to/node with the output of `node -p process.execPath`, and /absolute/path/to/@excellent-so/cli/dist with the output of `echo "$(npm root -g)/@excellent-so/cli/dist"`.
Last step: tell me to restart Codex, because it only sees the new server after a restart.

Paste it into Codex. It runs the installer and looks for Codex: linked, or adds the entry by hand.

Install
curl -fsSL https://excellent.so/install.sh | shIt runs excellent install-agent-mcps, which writes the entry and prints Codex: linked.
Restart
Restart Codex afterwards: it only sees the new server after a restart.
Undo
Delete the [mcp_servers.excellent] block from ~/.codex/config.toml, then restart Codex.
Config file
  • macOS~/.codex/config.toml
  • Linuxthe same pathnot supported yet
  • Windows%USERPROFILE%\.codex\config.tomlnot supported yet
Format
TOML, under [mcp_servers.excellent] as excellent
Detected by
the codex binary or Codex.app
Source
packages/core/src/agent-clis.ts:582
Codex docs

Codex on its own page

Gemini CLIGoogle~/.gemini/settings.jsonJSONmcpServersGemini CLI: linked

Gemini CLI

Google JSON · ~/.gemini/settings.json

Set up Excellent (excellent.so) in Gemini CLI for me. First run: curl -fsSL https://excellent.so/install.sh | sh
If its output has a line starting "Gemini CLI: linked" or "Gemini CLI: already-linked", skip to the last step.
Otherwise open ~/.gemini/settings.json (create it as {} if it is missing) and add this under the top-level "mcpServers" object, creating that object if needed and keeping everything else in the file unchanged:
"excellent": {"type":"stdio","command":"/absolute/path/to/node","args":["/absolute/path/to/@excellent-so/cli/dist/server.js"],"cwd":"/absolute/path/to/@excellent-so/cli/dist","env":{}}
Replace /absolute/path/to/node with the output of `node -p process.execPath`, and /absolute/path/to/@excellent-so/cli/dist with the output of `echo "$(npm root -g)/@excellent-so/cli/dist"`.
Last step: tell me to restart Gemini CLI, because it only sees the new server after a restart.

Paste it into Gemini CLI. It runs the installer and looks for Gemini CLI: linked, or adds the entry by hand.

Install
curl -fsSL https://excellent.so/install.sh | shIt runs excellent install-agent-mcps, which writes the entry and prints Gemini CLI: linked.
Restart
Restart Gemini CLI afterwards: it only sees the new server after a restart.
Undo
Delete the "excellent" entry under "mcpServers" in ~/.gemini/settings.json, then restart Gemini CLI.
Config file
  • macOS~/.gemini/settings.json
  • Linuxthe same pathnot supported yet
  • Windows%USERPROFILE%\.gemini\settings.jsonnot supported yet
Format
JSON, under mcpServers as excellent
Detected by
the gemini binary
Source
packages/core/src/agent-clis.ts:602
Gemini CLI docs

Gemini CLI on its own page

GitHub Copilot CLIGitHub~/.copilot/mcp-config.jsonJSONmcpServersGitHub Copilot CLI: linked

GitHub Copilot CLI

GitHub JSON · ~/.copilot/mcp-config.json

Set up Excellent (excellent.so) in GitHub Copilot CLI for me. First run: curl -fsSL https://excellent.so/install.sh | sh
If its output has a line starting "GitHub Copilot CLI: linked" or "GitHub Copilot CLI: already-linked", skip to the last step.
Otherwise open ~/.copilot/mcp-config.json (create it as {} if it is missing) and add this under the top-level "mcpServers" object, creating that object if needed and keeping everything else in the file unchanged:
"excellent": {"type":"stdio","command":"/absolute/path/to/node","args":["/absolute/path/to/@excellent-so/cli/dist/server.js"],"cwd":"/absolute/path/to/@excellent-so/cli/dist","env":{}}
Replace /absolute/path/to/node with the output of `node -p process.execPath`, and /absolute/path/to/@excellent-so/cli/dist with the output of `echo "$(npm root -g)/@excellent-so/cli/dist"`.
Last step: tell me to restart GitHub Copilot CLI, because it only sees the new server after a restart.

Paste it into GitHub Copilot CLI. It runs the installer and looks for GitHub Copilot CLI: linked, or adds the entry by hand.

Install
curl -fsSL https://excellent.so/install.sh | shIt runs excellent install-agent-mcps, which writes the entry and prints GitHub Copilot CLI: linked.
Restart
Restart GitHub Copilot CLI afterwards: it only sees the new server after a restart.
Undo
Delete the "excellent" entry under "mcpServers" in ~/.copilot/mcp-config.json, then restart GitHub Copilot CLI.
Config file
  • macOS~/.copilot/mcp-config.json
  • Linuxthe same pathnot supported yet
  • Windows%USERPROFILE%\.copilot\mcp-config.jsonnot supported yet
Format
JSON, under mcpServers as excellent
Detected by
the copilot binary
Source
packages/core/src/agent-clis.ts:793
GitHub Copilot CLI docs

GitHub Copilot CLI on its own page

WindsurfWindsurf~/.codeium/windsurf/mcp_config.jsonJSONmcpServersWindsurf Cascade: linked

Windsurf

Windsurf JSON · ~/.codeium/windsurf/mcp_config.json

Set up Excellent (excellent.so) in Windsurf for me. First run: curl -fsSL https://excellent.so/install.sh | sh
If its output has a line starting "Windsurf Cascade: linked" or "Windsurf Cascade: already-linked", skip to the last step.
Otherwise open ~/.codeium/windsurf/mcp_config.json (create it as {} if it is missing) and add this under the top-level "mcpServers" object, creating that object if needed and keeping everything else in the file unchanged:
"excellent": {"type":"stdio","command":"/absolute/path/to/node","args":["/absolute/path/to/@excellent-so/cli/dist/server.js"],"cwd":"/absolute/path/to/@excellent-so/cli/dist","env":{}}
Replace /absolute/path/to/node with the output of `node -p process.execPath`, and /absolute/path/to/@excellent-so/cli/dist with the output of `echo "$(npm root -g)/@excellent-so/cli/dist"`.
Last step: tell me to restart Windsurf, because it only sees the new server after a restart.

Paste it into Windsurf. It runs the installer and looks for Windsurf Cascade: linked, or adds the entry by hand.

Install
curl -fsSL https://excellent.so/install.sh | shIt runs excellent install-agent-mcps, which writes the entry and prints Windsurf Cascade: linked.
Restart
Restart Windsurf afterwards: it only sees the new server after a restart.
Undo
Delete the "excellent" entry under "mcpServers" in ~/.codeium/windsurf/mcp_config.json, then restart Windsurf.
Config file
  • macOS~/.codeium/windsurf/mcp_config.json
  • Linuxthe same pathnot supported yet
  • Windows%USERPROFILE%\.codeium\windsurf\mcp_config.jsonnot supported yet
Format
JSON, under mcpServers as excellent
Detected by
the windsurf binary or Windsurf.app
Source
packages/core/src/agent-clis.ts:1281
Windsurf docs

Windsurf on its own page

AmpAmp~/.config/amp/settings.jsonJSONamp.mcpServersAmp: linked

Amp

Amp JSON · ~/.config/amp/settings.json

Set up Excellent (excellent.so) in Amp for me. First run: curl -fsSL https://excellent.so/install.sh | sh
If its output has a line starting "Amp: linked" or "Amp: already-linked", skip to the last step.
Otherwise open ~/.config/amp/settings.json (create it as {} if it is missing) and add this under the top-level "amp.mcpServers" object, creating that object if needed and keeping everything else in the file unchanged:
"excellent": {"command":"/absolute/path/to/node","args":["/absolute/path/to/@excellent-so/cli/dist/server.js"],"cwd":"/absolute/path/to/@excellent-so/cli/dist","env":{}}
Replace /absolute/path/to/node with the output of `node -p process.execPath`, and /absolute/path/to/@excellent-so/cli/dist with the output of `echo "$(npm root -g)/@excellent-so/cli/dist"`.
Last step: tell me to restart Amp, because it only sees the new server after a restart.

Paste it into Amp. It runs the installer and looks for Amp: linked, or adds the entry by hand.

Install
curl -fsSL https://excellent.so/install.sh | shIt runs excellent install-agent-mcps, which writes the entry and prints Amp: linked.
Restart
Restart Amp afterwards: it only sees the new server after a restart.
Undo
Delete the "excellent" entry under "amp.mcpServers" in ~/.config/amp/settings.json, then restart Amp.
Config file
  • macOS~/.config/amp/settings.json
  • Linuxthe same pathnot supported yet
  • Windows%USERPROFILE%\.config\amp\settings.jsonnot supported yet
Format
JSON, under amp.mcpServers as excellent
Detected by
the amp binary
Source
packages/core/src/agent-clis.ts:825
Amp docs

Amp on its own page

Antigravity CLIGoogle~/.gemini/config/mcp_config.jsonJSONmcpServersAntigravity CLI: linked

Antigravity CLI

Google JSON · ~/.gemini/config/mcp_config.json

Set up Excellent (excellent.so) in Antigravity CLI for me. First run: curl -fsSL https://excellent.so/install.sh | sh
If its output has a line starting "Antigravity CLI: linked" or "Antigravity CLI: already-linked", skip to the last step.
Otherwise open ~/.gemini/config/mcp_config.json (create it as {} if it is missing) and add this under the top-level "mcpServers" object, creating that object if needed and keeping everything else in the file unchanged:
"excellent": {"type":"stdio","command":"/absolute/path/to/node","args":["/absolute/path/to/@excellent-so/cli/dist/server.js"],"cwd":"/absolute/path/to/@excellent-so/cli/dist","env":{}}
Replace /absolute/path/to/node with the output of `node -p process.execPath`, and /absolute/path/to/@excellent-so/cli/dist with the output of `echo "$(npm root -g)/@excellent-so/cli/dist"`.
Last step: tell me to restart Antigravity CLI, because it only sees the new server after a restart.

Paste it into Antigravity CLI. It runs the installer and looks for Antigravity CLI: linked, or adds the entry by hand.

Install
curl -fsSL https://excellent.so/install.sh | shIt runs excellent install-agent-mcps, which writes the entry and prints Antigravity CLI: linked.
Restart
Restart Antigravity CLI afterwards: it only sees the new server after a restart.
Undo
Delete the "excellent" entry under "mcpServers" in ~/.gemini/config/mcp_config.json, then restart Antigravity CLI.
Config file
  • macOS~/.gemini/config/mcp_config.json
  • Linuxthe same pathnot supported yet
  • Windows%USERPROFILE%\.gemini\config\mcp_config.jsonnot supported yet
Format
JSON, under mcpServers as excellent
Detected by
the agy binary or the antigravity binary
Source
packages/core/src/agent-clis.ts:621
Antigravity CLI docs

Antigravity CLI on its own page

AuggieAugment Code~/.augment/settings.jsonJSONmcpServersAuggie CLI: linked

Auggie

Augment Code JSON · ~/.augment/settings.json

Set up Excellent (excellent.so) in Auggie for me. First run: curl -fsSL https://excellent.so/install.sh | sh
If its output has a line starting "Auggie CLI: linked" or "Auggie CLI: already-linked", skip to the last step.
Otherwise open ~/.augment/settings.json (create it as {} if it is missing) and add this under the top-level "mcpServers" object, creating that object if needed and keeping everything else in the file unchanged:
"excellent": {"type":"stdio","command":"/absolute/path/to/node","args":["/absolute/path/to/@excellent-so/cli/dist/server.js"],"cwd":"/absolute/path/to/@excellent-so/cli/dist","env":{}}
Replace /absolute/path/to/node with the output of `node -p process.execPath`, and /absolute/path/to/@excellent-so/cli/dist with the output of `echo "$(npm root -g)/@excellent-so/cli/dist"`.
Last step: tell me to restart Auggie, because it only sees the new server after a restart.

Paste it into Auggie. It runs the installer and looks for Auggie CLI: linked, or adds the entry by hand.

Install
curl -fsSL https://excellent.so/install.sh | shIt runs excellent install-agent-mcps, which writes the entry and prints Auggie CLI: linked.
Restart
Restart Auggie afterwards: it only sees the new server after a restart.
Undo
Delete the "excellent" entry under "mcpServers" in ~/.augment/settings.json, then restart Auggie.
Config file
  • macOS~/.augment/settings.json
  • Linuxthe same pathnot supported yet
  • Windows%USERPROFILE%\.augment\settings.jsonnot supported yet
Format
JSON, under mcpServers as excellent
Detected by
the auggie binary
Source
packages/core/src/agent-clis.ts:843
Auggie docs

Auggie on its own page

ClineCline~/.cline/data/settings/cline_mcp_settings.jsonJSONmcpServersCline CLI: linked

Cline

Cline JSON · ~/.cline/data/settings/cline_mcp_settings.json

Set up Excellent (excellent.so) in Cline for me. First run: curl -fsSL https://excellent.so/install.sh | sh
If its output has a line starting "Cline CLI: linked" or "Cline CLI: already-linked", skip to the last step.
Otherwise open ~/.cline/data/settings/cline_mcp_settings.json (create it as {} if it is missing) and add this under the top-level "mcpServers" object, creating that object if needed and keeping everything else in the file unchanged:
"excellent": {"type":"stdio","command":"/absolute/path/to/node","args":["/absolute/path/to/@excellent-so/cli/dist/server.js"],"cwd":"/absolute/path/to/@excellent-so/cli/dist","env":{}}
Replace /absolute/path/to/node with the output of `node -p process.execPath`, and /absolute/path/to/@excellent-so/cli/dist with the output of `echo "$(npm root -g)/@excellent-so/cli/dist"`.
Last step: tell me to restart Cline, because it only sees the new server after a restart.

Paste it into Cline. It runs the installer and looks for Cline CLI: linked, or adds the entry by hand.

Install
curl -fsSL https://excellent.so/install.sh | shIt runs excellent install-agent-mcps, which writes the entry and prints Cline CLI: linked.
Restart
Restart Cline afterwards: it only sees the new server after a restart.
Undo
Delete the "excellent" entry under "mcpServers" in ~/.cline/data/settings/cline_mcp_settings.json, then restart Cline.
Config file
  • macOS~/.cline/data/settings/cline_mcp_settings.json
  • Linuxthe same pathnot supported yet
  • Windows%USERPROFILE%\.cline\data\settings\cline_mcp_settings.jsonnot supported yet
Format
JSON, under mcpServers as excellent
Detected by
the cline binary
Source
packages/core/src/agent-clis.ts:1019
Cline docs

Cline on its own page

CodebuffCodebuff~/.agents/mcp.jsonJSONmcpServersCodebuff: linked

Codebuff

Codebuff JSON · ~/.agents/mcp.json

Set up Excellent (excellent.so) in Codebuff for me. First run: curl -fsSL https://excellent.so/install.sh | sh
If its output has a line starting "Codebuff: linked" or "Codebuff: already-linked", skip to the last step.
Otherwise open ~/.agents/mcp.json (create it as {} if it is missing) and add this under the top-level "mcpServers" object, creating that object if needed and keeping everything else in the file unchanged:
"excellent": {"type":"stdio","command":"/absolute/path/to/node","args":["/absolute/path/to/@excellent-so/cli/dist/server.js"],"cwd":"/absolute/path/to/@excellent-so/cli/dist","env":{}}
Replace /absolute/path/to/node with the output of `node -p process.execPath`, and /absolute/path/to/@excellent-so/cli/dist with the output of `echo "$(npm root -g)/@excellent-so/cli/dist"`.
Last step: tell me to restart Codebuff, because it only sees the new server after a restart.

Paste it into Codebuff. It runs the installer and looks for Codebuff: linked, or adds the entry by hand.

Install
curl -fsSL https://excellent.so/install.sh | shIt runs excellent install-agent-mcps, which writes the entry and prints Codebuff: linked.
Restart
Restart Codebuff afterwards: it only sees the new server after a restart.
Undo
Delete the "excellent" entry under "mcpServers" in ~/.agents/mcp.json, then restart Codebuff.
Config file
  • macOS~/.agents/mcp.json
  • Linuxthe same pathnot supported yet
  • Windows%USERPROFILE%\.agents\mcp.jsonnot supported yet
Format
JSON, under mcpServers as excellent
Detected by
the codebuff binary
Source
packages/core/src/agent-clis.ts:857
Codebuff docs

Codebuff on its own page

CrushCharmbracelet~/.config/crush/crush.jsonJSONmcpCrush: linked

Crush

Charmbracelet JSON · ~/.config/crush/crush.json

Set up Excellent (excellent.so) in Crush for me. First run: curl -fsSL https://excellent.so/install.sh | sh
If its output has a line starting "Crush: linked" or "Crush: already-linked", skip to the last step.
Otherwise open ~/.config/crush/crush.json (create it as {} if it is missing) and add this under the top-level "mcp" object, creating that object if needed and keeping everything else in the file unchanged:
"excellent": {"type":"stdio","command":"/absolute/path/to/node","args":["/absolute/path/to/@excellent-so/cli/dist/server.js"],"cwd":"/absolute/path/to/@excellent-so/cli/dist","env":{}}
Replace /absolute/path/to/node with the output of `node -p process.execPath`, and /absolute/path/to/@excellent-so/cli/dist with the output of `echo "$(npm root -g)/@excellent-so/cli/dist"`.
Last step: tell me to restart Crush, because it only sees the new server after a restart.

Paste it into Crush. It runs the installer and looks for Crush: linked, or adds the entry by hand.

Install
curl -fsSL https://excellent.so/install.sh | shIt runs excellent install-agent-mcps, which writes the entry and prints Crush: linked.
Restart
Restart Crush afterwards: it only sees the new server after a restart.
Undo
Delete the "excellent" entry under "mcp" in ~/.config/crush/crush.json, then restart Crush.
Config file
  • macOS~/.config/crush/crush.json
  • Linuxthe same pathnot supported yet
  • Windows%USERPROFILE%\.config\crush\crush.jsonnot supported yet
Format
JSON, under mcp as excellent
Detected by
the crush binary
Source
packages/core/src/agent-clis.ts:1109
Crush docs

Crush on its own page

DevinCognition~/.config/devin/mcp_config.jsonJSONmcpServersDevin CLI: linked

Devin

Cognition JSON · ~/.config/devin/mcp_config.json

Set up Excellent (excellent.so) in Devin for me. First run: curl -fsSL https://excellent.so/install.sh | sh
If its output has a line starting "Devin CLI: linked" or "Devin CLI: already-linked", skip to the last step.
Otherwise open ~/.config/devin/mcp_config.json (create it as {} if it is missing) and add this under the top-level "mcpServers" object, creating that object if needed and keeping everything else in the file unchanged:
"excellent": {"type":"stdio","command":"/absolute/path/to/node","args":["/absolute/path/to/@excellent-so/cli/dist/server.js"],"cwd":"/absolute/path/to/@excellent-so/cli/dist","env":{}}
Replace /absolute/path/to/node with the output of `node -p process.execPath`, and /absolute/path/to/@excellent-so/cli/dist with the output of `echo "$(npm root -g)/@excellent-so/cli/dist"`.
Last step: tell me to restart Devin, because it only sees the new server after a restart.

Paste it into Devin. It runs the installer and looks for Devin CLI: linked, or adds the entry by hand.

Install
curl -fsSL https://excellent.so/install.sh | shIt runs excellent install-agent-mcps, which writes the entry and prints Devin CLI: linked.
Restart
Restart Devin afterwards: it only sees the new server after a restart.
Undo
Delete the "excellent" entry under "mcpServers" in ~/.config/devin/mcp_config.json, then restart Devin.
Config file
  • macOS~/.config/devin/mcp_config.json
  • Linuxthe same pathnot supported yet
  • Windows%USERPROFILE%\AppData\Roaming\devin\mcp_config.jsonnot supported yet
Format
JSON, under mcpServers as excellent
Detected by
the devin binary
Source
packages/core/src/agent-clis.ts:1037
Devin docs

Devin on its own page

DroidFactory~/.factory/mcp.jsonJSONmcpServersFactory Droid: linked

Droid

Factory JSON · ~/.factory/mcp.json

Set up Excellent (excellent.so) in Droid for me. First run: curl -fsSL https://excellent.so/install.sh | sh
If its output has a line starting "Factory Droid: linked" or "Factory Droid: already-linked", skip to the last step.
Otherwise open ~/.factory/mcp.json (create it as {} if it is missing) and add this under the top-level "mcpServers" object, creating that object if needed and keeping everything else in the file unchanged:
"excellent": {"type":"stdio","command":"/absolute/path/to/node","args":["/absolute/path/to/@excellent-so/cli/dist/server.js"],"cwd":"/absolute/path/to/@excellent-so/cli/dist","env":{}}
Replace /absolute/path/to/node with the output of `node -p process.execPath`, and /absolute/path/to/@excellent-so/cli/dist with the output of `echo "$(npm root -g)/@excellent-so/cli/dist"`.
Last step: tell me to restart Droid, because it only sees the new server after a restart.

Paste it into Droid. It runs the installer and looks for Factory Droid: linked, or adds the entry by hand.

Install
curl -fsSL https://excellent.so/install.sh | shIt runs excellent install-agent-mcps, which writes the entry and prints Factory Droid: linked.
Restart
Restart Droid afterwards: it only sees the new server after a restart.
Undo
Delete the "excellent" entry under "mcpServers" in ~/.factory/mcp.json, then restart Droid.
Config file
  • macOS~/.factory/mcp.json
  • Linuxthe same pathnot supported yet
  • Windows%USERPROFILE%\.factory\mcp.jsonnot supported yet
Format
JSON, under mcpServers as excellent
Detected by
the droid binary
Source
packages/core/src/agent-clis.ts:1006
Droid docs

Droid on its own page

GitLab Duo CLIGitLab~/.gitlab/duo/mcp.jsonJSONmcpServersGitLab Duo CLI: linked

GitLab Duo CLI

GitLab JSON · ~/.gitlab/duo/mcp.json

Set up Excellent (excellent.so) in GitLab Duo CLI for me. First run: curl -fsSL https://excellent.so/install.sh | sh
If its output has a line starting "GitLab Duo CLI: linked" or "GitLab Duo CLI: already-linked", skip to the last step.
Otherwise open ~/.gitlab/duo/mcp.json (create it as {} if it is missing) and add this under the top-level "mcpServers" object, creating that object if needed and keeping everything else in the file unchanged:
"excellent": {"type":"stdio","command":"/absolute/path/to/node","args":["/absolute/path/to/@excellent-so/cli/dist/server.js"],"cwd":"/absolute/path/to/@excellent-so/cli/dist","env":{}}
Replace /absolute/path/to/node with the output of `node -p process.execPath`, and /absolute/path/to/@excellent-so/cli/dist with the output of `echo "$(npm root -g)/@excellent-so/cli/dist"`.
Last step: tell me to restart GitLab Duo CLI, because it only sees the new server after a restart.

Paste it into GitLab Duo CLI. It runs the installer and looks for GitLab Duo CLI: linked, or adds the entry by hand.

Install
curl -fsSL https://excellent.so/install.sh | shIt runs excellent install-agent-mcps, which writes the entry and prints GitLab Duo CLI: linked.
Restart
Restart GitLab Duo CLI afterwards: it only sees the new server after a restart.
Undo
Delete the "excellent" entry under "mcpServers" in ~/.gitlab/duo/mcp.json, then restart GitLab Duo CLI.
Config file
  • macOS~/.gitlab/duo/mcp.json
  • Linuxthe same pathnot supported yet
  • Windows%USERPROFILE%\AppData\Roaming\GitLab\duo\mcp.jsonnot supported yet
Format
JSON, under mcpServers as excellent
Detected by
the duo binary
Source
packages/core/src/agent-clis.ts:809
GitLab Duo CLI docs

GitLab Duo CLI on its own page

gooseAgentic AI Foundation~/.config/goose/config.yamlYAMLextensionsgoose: linked

goose

Agentic AI Foundation YAML · ~/.config/goose/config.yaml

Set up Excellent (excellent.so) in goose for me. First run: curl -fsSL https://excellent.so/install.sh | sh
If its output has a line starting "goose: linked" or "goose: already-linked", skip to the last step.
Otherwise add this to ~/.config/goose/config.yaml (create the file if it is missing). If the file already has a top-level extensions: map, put the excellent: entry inside it; keep everything else unchanged:
extensions:
  excellent:
    type: "stdio"
    name: "Excellent"
    enabled: true
    cmd: "/absolute/path/to/node"
    cwd: "/absolute/path/to/@excellent-so/cli/dist"
    args:
      - "/absolute/path/to/@excellent-so/cli/dist/server.js"
    env_keys: []
    envs: {}
    timeout: 300
Replace /absolute/path/to/node with the output of `node -p process.execPath`, and /absolute/path/to/@excellent-so/cli/dist with the output of `echo "$(npm root -g)/@excellent-so/cli/dist"`.
Last step: tell me to restart goose, because it only sees the new server after a restart.

Paste it into goose. It runs the installer and looks for goose: linked, or adds the entry by hand.

Install
curl -fsSL https://excellent.so/install.sh | shIt runs excellent install-agent-mcps, which writes the entry and prints goose: linked.
Restart
Restart goose afterwards: it only sees the new server after a restart.
Undo
Delete the excellent: entry under extensions: in ~/.config/goose/config.yaml, then restart goose.
Config file
  • macOS~/.config/goose/config.yaml
  • Linuxthe same pathnot supported yet
  • Windows%USERPROFILE%\AppData\Roaming\Block\goose\config\config.yamlnot supported yet
Format
YAML, under extensions as excellent
Detected by
the goose binary
Source
packages/core/src/agent-clis.ts:948
goose docs

goose on its own page

Grok BuildxAI~/.grok/config.tomlTOML[mcp_servers.excellent]Grok Build: linked

Grok Build

xAI TOML · ~/.grok/config.toml

Set up Excellent (excellent.so) in Grok Build for me. First run: curl -fsSL https://excellent.so/install.sh | sh
If its output has a line starting "Grok Build: linked" or "Grok Build: already-linked", skip to the last step.
Otherwise add this block to ~/.grok/config.toml (create the file if it is missing; if it already has an [mcp_servers.excellent] block, replace only that block):
[mcp_servers.excellent]
command = "/absolute/path/to/node"
args = [ "/absolute/path/to/@excellent-so/cli/dist/server.js" ]
cwd = "/absolute/path/to/@excellent-so/cli/dist"
env = {}
Replace /absolute/path/to/node with the output of `node -p process.execPath`, and /absolute/path/to/@excellent-so/cli/dist with the output of `echo "$(npm root -g)/@excellent-so/cli/dist"`.
Last step: tell me to restart Grok Build, because it only sees the new server after a restart.

Paste it into Grok Build. It runs the installer and looks for Grok Build: linked, or adds the entry by hand.

Install
curl -fsSL https://excellent.so/install.sh | shIt runs excellent install-agent-mcps, which writes the entry and prints Grok Build: linked.
Restart
Restart Grok Build afterwards: it only sees the new server after a restart.
Undo
Delete the [mcp_servers.excellent] block from ~/.grok/config.toml, then restart Grok Build.
Config file
  • macOS~/.grok/config.toml
  • Linuxthe same pathnot supported yet
  • Windows%USERPROFILE%\.grok\config.tomlnot supported yet
Format
TOML, under [mcp_servers.excellent] as excellent
Detected by
the grok binary
Source
packages/core/src/agent-clis.ts:640
Grok Build docs

Grok Build on its own page

Hermes AgentNous Research~/.hermes/config.yamlYAMLmcp_serversHermes Agent: linked

Hermes Agent

Nous Research YAML · ~/.hermes/config.yaml

Set up Excellent (excellent.so) in Hermes Agent for me. First run: curl -fsSL https://excellent.so/install.sh | sh
If its output has a line starting "Hermes Agent: linked" or "Hermes Agent: already-linked", skip to the last step.
Otherwise add this to ~/.hermes/config.yaml (create the file if it is missing). If the file already has a top-level mcp_servers: map, put the excellent: entry inside it; keep everything else unchanged:
mcp_servers:
  excellent:
    command: "/absolute/path/to/node"
    cwd: "/absolute/path/to/@excellent-so/cli/dist"
    args:
      - "/absolute/path/to/@excellent-so/cli/dist/server.js"
    env: {}
Replace /absolute/path/to/node with the output of `node -p process.execPath`, and /absolute/path/to/@excellent-so/cli/dist with the output of `echo "$(npm root -g)/@excellent-so/cli/dist"`.
Last step: tell me to restart Hermes Agent, because it only sees the new server after a restart.

Paste it into Hermes Agent. It runs the installer and looks for Hermes Agent: linked, or adds the entry by hand.

Install
curl -fsSL https://excellent.so/install.sh | shIt runs excellent install-agent-mcps, which writes the entry and prints Hermes Agent: linked.
Restart
Restart Hermes Agent afterwards: it only sees the new server after a restart.
Undo
Delete the excellent: entry under mcp_servers: in ~/.hermes/config.yaml, then restart Hermes Agent.
Config file
  • macOS~/.hermes/config.yaml
  • Linuxthe same pathnot supported yet
  • Windows%USERPROFILE%\.hermes\config.yamlnot supported yet
Format
YAML, under mcp_servers as excellent
Detected by
the hermes binary
Source
packages/core/src/agent-clis.ts:671
Hermes Agent docs

Hermes Agent on its own page

JunieJetBrains~/.junie/mcp/mcp.jsonJSONmcpServersJunie CLI: linked

Junie

JetBrains JSON · ~/.junie/mcp/mcp.json

Set up Excellent (excellent.so) in Junie for me. First run: curl -fsSL https://excellent.so/install.sh | sh
If its output has a line starting "Junie CLI: linked" or "Junie CLI: already-linked", skip to the last step.
Otherwise open ~/.junie/mcp/mcp.json (create it as {} if it is missing) and add this under the top-level "mcpServers" object, creating that object if needed and keeping everything else in the file unchanged:
"excellent": {"type":"stdio","command":"/absolute/path/to/node","args":["/absolute/path/to/@excellent-so/cli/dist/server.js"],"cwd":"/absolute/path/to/@excellent-so/cli/dist","env":{}}
Replace /absolute/path/to/node with the output of `node -p process.execPath`, and /absolute/path/to/@excellent-so/cli/dist with the output of `echo "$(npm root -g)/@excellent-so/cli/dist"`.
Last step: tell me to restart Junie, because it only sees the new server after a restart.

Paste it into Junie. It runs the installer and looks for Junie CLI: linked, or adds the entry by hand.

Install
curl -fsSL https://excellent.so/install.sh | shIt runs excellent install-agent-mcps, which writes the entry and prints Junie CLI: linked.
Restart
Restart Junie afterwards: it only sees the new server after a restart.
Undo
Delete the "excellent" entry under "mcpServers" in ~/.junie/mcp/mcp.json, then restart Junie.
Config file
  • macOS~/.junie/mcp/mcp.json
  • Linuxthe same pathnot supported yet
  • Windows%USERPROFILE%\.junie\mcp\mcp.jsonnot supported yet
Format
JSON, under mcpServers as excellent
Detected by
the junie binary
Source
packages/core/src/agent-clis.ts:904
Junie docs

Junie on its own page

Kilo Code CLIKilo~/.config/kilo/kilo.jsonJSONmcpKilo Code CLI: linked

Kilo Code CLI

Kilo JSON · ~/.config/kilo/kilo.json

Set up Excellent (excellent.so) in Kilo Code CLI for me. First run: curl -fsSL https://excellent.so/install.sh | sh
If its output has a line starting "Kilo Code CLI: linked" or "Kilo Code CLI: already-linked", skip to the last step.
Otherwise open ~/.config/kilo/kilo.json (create it as {} if it is missing) and add this under the top-level "mcp" object, creating that object if needed and keeping everything else in the file unchanged:
"excellent": {"type":"local","command":["/absolute/path/to/node","/absolute/path/to/@excellent-so/cli/dist/server.js"],"cwd":"/absolute/path/to/@excellent-so/cli/dist","environment":{},"enabled":true}
If the file nests servers under "mcp": {"servers": {...}}, put it there instead, with "disabled": false in place of "enabled": true.
Replace /absolute/path/to/node with the output of `node -p process.execPath`, and /absolute/path/to/@excellent-so/cli/dist with the output of `echo "$(npm root -g)/@excellent-so/cli/dist"`.
Last step: tell me to restart Kilo Code CLI, because it only sees the new server after a restart.

Paste it into Kilo Code CLI. It runs the installer and looks for Kilo Code CLI: linked, or adds the entry by hand.

Install
curl -fsSL https://excellent.so/install.sh | shIt runs excellent install-agent-mcps, which writes the entry and prints Kilo Code CLI: linked.
Restart
Restart Kilo Code CLI afterwards: it only sees the new server after a restart.
Undo
Delete the "excellent" entry under "mcp" in ~/.config/kilo/kilo.json, then restart Kilo Code CLI.
Config file
  • macOS~/.config/kilo/kilo.json
  • Linuxthe same pathnot supported yet
  • Windows%USERPROFILE%\.config\kilo\kilo.jsonnot supported yet
Format
JSON, under mcp as excellent
Detected by
the kilo binary
Source
packages/core/src/agent-clis.ts:737
Kilo Code CLI docs

Kilo Code CLI on its own page

KimiMoonshot AI~/.kimi-code/mcp.jsonJSONmcpServersKimi Code CLI: linked

Kimi

Moonshot AI JSON · ~/.kimi-code/mcp.json

Set up Excellent (excellent.so) in Kimi for me. First run: curl -fsSL https://excellent.so/install.sh | sh
If its output has a line starting "Kimi Code CLI: linked" or "Kimi Code CLI: already-linked", skip to the last step.
Otherwise open ~/.kimi-code/mcp.json (create it as {} if it is missing) and add this under the top-level "mcpServers" object, creating that object if needed and keeping everything else in the file unchanged:
"excellent": {"type":"stdio","command":"/absolute/path/to/node","args":["/absolute/path/to/@excellent-so/cli/dist/server.js"],"cwd":"/absolute/path/to/@excellent-so/cli/dist","env":{}}
Replace /absolute/path/to/node with the output of `node -p process.execPath`, and /absolute/path/to/@excellent-so/cli/dist with the output of `echo "$(npm root -g)/@excellent-so/cli/dist"`.
Last step: tell me to restart Kimi, because it only sees the new server after a restart.

Paste it into Kimi. It runs the installer and looks for Kimi Code CLI: linked, or adds the entry by hand.

Install
curl -fsSL https://excellent.so/install.sh | shIt runs excellent install-agent-mcps, which writes the entry and prints Kimi Code CLI: linked.
Restart
Restart Kimi afterwards: it only sees the new server after a restart.
Undo
Delete the "excellent" entry under "mcpServers" in ~/.kimi-code/mcp.json, then restart Kimi.
Config file
  • macOS~/.kimi-code/mcp.json
  • Linuxthe same pathnot supported yet
  • Windows%USERPROFILE%\.kimi-code\mcp.jsonnot supported yet
Format
JSON, under mcpServers as excellent
Detected by
the kimi binary
Source
packages/core/src/agent-clis.ts:987
Kimi docs

Kimi on its own page

KiroAWS~/.kiro/settings/mcp.jsonJSONmcpServersKiro CLI: linked

Kiro

AWS JSON · ~/.kiro/settings/mcp.json

Set up Excellent (excellent.so) in Kiro for me. First run: curl -fsSL https://excellent.so/install.sh | sh
If its output has a line starting "Kiro CLI: linked" or "Kiro CLI: already-linked", skip to the last step.
Otherwise open ~/.kiro/settings/mcp.json (create it as {} if it is missing) and add this under the top-level "mcpServers" object, creating that object if needed and keeping everything else in the file unchanged:
"excellent": {"type":"stdio","command":"/absolute/path/to/node","args":["/absolute/path/to/@excellent-so/cli/dist/server.js"],"cwd":"/absolute/path/to/@excellent-so/cli/dist","env":{}}
Replace /absolute/path/to/node with the output of `node -p process.execPath`, and /absolute/path/to/@excellent-so/cli/dist with the output of `echo "$(npm root -g)/@excellent-so/cli/dist"`.
Last step: tell me to restart Kiro, because it only sees the new server after a restart.

Paste it into Kiro. It runs the installer and looks for Kiro CLI: linked, or adds the entry by hand.

Install
curl -fsSL https://excellent.so/install.sh | shIt runs excellent install-agent-mcps, which writes the entry and prints Kiro CLI: linked.
Restart
Restart Kiro afterwards: it only sees the new server after a restart.
Undo
Delete the "excellent" entry under "mcpServers" in ~/.kiro/settings/mcp.json, then restart Kiro.
Config file
  • macOS~/.kiro/settings/mcp.json
  • Linuxthe same pathnot supported yet
  • Windows%USERPROFILE%\.kiro\settings\mcp.jsonnot supported yet
Format
JSON, under mcpServers as excellent
Detected by
the kiro-cli binary or the kiro binary
Source
packages/core/src/agent-clis.ts:1078
Kiro docs

Kiro on its own page

Amazon QAWS~/.aws/amazonq/mcp.jsonJSONmcpServersAmazon Q Developer CLI: linked

Amazon Q

AWS JSON · ~/.aws/amazonq/mcp.json

Set up Excellent (excellent.so) in Amazon Q for me. First run: curl -fsSL https://excellent.so/install.sh | sh
If its output has a line starting "Amazon Q Developer CLI: linked" or "Amazon Q Developer CLI: already-linked", skip to the last step.
Otherwise open ~/.aws/amazonq/mcp.json (create it as {} if it is missing) and add this under the top-level "mcpServers" object, creating that object if needed and keeping everything else in the file unchanged:
"excellent": {"type":"stdio","command":"/absolute/path/to/node","args":["/absolute/path/to/@excellent-so/cli/dist/server.js"],"cwd":"/absolute/path/to/@excellent-so/cli/dist","env":{}}
Replace /absolute/path/to/node with the output of `node -p process.execPath`, and /absolute/path/to/@excellent-so/cli/dist with the output of `echo "$(npm root -g)/@excellent-so/cli/dist"`.
Last step: tell me to restart Amazon Q, because it only sees the new server after a restart.

Paste it into Amazon Q. It runs the installer and looks for Amazon Q Developer CLI: linked, or adds the entry by hand.

Install
curl -fsSL https://excellent.so/install.sh | shIt runs excellent install-agent-mcps, which writes the entry and prints Amazon Q Developer CLI: linked.
Restart
Restart Amazon Q afterwards: it only sees the new server after a restart.
Undo
Delete the "excellent" entry under "mcpServers" in ~/.aws/amazonq/mcp.json, then restart Amazon Q.
Config file
  • macOS~/.aws/amazonq/mcp.json
  • Linuxthe same pathnot supported yet
  • Windows%USERPROFILE%\.aws\amazonq\mcp.jsonnot supported yet
Format
JSON, under mcpServers as excellent
Detected by
the q binary or a path containing amazon-q or amazonq
Source
packages/core/src/agent-clis.ts:1091
Amazon Q docs

Amazon Q on its own page

Open InterpreterOpen Interpreter~/.openinterpreter/config.tomlTOML[mcp_servers.excellent]Open Interpreter: linked

Open Interpreter

Open Interpreter TOML · ~/.openinterpreter/config.toml

Set up Excellent (excellent.so) in Open Interpreter for me. First run: curl -fsSL https://excellent.so/install.sh | sh
If its output has a line starting "Open Interpreter: linked" or "Open Interpreter: already-linked", skip to the last step.
Otherwise add this block to ~/.openinterpreter/config.toml (create the file if it is missing; if it already has an [mcp_servers.excellent] block, replace only that block):
[mcp_servers.excellent]
command = "/absolute/path/to/node"
args = [ "/absolute/path/to/@excellent-so/cli/dist/server.js" ]
cwd = "/absolute/path/to/@excellent-so/cli/dist"
env = {}
Replace /absolute/path/to/node with the output of `node -p process.execPath`, and /absolute/path/to/@excellent-so/cli/dist with the output of `echo "$(npm root -g)/@excellent-so/cli/dist"`.
Last step: tell me to restart Open Interpreter, because it only sees the new server after a restart.

Paste it into Open Interpreter. It runs the installer and looks for Open Interpreter: linked, or adds the entry by hand.

Install
curl -fsSL https://excellent.so/install.sh | shIt runs excellent install-agent-mcps, which writes the entry and prints Open Interpreter: linked.
Restart
Restart Open Interpreter afterwards: it only sees the new server after a restart.
Undo
Delete the [mcp_servers.excellent] block from ~/.openinterpreter/config.toml, then restart Open Interpreter.
Config file
  • macOS~/.openinterpreter/config.toml
  • Linuxthe same pathnot supported yet
  • Windows%USERPROFILE%\.openinterpreter\config.tomlnot supported yet
Format
TOML, under [mcp_servers.excellent] as excellent
Detected by
the interpreter binary
Source
packages/core/src/agent-clis.ts:1189
Open Interpreter docs

Open Interpreter on its own page

OpenClawOpenClawopenclaw mcp setVendor CLIexcellentOpenClaw: linked

OpenClaw

OpenClaw OpenClaw's own MCP command

Set up Excellent (excellent.so) in OpenClaw for me. First run: curl -fsSL https://excellent.so/install.sh | sh
If its output has a line starting "OpenClaw: linked" or "OpenClaw: already-linked", skip to the last step.
Otherwise run:
openclaw mcp set excellent '{"command":"/absolute/path/to/node","args":["/absolute/path/to/@excellent-so/cli/dist/server.js"],"cwd":"/absolute/path/to/@excellent-so/cli/dist","env":{},"transport":"stdio"}'
Replace /absolute/path/to/node with the output of `node -p process.execPath`, and /absolute/path/to/@excellent-so/cli/dist with the output of `echo "$(npm root -g)/@excellent-so/cli/dist"`.
Last step: tell me to restart OpenClaw, because it only sees the new server after a restart.

Paste it into OpenClaw. It runs the installer and looks for OpenClaw: linked, or adds the entry by hand.

Install
curl -fsSL https://excellent.so/install.sh | shIt runs excellent install-agent-mcps, which writes the entry and prints OpenClaw: linked.
Restart
Restart OpenClaw afterwards: it only sees the new server after a restart.
Undo
Run `openclaw mcp unset excellent`, then restart OpenClaw.
Config file
  • macOS~/.openclaw/openclaw.json
  • Linuxthe same pathnot supported yet
  • Windows%USERPROFILE%\.openclaw\openclaw.jsonnot supported yet
Format
OpenClaw's own mcp set command
Detected by
the openclaw binary
Source
packages/core/src/agent-clis.ts:710
OpenClaw docs

OpenClaw on its own page

OpenCodeAnomaly~/.config/opencode/opencode.jsonJSONmcpOpenCode: linked

OpenCode

Anomaly JSON · ~/.config/opencode/opencode.json

Set up Excellent (excellent.so) in OpenCode for me. First run: curl -fsSL https://excellent.so/install.sh | sh
If its output has a line starting "OpenCode: linked" or "OpenCode: already-linked", skip to the last step.
Otherwise open ~/.config/opencode/opencode.json (create it as {} if it is missing) and add this under the top-level "mcp" object, creating that object if needed and keeping everything else in the file unchanged:
"excellent": {"type":"local","command":["/absolute/path/to/node","/absolute/path/to/@excellent-so/cli/dist/server.js"],"cwd":"/absolute/path/to/@excellent-so/cli/dist","environment":{},"enabled":true}
If the file nests servers under "mcp": {"servers": {...}}, put it there instead, with "disabled": false in place of "enabled": true.
Replace /absolute/path/to/node with the output of `node -p process.execPath`, and /absolute/path/to/@excellent-so/cli/dist with the output of `echo "$(npm root -g)/@excellent-so/cli/dist"`.
Last step: tell me to restart OpenCode, because it only sees the new server after a restart.

Paste it into OpenCode. It runs the installer and looks for OpenCode: linked, or adds the entry by hand.

Install
curl -fsSL https://excellent.so/install.sh | shIt runs excellent install-agent-mcps, which writes the entry and prints OpenCode: linked.
Restart
Restart OpenCode afterwards: it only sees the new server after a restart.
Undo
Delete the "excellent" entry under "mcp" in ~/.config/opencode/opencode.json, then restart OpenCode.
Config file
  • macOS~/.config/opencode/opencode.json
  • Linuxthe same pathnot supported yet
  • Windows%USERPROFILE%\.config\opencode\opencode.jsonnot supported yet
Format
JSON, under mcp as excellent
Detected by
the opencode binary or the opencode2 binary
Source
packages/core/src/agent-clis.ts:689
OpenCode docs

OpenCode on its own page

Qwen CodeAlibaba Cloud~/.qwen/settings.jsonJSONmcpServersQwen Code: linked

Qwen Code

Alibaba Cloud JSON · ~/.qwen/settings.json

Set up Excellent (excellent.so) in Qwen Code for me. First run: curl -fsSL https://excellent.so/install.sh | sh
If its output has a line starting "Qwen Code: linked" or "Qwen Code: already-linked", skip to the last step.
Otherwise open ~/.qwen/settings.json (create it as {} if it is missing) and add this under the top-level "mcpServers" object, creating that object if needed and keeping everything else in the file unchanged:
"excellent": {"type":"stdio","command":"/absolute/path/to/node","args":["/absolute/path/to/@excellent-so/cli/dist/server.js"],"cwd":"/absolute/path/to/@excellent-so/cli/dist","env":{}}
Replace /absolute/path/to/node with the output of `node -p process.execPath`, and /absolute/path/to/@excellent-so/cli/dist with the output of `echo "$(npm root -g)/@excellent-so/cli/dist"`.
Last step: tell me to restart Qwen Code, because it only sees the new server after a restart.

Paste it into Qwen Code. It runs the installer and looks for Qwen Code: linked, or adds the entry by hand.

Install
curl -fsSL https://excellent.so/install.sh | shIt runs excellent install-agent-mcps, which writes the entry and prints Qwen Code: linked.
Restart
Restart Qwen Code afterwards: it only sees the new server after a restart.
Undo
Delete the "excellent" entry under "mcpServers" in ~/.qwen/settings.json, then restart Qwen Code.
Config file
  • macOS~/.qwen/settings.json
  • Linuxthe same pathnot supported yet
  • Windows%USERPROFILE%\.qwen\settings.jsonnot supported yet
Format
JSON, under mcpServers as excellent
Detected by
the qwen binary
Source
packages/core/src/agent-clis.ts:967
Qwen Code docs

Qwen Code on its own page

Rovo DevAtlassian~/.rovodev/mcp_config.jsonJSONmcpServersRovo Dev CLI: linked

Rovo Dev

Atlassian JSON · ~/.rovodev/mcp_config.json

Set up Excellent (excellent.so) in Rovo Dev for me. First run: curl -fsSL https://excellent.so/install.sh | sh
If its output has a line starting "Rovo Dev CLI: linked" or "Rovo Dev CLI: already-linked", skip to the last step.
Otherwise open ~/.rovodev/mcp_config.json (create it as {} if it is missing) and add this under the top-level "mcpServers" object, creating that object if needed and keeping everything else in the file unchanged:
"excellent": {"transport":"stdio","command":"/absolute/path/to/node","args":["/absolute/path/to/@excellent-so/cli/dist/server.js"],"cwd":"/absolute/path/to/@excellent-so/cli/dist","env":{}}
Replace /absolute/path/to/node with the output of `node -p process.execPath`, and /absolute/path/to/@excellent-so/cli/dist with the output of `echo "$(npm root -g)/@excellent-so/cli/dist"`.
Last step: tell me to restart Rovo Dev, because it only sees the new server after a restart.

Paste it into Rovo Dev. It runs the installer and looks for Rovo Dev CLI: linked, or adds the entry by hand.

Install
curl -fsSL https://excellent.so/install.sh | shIt runs excellent install-agent-mcps, which writes the entry and prints Rovo Dev CLI: linked.
Restart
Restart Rovo Dev afterwards: it only sees the new server after a restart.
Undo
Delete the "excellent" entry under "mcpServers" in ~/.rovodev/mcp_config.json, then restart Rovo Dev.
Config file
  • macOS~/.rovodev/mcp_config.json
  • Linuxthe same pathnot supported yet
  • Windows%USERPROFILE%\.rovodev\mcp_config.jsonnot supported yet
Format
JSON, under mcpServers as excellent
Detected by
the acli binary, the rovodev binary or acli rovodev --help
Source
packages/core/src/agent-clis.ts:924
Rovo Dev docs

Rovo Dev on its own page

Detected, not configured

The installer knows these 15 agents and attributes their sessions, but writes nothing for them, and offers no prompt.

AgentConfigWhy it is left aloneSource
Mistral VibeMistral AI~/.vibe/config.toml
Refused
Its documented MCP settings do not establish which working directory the server runs in, so the installer will not create a registration it cannot verify as portable.packages/core/src/agent-clis.ts:888
OpenHands CLIAll Hands AI~/.openhands/mcp.json
Refused
Its documented MCP settings do not establish which working directory the server runs in, so the installer will not create a registration it cannot verify as portable.packages/core/src/agent-clis.ts:1057
ZedZed Industries~/.config/zed/settings.json
Refused
Its documented MCP settings do not establish which working directory the server runs in, so the installer will not create a registration it cannot verify as portable.packages/core/src/agent-clis.ts:1296
Grok BotxAI / Cursornone it will write
Detected only
Detected as a desktop control surface only. Work runs on Grok Bot's cloud computer; connect Excellent through the inherited Cursor MCP policy or register it inside that execution environment.packages/core/src/agent-clis.ts:657
Roo Code CLIRoo Codenone it will write
Detected only
The standalone Roo CLI is detectable and attributable. Roo MCP settings are editor/profile or project scoped, so Excellent does not guess a global config path; configure it explicitly or self-register a maintained fork.packages/core/src/agent-clis.ts:757
Sourcegraph Cody CLISourcegraphnone it will write
Detected only
Cody CLI is detectable and attributable; no current persistent MCP client config is documented for safe automatic linking.packages/core/src/agent-clis.ts:876
Continue CLIContinuenone it will write
Detected only
Continue currently sources persistent MCPs from its platform/config; use the self-registration manifest if your deployment exposes a local MCP file.packages/core/src/agent-clis.ts:1124
Jules ToolsGooglenone it will write
Detected only
Excellent detects the local Jules controller, but Jules work executes in a cloud VM; the controller is not treated as proof of a local agent session.packages/core/src/agent-clis.ts:1143
AiderAider AInone it will write
Detected only
Aider has no documented native MCP client; Excellent can detect and attribute the host but cannot inject MCP tools.packages/core/src/agent-clis.ts:1159
PiPinone it will write
Detected only
Pi intentionally ships no native MCP client; Excellent detects and attributes it, while a Pi extension can use the self-registration manifest.packages/core/src/agent-clis.ts:1171
SWE-agentPrinceton NLPnone it will write
Detected only
SWE-agent exposes its own environment/tool bundles rather than a documented persistent MCP client config.packages/core/src/agent-clis.ts:1210
mini-SWE-agentSWE-agentnone it will write
Detected only
Installation is detected through the package-specific mini-extra companion. The generic `mini` basename is not used for identity; interpreter command markers are. No native MCP client is currently documented.packages/core/src/agent-clis.ts:1222
Trae AgentByteDancenone it will write
Detected only
Trae's MCP map lives in the caller-selected project YAML; Excellent detects and attributes it but does not guess which project config to rewrite.packages/core/src/agent-clis.ts:1241
PlandexPlandexnone it will write
Detected only
No documented persistent MCP client registry was found; detection and session attribution are supported.packages/core/src/agent-clis.ts:1253
Warp OzWarpnone it will write
Detected only
Oz accepts MCP configuration per run with --mcp or from Warp's cloud registry; it has no documented local persistent file Excellent can safely rewrite.packages/core/src/agent-clis.ts:1269

02Undo

Each agent comes back out by hand, one entry in one file

Removing the entry is the whole undo. Excellent does not touch the agent's other settings, so there is nothing else to put back.

  • By hand, per agent

    Delete the excellent entry from that agent's config file, then restart the agent. For OpenClaw, run openclaw mcp unset excellent. Every agent on this page carries its own undo line.

  • It stays removed

    After the first setup that succeeds, Excellent records it in ~/.excellent/agent-mcp-first-use-v1.json and never adds a removed entry back by itself. Only an explicit excellent install-agent-mcps writes again.

  • The bulk command

    excellent-mcp uninstall-skills removes the exact entries only in a source checkout. In an install by curl or npm it does not recognize the installer's entries as its own and removes nothing, so use the lines above.

Put Excellent in your agent: install it, restart the agent, run one task

Names and marks belong to their owners. Shown to say Excellent works with these agents, with no endorsement implied.