AI coding tools matrix

Multica ships with built-in support for 13 AI coding tools. They all implement the same interface — queue, dispatch, execute, return results — so you can drive any of them from the same Multica board. But the capability details diverge significantly: whether session resumption actually works, whether MCP is supported, where skill files live, how models are selected. This page is the full matrix.

For guidance on picking a tool when creating an agent, see Creating and configuring agents.

Capability matrix

What each tool is for

Antigravity

From Google. CLI binary name is agy. Pairs with Google's Antigravity service and ships with a Gemini-backed default model. Session resumption works via --conversation <id>; the daemon captures the conversation UUID from the CLI's log file because stdout is plain text rather than a structured event stream. Model selection works via the --model flag (added in agy 1.0.6): the daemon enumerates the catalog with agy models and ships the chosen value verbatim. Note these are human display strings such as Claude Opus 4.6 (Thinking), not provider/model slugs — and agy silently no-ops on a value it doesn't recognise, so prefer picking from the discovered list over typing a custom one. Skills land in .agents/skills/ (the CLI inherits Gemini CLI's workspace skill layout — see Antigravity migration docs).

Claude Code

From Anthropic. First choice for new users — the most complete feature set: session resumption actually works, it reads MCP configuration, and it supports fine-tuning flags like --max-turns and --append-system-prompt. Requires an Anthropic API key.

CodeBuddy

From Tencent. A Claude Code–compatible CLI agent — Multica drives it with the same stream-json protocol as Claude Code, so session resumption works (via --resume), MCP config is passed through --mcp-config, and skills use Claude Code's .claude/skills/ layout. Models are discovered dynamically.

Codex

From OpenAI. Uses JSON-RPC 2.0, has stronger statefulness, and a finer-grained approve mechanism (manual approval for exec_command and patch_apply). MCP config is materialized into the per-task $CODEX_HOME/config.toml. Session resumption works through Codex app-server thread/resume; if the saved thread is missing or stale, Multica falls back to a fresh thread so the task can still run.

Copilot

From GitHub. Model routing goes through your GitHub account entitlement — the tool doesn't select a model itself; GitHub decides which model you get. Placing skills in .github/skills/ is GitHub CLI's native discovery mechanism.

Cursor

From Anysphere, the CLI counterpart to the Cursor editor. Session resumption works with current Cursor Agent releases: the stream-json event includes a session_id, and Multica passes it back with --resume <id> on the next run. MCP config is materialized into the task workspace's .cursor/mcp.json, with Cursor's project approval file written under a per-task CURSOR_DATA_DIR so managed MCP servers do not depend on the user's global Cursor approvals.

Hermes

From Nous Research. Uses the ACP protocol (shares a transport with Kimi). Session resumption works, and MCP config is passed through ACP mcpServers. But the skill injection path is the generic fallback (.agent_context/skills/), not a dedicated one — if the Hermes CLI itself doesn't read this path, skills may not take effect. Verify by testing.

Selecting a Hermes profile. To launch Hermes under a specific profile, set the agent's custom_args to the profile flag and the profile name as two separate entries — for example, for a profile named research:

["-p", "research"]

Don't combine them into one string like "-p research"; Multica passes each array item as a separate argv entry. custom_args is configured per agent — see Creating and configuring agents.

Kimi

From Moonshot, aimed at the Chinese market. Shares the ACP protocol with Hermes, including MCP config through ACP mcpServers, but the skill path .kimi/skills/ is Kimi CLI's native discovery mechanism — different from Hermes's fallback.

Kiro CLI

From Amazon. Uses ACP over stdio via kiro-cli acp. Session resumption works through ACP session/load, MCP config is passed through ACP mcpServers, model selection works through session/set_model, and skills are copied into .kiro/skills/ for native project-level discovery.

OpenCode

From SST, open source. Dynamically discovers available models and model variants (scans the CLI's configuration file). Session resumption works, and it consumes the agent's mcp_config field — Multica injects it inline through the OPENCODE_CONFIG_CONTENT environment variable, so the agent's MCP servers reach OpenCode without writing anything into the task workdir's opencode.json (the agent or the user keep ownership of that file). When a model exposes variants, Multica shows them as the agent thinking selector and passes the selected value through opencode run --variant. Suitable for tinkerers who want to customize their model catalog.

OpenClaw

Open-source project, a CLI agent orchestrator. MCP config is materialized through Multica's per-task OpenClaw config wrapper. Model is bound at the agent layer (openclaw agents add --model) — it can't be overridden per task. Configuration is strictly controlled: users can't pass --model or --system-prompt; the agent-registration config decides.

Pi

From Inflection AI, minimalist. Session resumption is unusual — the session ID is a file path on disk (~/.pi/...) rather than a string ID. In other tools, the resume id is a string returned by the CLI; in Pi, the resume id is the session file itself.

Qoder

From Alibaba. An agentic coding CLI. Uses the ACP protocol over stdio (shares a transport with Hermes, Kimi, and Kiro CLI). Session resumption works through ACP session/resume, MCP config is passed through ACP mcpServers, model selection is discovered dynamically, and skills are copied into .qoder/skills/ for native discovery.

Session resumption: who really supports it

The session resumption mechanism is covered in Tasks. Every supported tool resumes sessions — pass the resume id and the task continues from the previous context. The one quirk is Pi, whose resume id is a session file path on disk rather than a string id (see Pi above).

MCP configuration: provider-specific support

Of the 13 tools, ten consume mcp_config: Claude Code, CodeBuddy, Codex, Cursor, Hermes, Kimi, Kiro CLI, OpenCode, OpenClaw, and Qoder. The other three accept the field but ignore it — no error, no warning, the config just has no effect.

The runtime paths are provider-specific: Claude Code and CodeBuddy receive it through --mcp-config paired with --strict-mcp-config; Codex writes a daemon-managed mcp_servers block into the per-task $CODEX_HOME/config.toml; Cursor writes .cursor/mcp.json plus per-task project approvals under CURSOR_DATA_DIR; Hermes, Kimi, Kiro CLI, and Qoder receive ACP mcpServers; OpenCode receives inline config through OPENCODE_CONFIG_CONTENT; OpenClaw receives mcp.servers through Multica's per-task config wrapper. OpenCode's path does not rewrite the project's opencode.json.

Where skill files go

Each tool uses its own skill discovery path. Before a task runs, the Multica daemon copies the workspace's skill files into the corresponding path:

Whether a fallback-path tool actually reads this directory depends on the tool's own documentation — no guarantees. If your skills aren't taking effect for Hermes / OpenClaw, check this first.

For native project-level paths, repo-scoped discovery is expected: if the checked-out repository already contains a matching directory, the underlying tool can discover those committed skills on its own. You do not need to import those repo skills into Multica just to use them in that repo. Multica keeps the repo files intact. If a workspace skill has the same natural directory name, the daemon writes the workspace copy to a collision-free sibling such as review-helper-multica.

For creating and using skills, see Skills.

Next

• Creating and configuring agents — pick a tool for your agent
• Tasks — task lifecycle and session-resumption mechanics
• Daemon and runtimes — where the tools run and how they connect to Multica
• Install an agent runtime — installation and authentication for each of the 13 supported tools