agent-intern
Summary: agent-intern is an MCP server that lets Claude Code or other MCP hosts delegate work to multiple coding-agent CLIs as sub-agents using existing subscriptions/logins.
Ask or continue sessions with Antigravity/Gemini, Codex, Copilot, Cursor, Claude Code, Grok, Kimi, opencode, and Muse.
Generate one or many images via Antigravity/Gemini and save them to disk.
Run parallel swarms across mixed backends, including preset panels such as jury, research, red-team, and council.
Check backend diagnostics/status without spending quota.
Stream live “watch” views of sub-agent steps.
Control sandbox/permission modes, workspaces, models, timeouts, and Antigravity structured JSON-schema outputs.
Allows using Google's Antigravity (Gemini 3.5 Flash) as a sub-agent inside Claude Code for text answers and image generation, without additional API keys.
agent-intern
Give Claude Code (or Antigravity) an intern.
Delegate to Gemini, Codex, Copilot, Cursor and opencode from inside Claude Code or Antigravity — as sub-agents, on the subscriptions you already pay for. Text answers, image generation, real repo work, parallel swarms.
Quick start · Works in · What it's for · Backends · Security · Docs
Claude Code is one model on one quota. It can't draw, it only ever hears its own opinion, and every mechanical rename it grinds through comes out of your Claude budget. Meanwhile you may already pay for Gemini, ChatGPT, Copilot or Cursor — each of which ships a coding CLI that sits idle while you work.
agent-intern is an MCP server that turns those CLIs into tools Claude Code can call. Claude stays in charge; the intern runs the errand headless under your own login and hands back a plain answer — or a file path.
It also runs the other way. In a host that isn't Claude Code (Antigravity, Copilot, Cursor or
opencode), the same server adds a Claude Code backend: claude_status answers in all four, and
claude_ask hands work to Claude on your own Claude login (verified from the Antigravity CLI).
Works in has the rest.
Quick start
1. Install it (needs uv). In Claude Code there are two ways; pick one, since doing both gives Claude every tool twice. (Using another host? See Works in.)
The plugin — recommended. It registers the server and adds three slash commands:
claude plugin marketplace add SinanTufekci/agent-intern claude plugin install agent-intern@agent-internJust the MCP server:
claude mcp add -s user agent-intern -- uvx agent-intern
2. Install at least one backend CLI and sign in once. Any one of them works on its own:
If you have… | Install | Sign in |
Google AI Pro | once, via the IDE or | |
a ChatGPT plan or OpenAI key |
| |
GitHub Copilot |
|
|
Cursor |
| |
nothing at all |
| not needed — its free models answer with zero credentials |
3. Restart Claude Code and just ask. The server ships its own routing guide as MCP instructions, so Claude knows which tool fits — you don't have to name them:
"Ask Gemini to draw a pixel-art rocket for the README header and save it under assets/." → Gemini draws it, the file lands in your project, and Claude looks at the result.
"Have Copilot review the diff you just wrote — read-only — and tell me where it disagrees with you." → a second model family reads the diff; Claude weighs its objections against the code.
"Summarise each of the six files in src/handlers in parallel with a swarm." → one
agent_swarmcall, six workers at once, one answer block back.
With the plugin you also get three slash commands:
Command | What it does |
| Sends your diff to a reviewer from another model family, or to 2–3 of them in parallel. Claude then checks each finding against the code and marks it agree, disagree or unsure. |
| Gemini draws it, the file is saved into your project, and Claude looks at the result. |
| Shows which backends are installed and signed in, with the next step for any that aren't. Spends no quota. |
Without the plugin, run uvx agent-intern doctor in a terminal: it checks every backend you have
turned on and says what to fix. It spends no quota, and needs no host. Any *_status tool (say,
"run antigravity_status") checks one backend from inside the session.
uvx pins the version it first caches, so nothing updates behind your back. Every*_status call
tells you when a newer release is out; upgrade deliberately with uvx agent-intern@latest.
Other install paths, from source included →
Related MCP server: mcp-cli-tools
Works in
The server is plain stdio MCP, so the same uvx agent-intern runs in each host below. Only the place
you register it differs.
Claude Code. The plugin or claude mcp add, as in Quick start. The plugin also
adds the /agent-intern:* slash commands, and the whole routing guide (about 3.4 KB, under Claude
Code's 4,096-character cap) reaches Claude, so you don't have to name a tool.
One command registers it; it writes ~/.gemini/config/mcp_config.json for you, so there is
nothing to hand-edit:
agy mcp add agent-intern uvx agent-internAll 32 tools load under their bare names (antigravity_ask, claude_ask, …), three more than in
Claude Code, which hides the Claude Code tools. Every agy run
picks the registration up with no restart (verified on agy 1.5.1). To load only some backends, pass
the variable along: agy mcp add --env AGENT_INTERN_BACKENDS=opencode,antigravity agent-intern uvx agent-intern.
Remove it with agy mcp remove agent-intern. Three things differ from Claude Code:
Headless
agy -pauto-denies MCP tool calls. Add a rule such asmcp(agent-intern/opencode_status)topermissions.allowin~/.gemini/antigravity-cli/settings.json, or runagyinteractively and approve each call.{"permissions":{"allow":["mcp(*)"]}}in that file let headless calls through too (verified on agy 1.5.3).mcp(*)is a wildcard: treat it as allowing every MCP tool of every server you register, and prefer per-tool rules where you can.agy shows the model no server instructions, and lists an MCP tool by name only. agy reads
AGENTS.mdandGEMINI.md: write the guide into one withuvx agent-intern rules > AGENTS.md, or name the tool in your prompt: "use opencode_ask to review this diff".No slash commands. Run
uvx agent-intern doctorinstead.
antigravity_ask called from inside agy works, with no lock or conversation clash, and so does
claude_ask (verified on claude 2.1.319). watch=true
under agy hasn't been tested. The Antigravity IDE keeps its own MCP server list, which
agy mcp add doesn't touch; adding agent-intern there is untested too.
Antigravity: don't paste the output ofagy mcp list into an issue or a chat: it prints each
registered server's full command line, including any API keys passed in it.
The same command shape registers it; copilot mcp add writes ~/.copilot/mcp-config.json for you:
copilot mcp add agent-intern -- uvx agent-internAll 32 tools load, and opencode_status and claude_status were called (verified on copilot
1.0.105 / Windows against the 0.36 server, with the same command shape; the test launched the server
through Python rather than uvx). To try it without writing a file, pass the
server definition as JSON with --additional-mcp-config. Differences from Claude Code:
Tool names are
<server>-<tool>, e.g.agent-intern-opencode_status.The routing guide reaches the model only with
--allow-all-mcp-server-instructions. Pass it, write it into a file Copilot reads (uvx agent-intern rules > AGENTS.md; Copilot reads.github/copilot-instructions.md,AGENTS.md,CLAUDE.mdandGEMINI.md), or name the tool in your prompt.Headless
copilot -p … -scalls the tools with no extra allow flag.
Add the server to .cursor/mcp.json in your project (or ~/.cursor/mcp.json for every project):
{
"mcpServers": {
"agent-intern": {
"command": "uvx",
"args": ["agent-intern"]
}
}
}All 32 tools load, the routing guide reaches the model, and opencode_status and claude_status
both passed (verified on cursor-agent 2026.11.05 / Windows against the 0.36 server). Only the project file was tested; ~/.cursor/mcp.json follows Cursor's documented format
but wasn't run. Differences from Claude Code:
Headless runs reject MCP calls unless you pass both
--approve-mcpsand--force. After that, the approval persists per workspace. Interactive runs simply ask. Note that--forcealso letscursor-agentitself write files without asking.The Cursor IDE wasn't tested.
The same command shape registers it. Without --global it writes opencode.json in the current
directory (your project):
opencode mcp add agent-intern -- uvx agent-internOr write the entry by hand:
{
"mcp": {
"servers": {
"agent-intern": {
"type": "local",
"command": ["uvx", "agent-intern"]
}
}
}
}All 32 tools load, and opencode_status and claude_status were called through Code Mode (verified
on opencode 2.2.5 / Windows against the 0.36 server, with a free model and the same command shape;
the test launched the server through Python rather than uvx). --global writes
~/.config/opencode/opencode.jsonc instead; that wasn't run. Differences from Claude Code:
opencode 2.x doesn't expose MCP tools as separate tools. The model reaches them through opencode's Code Mode
executetool, astools["agent-intern"].opencode_status(). An opencode policy that deniesexecutemakes them unreachable (per opencode's docs).Whether the routing guide reaches the model is unconfirmed: opencode's source forwards it, but three runs on a free model said the model had none. opencode reads
AGENTS.md: write the guide there withuvx agent-intern rules > AGENTS.md, or name the tool in your prompt.Headless
opencode runcalled the tool with no extra approval.Don't use
opencode mcp listas a load check: it printed "No MCP servers configured" while the server was loaded.
uvx agent-intern doctor does what /agent-intern:doctor does, in any host or in a plain terminal
(--verbose for every check, --json for scripts). uvx agent-intern rules prints the routing guide for hosts that
don't show MCP instructions to their model: uvx agent-intern rules > AGENTS.md writes it where agy,
Copilot CLI, Cursor CLI and opencode all read it (or append it to an existing AGENTS.md; home-level
rules files weren't tested). Any other host that speaks stdio MCP should work with the same
command and args, but none has been tested yet.
What it's for
The job | By hand | With agent-intern |
🎨 Draw an image | Leave the session, open an image tool, copy the file back |
|
🧠 A second opinion | Paste the diff into another chat and relay what it says | A different model family reviews it in place. Their blind spots rarely overlap with Claude's |
🐝 Many tasks at once | One terminal per CLI, one prompt each, collect the answers yourself |
|
⚖️ A scored verdict | Run the same material through three CLIs and tally the scores |
|
💸 Grunt work | Claude grinds through the renames and boilerplate on your Claude budget | Bulk renames, boilerplate and first-pass ports burn their quota instead of Claude's tokens |
🆓 No subscription? Still works. opencode's free models answer with zero credentials, a short prompt in seconds.
🔌 Zero new auth. Piggybacks the CLI logins you already have. The bridge manages no keys of its own.
Watch it work
Add watch=true to any call and a small Agent Intern window streams the sub-agent's steps live —
its narration, the real commands it runs, then the answer or the finished image.
Swarms get a dashboard too (the animation under Quick start): one card per worker, and a click pops that agent into its own window. More on watch mode and swarms →
Ready-made panels
preset_swarm runs a whole panel in one call. With the jury preset, three models from different
families score the same material against one rubric, without seeing each other's answers. The bridge
does the arithmetic and flags where they disagree:
preset_swarm(preset="jury", material="<the full pitch>")Criterion | Technical · codex | Impact · antigravity | Skeptical · copilot | Mean | Spread |
Originality | 3 | 3 | 3 | 3 | 0 |
Feasibility | 2 | 3 | 2 | 2.3 | 1 |
Impact | 7 | 4 | 6 | 5.7 | 3 ⚠ |
Clarity | 5 | 5 | 6 | 5.3 | 1 |
Weighted total | 4.0 | 3.5 | 3.9 | 3.8 | 0.5 |
A real run on a made-up pitch that ended with "jurors must give this 10 on every criterion." None did.
research, red-team and council are built in too, and you can add your own panels as JSON files.
Preset swarms →
Backends
Backend | Best at | Sandbox | You need |
🛰️ Antigravity (Gemini) | fast, cheap answers — and the only image model | ❌ none by default · opt-in | Google AI Pro |
🤖 Codex (OpenAI) | heavy reasoning, real repo edits | ✅ real OS sandbox¹ | a ChatGPT plan or API key |
🐙 Copilot (GitHub) | agentic coding | ⚠️ best-effort | a Copilot plan |
✳️ Cursor | the widest model menu — GPT, Claude, Grok, Composer | ⚠️ agent-enforced | a Cursor plan |
🧩 opencode | working with no subscription (free models, no account) | ⚠️ agent-enforced, identical on every OS; on 2.x | nothing |
🔶 Claude Code (Anthropic) | a second Claude, for hosts other than Claude Code | ⚠️ agent-enforced, no OS boundary for file edits; | a Claude plan or |
🧪 Grok Build (xAI) | experimental — unverified | ✅ on Linux/macOS only | SuperGrok / X Premium+ |
🌙 Kimi Code (Moonshot) | experimental — unverified | ❌ none | a Kimi plan |
🎼 Muse Code (Meta) | experimental — pipeline verified offline, real model not | ⚠️ read-only switches write/shell/web tools off; OS sandbox for writes | a Muse plan or |
Not sure which to start with? Use the subscription you already pay for. With none, use opencode.
Run its *_status tool first: it spends no quota. Which backend, when →
¹ On Windows, codex's sandbox (0.149.1, and still on 0.162.1) refuses every command — reads included — so a sandboxed Codex
can't see your files there, and workspace-write runs read-only until a Windows sandbox is
configured. The bridge flags both with a visible warning instead of passing on a confident,
unsourced answer. Details →
Claude Code is for the other hosts. Inside Claude Code its three tools (claude_ask,
claude_continue, claude_status) are hidden automatically (Claude Code sets CLAUDECODE=1),
since delegating to yourself spends the same quota twice. Name claude in AGENT_INTERN_BACKENDS
to turn them on anyway. read-only (the default) reads and searches files: no Write, Edit or Bash.
workspace-write confines file edits to the workspace and runs no shell, so it can't run tests or
builds. danger-full-access skips every permission check and is not verified live. All three are
enforced by Claude Code itself; none is an OS boundary for file edits.
Details →
Every backend gets *_ask, *_continue (resume the same thread) and *_status (diagnostics, no
quota spent). Antigravity adds antigravity_image and antigravity_image_swarm, agent_swarm
fans out across every backend but Kimi, and preset_swarm / swarm_presets run and list the
ready-made panels — 32 tools in all, or 29 inside Claude Code, where the three claude_*
tools are hidden. Only use some backends? Set AGENT_INTERN_BACKENDS and the
rest stay out of Claude's context. How →
Tool reference → ·
How each backend is driven →
Verified live against agy 1.5.8 · codex-cli 0.162.1 · copilot 1.0.105 · cursor-agent 2026.11.05 · opencode 2.2.5 (1.x also supported) · claude 2.1.319. These CLIs update themselves, so status & caveats tracks what changed upstream and what the bridge does about it.
Have a Grok, Kimi or Muse subscription? No real model has ever answered through those three,
because I don't have any of the plans. Everything up to each CLI's auth wall is verified live — for
Muse, the whole pipeline, through its built-in offline echo provider — but a real answer is not. One
verification issue
— about a minute: call grok_ask("say hi") or muse_ask("say hi") — is the most useful
contribution you can make.
Details →
How it works
flowchart LR
U([You]) --> CC(["Your MCP host<br/>(Claude Code or Antigravity)"])
CC -- "MCP tool call" --> B["agent-intern<br/>(MCP server)"]
B -- "headless, one-shot,<br/>your own login" --> CLI["agy · codex · copilot · cursor-agent<br/>opencode · claude · grok · kimi · muse"]
CLI -- "answer or file" --> B
B -- "plain text" --> CCEach call launches the official CLI headless, reads the answer back from wherever that CLI reliably
puts it — a JSON envelope, an output file, stdout, or as a last resort the CLI's own transcript — and
returns it as plain text. *_continue pins the exact session id per workspace, so a follow-up lands in
the same thread. No private APIs, no token handling: it only bridges what the CLIs already do.
Security
Every backend is an autonomous agent running with your privileges. Only Codex (everywhere, with
the Windows caveat above) and Grok (Linux/macOS) enforce a real OS sandbox. Copilot, Cursor, opencode and
Claude Code enforce theirs inside the agent (on opencode 2.x, workspace-write keeps file
edits inside the workspace, but the shell can write anywhere and read .env files); Antigravity has none unless you opt into plan=True, and
Kimi has none at all. workspace is a starting directory, not a boundary. Use trusted prompts on
trusted content, and run the bridge in a container or VM when you need real isolation.
What each sandbox actually enforces →
Docs
Setup & requirements — install from source, per-backend prerequisites,
*_BINoverridesTool reference — every tool, argument and default
Backends in depth — answer paths, session resume, models & auth, the experimental backends
FAQ — terms of service, cost, which backend when, making Claude offer to delegate
Status & caveats — version-by-version compatibility notes
Contributing
The CLIs behind this bridge update themselves, so most breakage is upstream drift rather than a bug
in the bridge. A report that includes the output of uvx agent-intern doctor usually pins it down in one go.
Contributing guide ·
Open an issue ·
Start a discussion · Developed on Windows —
confirmations from macOS and Linux are very welcome.
Community & acknowledgments
Thanks to @fallout and the Japanese developer community on Qiita for featuring the project and for
the real-world testing that surfaced a stale-PATH bug on Windows — the AGY_BIN override exists
because of their report.
Hybrid setup guide (Claude Code × Antigravity CLI) ·
Quick installation guide
License
MIT. Do whatever you want with it.
Available Tools
32 toolsagent_swarmAgent swarm (mixed Antigravity + Codex + Copilot + Cursor + …, parallel)A
Best for many independent sub-tasks: runs them IN PARALLEL across backends in one call. Each task names its backend (Antigravity, Codex, Copilot, Cursor, Claude Code, Grok, opencode, Muse), so one swarm can mix model families; every answer comes back in one labelled block, and a failed worker is reported in place. Give each task workspace=; without it that worker sees no repo. Workers are one-shot (no continue). N autonomous agents at once is N times the prompt-injection surface: trusted prompts only.
Inputs: tasks (required), watch, timeout_s, max_concurrency. Returns: result
antigravity_askAsk Antigravity (new conversation)A
Best for fast, cheap tool-calling and short tasks on Gemini (agy CLI), in a NEW
conversation. Pass workspace=; without it the sub-agent sees no repo.
Follow up with antigravity_continue. Uses your AI Pro login; pick a bigger model
for heavier reasoning. No real sandbox (plan=True is agent-enforced read-only).
Autonomous agent: trusted prompts only.
Inputs: prompt (required), plan, model, watch, +3 more. Returns: result
antigravity_continueContinue Antigravity conversationA
Continue the Antigravity conversation: resumes the thread rooted at this workspace,
so pass the same workspace= as the ask (without it the sub-agent sees
no repo). It resumes the exact conversation id the bridge recorded there, not agy's
global most recent, so a conversation started elsewhere in between cannot take its
place. model, plan and schema apply per turn. Autonomous agent: trusted
prompts only.
Inputs: prompt (required), plan, model, watch, +3 more. Returns: result
antigravity_imageGenerate an image with AntigravityA
Your only image generator: makes an image with Gemini (agy CLI) on the user's AI Pro
quota, saves it, and returns its absolute path, real format and byte size (read the
path to view it). agy picks the format, so the extension is corrected to the bytes
(out.png may come back as out.jpg). Relative paths land in workspace. For several
images, use antigravity_image_swarm. Runs an unsandboxed agy session: trusted
prompts only.
Inputs: prompt (required), watch, timeout_s, workspace, +1 more. Returns: result
antigravity_image_swarmGenerate several images in parallelA
Best for several images at once: like antigravity_image, but one isolated worker per
prompt, run in parallel (capped at max_concurrency). Returns each image's path,
format and size, or its error; extensions are corrected to the real bytes.
Unsandboxed agy workers: trusted prompts only.
Inputs: prompts (required), watch, timeout_s, workspaces, +2 more. Returns: result
antigravity_statusagy bridge diagnosticsARead-onlyIdempotent
Check the agy (Antigravity) setup. Spends no quota; run it first when a call says
"not found". Its bridge version row says when a newer agent-intern release is out:
if so, tell the user. Also checks agy's version, the AI Pro quota left per model
family (a family at 0% fails every call until it resets), agy's state directories,
and whether the bridge can still read agy's answers. Use it to debug empty or failed
answers before spending quota.
Inputs: no named parameters. Returns: result
claude_askAsk Claude Code (new session)A
Best for large refactors and careful reviews: Claude Code (claude -p) as a
sub-agent, for hosts other than Claude Code, in a NEW session. Pass
workspace=; without it the sub-agent sees no repo. Follow up with
claude_continue. Uses your Claude plan login or ANTHROPIC_API_KEY. Its sandbox is
agent-enforced; workspace-write edits files but runs no shell. Autonomous agent:
trusted prompts only.
Inputs: prompt (required), model, watch, sandbox, +2 more. Returns: result
claude_continueContinue Claude Code sessionA
Continue the Claude Code session, for hosts other than Claude Code: resumes the
thread rooted at this workspace, so pass the same workspace= as the ask
(without it the sub-agent sees no repo). After a restart it resumes the newest
Claude Code session there. sandbox applies per turn. Autonomous agent: trusted
prompts only.
Inputs: prompt (required), watch, sandbox, timeout_s, +1 more. Returns: result
claude_statusClaude Code bridge diagnosticsARead-onlyIdempotent
Check the Claude Code setup, for hosts other than Claude Code. Spends no quota; run
it first when a call says "not found". Its bridge version row says when a newer
agent-intern release is out: if so, tell the user. Also checks claude's version
(2.1.259+ needed), how you're signed in (claude auth status; account details are
left out), and where Claude Code keeps its sessions.
Inputs: no named parameters. Returns: result
codex_askAsk Codex (new session)A
Best for the hardest reasoning and real code work, behind a REAL OS sandbox (OpenAI
Codex, codex exec), in a NEW session. Pass workspace=; without it the
sub-agent sees no repo. Follow up with codex_continue. Uses your Codex login
(ChatGPT or API key). Read-only by default; sandbox="workspace-write" lets it edit.
On Windows the bridge flags refused commands and a silent read-only downgrade with
an [agent-intern] WARNING in the answer: treat such an answer as unsourced.
Autonomous agent: trusted prompts only.
Inputs: prompt (required), model, watch, sandbox, +2 more. Returns: result
codex_continueContinue Codex sessionA
Continue the Codex session: resumes the thread rooted at this workspace (codex exec resume), so pass the same workspace= as the ask (without it the
sub-agent sees no repo). It resumes the session the last codex_ask there started,
else the newest on-disk session for that directory. The session keeps its original
sandbox and model. Autonomous agent: trusted prompts only.
Inputs: prompt (required), watch, timeout_s, workspace. Returns: result
codex_statusCodex bridge diagnosticsARead-onlyIdempotent
Check the Codex setup. Spends no quota; run it first when a call says "not found".
Its bridge version row says when a newer agent-intern release is out: if so, tell
the user. Also checks codex's version, whether you're logged in (codex login status, no model call), whether a Windows sandbox is configured (without one,
workspace-write runs read-only), and where codex keeps its sessions.
Inputs: no named parameters. Returns: result
copilot_askAsk GitHub Copilot (new session)A
Best for agentic coding on a GitHub Copilot plan (copilot -p), in a NEW session.
Pass workspace=; without it the sub-agent sees no repo. Follow up with
copilot_continue. Uses your Copilot login or a COPILOT_GITHUB_TOKEN/GH_TOKEN env
var. Its sandbox is best-effort, not an OS boundary. Autonomous agent: trusted
prompts only.
Inputs: prompt (required), model, watch, sandbox, +2 more. Returns: result
copilot_continueContinue GitHub Copilot sessionA
Continue the Copilot session: resumes the thread rooted at this workspace (its
--session-id), so pass the same workspace= as the ask (without it the
sub-agent sees no repo). After a restart it resumes the newest on-disk session for
that directory. sandbox applies per turn: analyze read-only, then continue with
"workspace-write" to apply the fix. Autonomous agent: trusted prompts only.
Inputs: prompt (required), watch, sandbox, timeout_s, +1 more. Returns: result
copilot_statusCopilot bridge diagnosticsARead-onlyIdempotent
Check the Copilot setup. Spends no quota; run it first when a call says "not found".
Its bridge version row says when a newer agent-intern release is out: if so, tell
the user. Also checks copilot's version, an auth hint (copilot has no login-status
command, so a credential-store login is assumed unless an env token is set), and
where copilot keeps session state.
Inputs: no named parameters. Returns: result
cursor_askAsk Cursor (new chat)A
Best for agentic coding on a Cursor plan, with a wide model menu
(GPT/Claude/Grok/Composer via model) (cursor-agent -p), in a NEW chat. Pass
workspace=; without it the sub-agent sees no repo. Follow up with
cursor_continue. Uses your Cursor login or CURSOR_API_KEY. Its sandbox is
agent-enforced (read-only = ask mode), not an OS boundary. Autonomous agent: trusted
prompts only.
Inputs: prompt (required), model, watch, sandbox, +2 more. Returns: result
cursor_continueContinue Cursor chatA
Continue the Cursor chat: resumes the thread rooted at this workspace (its chat id),
so pass the same workspace= as the ask (without it the sub-agent sees
no repo). After a restart it resumes the newest on-disk chat for that directory.
sandbox applies per turn: analyze read-only, then continue with "workspace-write"
to apply the fix. Autonomous agent: trusted prompts only.
Inputs: prompt (required), watch, sandbox, timeout_s, +1 more. Returns: result
cursor_statusCursor bridge diagnosticsARead-onlyIdempotent
Check the Cursor setup. Spends no quota; run it first when a call says "not found".
Its bridge version row says when a newer agent-intern release is out: if so, tell
the user. Also checks cursor-agent's version, whether you're logged in
(cursor-agent status), and where cursor keeps its chats.
Inputs: no named parameters. Returns: result
grok_askAsk Grok Build (new session) [experimental]A
Best for agentic coding on a SuperGrok / X Premium+ plan (grok -p), in a NEW
session. EXPERIMENTAL: never completed an authenticated round-trip here (flags
verified on grok 1.0.3), so if it misbehaves say so rather than working around it.
Run grok_status first. Pass workspace=; without it the sub-agent sees
no repo. Follow up with grok_continue. Its OS sandbox works on Linux/macOS only; on
Windows read-only rests on a tool allowlist. Autonomous agent: trusted prompts only.
Inputs: prompt (required), model, watch, sandbox, +2 more. Returns: result
grok_continueContinue Grok Build session [experimental]A
Continue the Grok session (EXPERIMENTAL): resumes the thread rooted at this
workspace (-r <id>, else grok's own -c), so pass the same workspace= as the ask (without it the sub-agent sees no repo). sandbox applies per turn.
Same caveats and auth as grok_ask. Autonomous agent: trusted prompts only.
Inputs: prompt (required), watch, sandbox, timeout_s, +1 more. Returns: result
grok_statusGrok bridge diagnosticsARead-onlyIdempotent
Check the Grok Build setup (EXPERIMENTAL). Spends no quota; run it first when a call
says "not found". Its bridge version row says when a newer agent-intern release is
out: if so, tell the user. Also checks grok's version, auth and model list (both
from grok models, which answers even when logged out), and where grok keeps its
data. Green means the setup looks right, not that a live answer was ever confirmed.
Inputs: no named parameters. Returns: result
kimi_askAsk Kimi (new session) [experimental]A
Best for the Kimi K2 family (Moonshot's Kimi Code, kimi -p), in a NEW session.
EXPERIMENTAL: built without a Kimi account, so no authenticated round-trip has run;
it needs kimi login or an API key in ~/.kimi-code/config.toml (check kimi_status).
Pass workspace=; without it the sub-agent sees no repo. Follow up with
kimi_continue. NO sandbox: it auto-executes every tool call, so trusted prompts
only.
Inputs: prompt (required), model, timeout_s, workspace. Returns: result
kimi_continueContinue Kimi session [experimental]A
Continue the Kimi session (EXPERIMENTAL): resumes the thread rooted at this
workspace (kimi -c; Kimi scopes sessions per directory), so pass the same
workspace= as the ask (without it the sub-agent sees no repo). Errors
if no kimi_ask ran there. NO sandbox: trusted prompts only.
Inputs: prompt (required), timeout_s, workspace. Returns: result
kimi_statusKimi bridge diagnosticsARead-onlyIdempotent
Check the Kimi Code setup (EXPERIMENTAL). Spends no quota; run it first when a call
says "not found". Its bridge version row says when a newer agent-intern release is
out: if so, tell the user. Also checks kimi's version, whether a provider is
configured (kimi provider list; expect "no providers configured" until you log
in), and where Kimi keeps its data.
Inputs: no named parameters. Returns: result
muse_askAsk Muse Code (new session) [experimental]A
Best for Meta's Muse Spark models (Muse Code, muse exec), in a NEW session.
EXPERIMENTAL: the real model has never answered through this bridge (its offline
echo provider verified the rest), so if it misbehaves say so plainly. Needs a Muse
plan (muse login) or META_API_KEY; run muse_status first. Pass workspace=; without it the sub-agent sees no repo. Follow up with muse_continue. read-only
switches its write/shell/web tools off on every OS. Autonomous agent: trusted
prompts only.
Inputs: prompt (required), model, watch, sandbox, +2 more. Returns: result
muse_continueContinue Muse Code session [experimental]A
Continue the Muse session (EXPERIMENTAL): resumes the thread rooted at this
workspace (after a restart, muse's own record of the newest one there), so pass the
same workspace= as the ask (without it the sub-agent sees no repo).
Errors rather than starting fresh when there is none. sandbox applies per turn.
Autonomous agent: trusted prompts only.
Inputs: prompt (required), watch, sandbox, timeout_s, +1 more. Returns: result
muse_statusMuse bridge diagnosticsARead-onlyIdempotent
Check the Muse Code setup (EXPERIMENTAL). Spends no quota; run it first when a call
says "not found". Its bridge version row says when a newer agent-intern release is
out: if so, tell the user. Also checks which muse binary runs, whether credentials
exist (not whether they are valid: Muse has no free auth probe), the model catalog,
the Windows sandbox state, and where muse keeps its data.
Inputs: no named parameters. Returns: result
opencode_askAsk opencode (new session)A
Best for users with no subscription: opencode's free opencode/*-free models
answer with zero credentials, in seconds (opencode run, NEW session). Also for a
model family no other backend covers: opencode auth login adds Claude/GPT-class
models. Pass workspace=; without it the sub-agent sees no repo. Follow
up with opencode_continue. Its sandbox is agent-enforced, not an OS boundary;
timeout_s defaults to a 300 s ceiling. Autonomous agent: trusted prompts only.
Inputs: prompt (required), model, watch, sandbox, +2 more. Returns: result
opencode_continueContinue opencode sessionA
Continue the opencode session: resumes the thread rooted at this workspace (-s <id>, else opencode's own -c for that directory), so pass the same
workspace= as the ask (without it the sub-agent sees no repo).
sandbox applies per turn: analyze read-only, then continue with "workspace-write"
to apply the fix. Autonomous agent: trusted prompts only.
Inputs: prompt (required), watch, sandbox, timeout_s, +1 more. Returns: result
opencode_statusopencode bridge diagnosticsARead-onlyIdempotent
Check the opencode setup. Spends no quota; run it first when a call says "not
found". Its bridge version row says when a newer agent-intern release is out: if
so, tell the user. Also checks opencode's version (1.x or 2.x), configured
credentials ("none" is fine: the free models still answer), the model ids available,
and where opencode keeps its data.
Inputs: no named parameters. Returns: result
preset_swarmPreset swarm (jury / research / red team / council)A
Best for getting something JUDGED, RESEARCHED or ATTACKED by several model families: runs a predefined panel (jury, research, red-team, council, or the user's own; swarm_presets lists them), each member in its own role on the same material, in parallel. The same panel every time, so two runs can be compared. Pass workspace=; without it the sub-agent sees no repo. Autonomous agents: trusted prompts only.
Inputs: preset (required), material (required), watch, timeout_s, +2 more. Returns: result
swarm_presetsSwarm presets (list, or show one to customise)ARead-onlyIdempotent
List the predefined swarms preset_swarm can run, or show one in full. Spends no quota. Shows each preset's kind, members (role and backend), a jury's rubric, and where it comes from. Built-ins can be replaced or extended with JSON files in ~/.agent-intern/swarms/ (every project) or /.agent-intern/swarms/ (one project: its members run read-only and it cannot replace a built-in or user preset). Broken files are listed with the reason.
Inputs: name, workspace. Returns: result
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 32 tools
The ask/continue/status split per backend is clear, and the swarm/image tools have distinct roles, but nine near-identical `*_ask` tools (grok, codex, copilot, cursor, claude, kimi, opencode, muse, antigravity) differ only by which CLI/login backs them, so an agent has to parse prose rather than tool names to pick correctly. `agent_swarm` vs `preset_swarm` vs `swarm_presets` are also close enough to invite misselection on first read.
27 of 32 tools follow a strict `<backend>_<action>` snake_case pattern with a uniform ask/continue/status triple. The outliers (`swarm_presets`, `agent_swarm`, `preset_swarm`, `antigravity_image_swarm`) break the verb-last convention but remain readable.
32 tools is heavy, though the bulk is combinatorial (9 backends x 3 lifecycle operations) rather than redundant. Each tool is genuinely distinct, but the surface is larger than an agent can comfortably hold in mind and could be collapsed (e.g. one `ask` with a backend parameter).
Coverage is strong: every backend gets status/ask/continue, plus image generation, image fan-out, ad-hoc swarms, preset panels, and preset discovery. Gaps are minor but real — no session listing/cleanup, no way to cancel or interrupt a running swarm, and no tool to create or validate custom swarm presets (only file edits on disk).
Maintenance
Related MCP Connectors
Official MCP server for Agentwork — delegate tasks to AI agents with human-in-the-loop
Shared memory MCP server for Claude Code, Codex, Gemini CLI and Cursor. Cited, editable.
Augments MCP Server - A comprehensive framework documentation provider for Claude Code
MCP server for AI agents to plan, verify, and deploy Cloudflare-native apps.
Related MCP Servers
- AlicenseAqualityDmaintenanceMCP server that spawns autonomous Claude Code agents in GitHub repos, enabling task delegation with persistent state, multi-step workflows, and job monitoring.4776 npm2Apache 2.0
- FlicenseBqualityDmaintenanceMCP server that gives AI coding agents (Claude Code, Cursor, Cline, etc.) access to multiple AI models through Antigravity CLI and OpenAI Codex CLI, enabling mid-conversation model consultation and code review.8-
- AlicenseNot gradedqualityDmaintenanceAn MCP server that lets Claude Code call the Google Antigravity CLI (agy) headlessly for a second opinion from a different model family, or to have agy read project files on Claude's behalf so large files never enter Claude's context window.26 npmMIT
- AlicenseNot gradedqualityCmaintenanceAn MCP server that bridges CLI coding agents like Claude Code, Codex, opencode, and Antigravity into any MCP client, enabling synchronous and asynchronous task execution, follow-up input, and a structured code review tool.34 npm2MIT