Skip to content

Integrations

Canonical setup guide for using Fusion from coding agents, plus the MCP tool reference. Fusion is an MCP server, started by the client over stdio (or served on localhost over HTTP, see Transports); the client stays the executor and applies edits itself.

Do not run uv run fusion mcp manually in a terminal. It speaks JSON-RPC on stdin/stdout and is meant to be spawned by the client. Pressing Enter there sends invalid input and produces Invalid JSON: EOF errors. To check that providers work, run:

uv run python evals/runners/compare_pipelines.py

Claude Code

Requirements: uv and Claude Code. Fusion runs straight from GitHub with uvx: there is nothing to clone or publish. It needs Python 3.11 or newer, and uvx fetches one (--managed-python) when the machine's default is older. Install it with one command, then give it keys.

uvx --python '>=3.11' --from git+https://github.com/alexandre0sheva/fusion-code-orchestrator fusion install claude-code --plugin

Or, from a checkout: uv run fusion install claude-code --plugin. Restart Claude Code, then check with /mcp (the server plugin:fusion:fusion should be connected) and /fusion:stats.

Provider keys reach the server through the environment Claude Code starts in, or a .env file in the project directory you open Claude Code in (the server starts there). Set at least one of ANTHROPIC_API_KEY, OPENAI_API_KEY, GOOGLE_API_KEY, OPENROUTER_API_KEY (OpenRouter alone runs every default strategy; see OpenRouter for the privacy setting it needs). Without any, Fusion answers with the failures listed in warnings. Run claude from a shell that has them exported.

Choose how to install

You want Run Gets you
Everything (recommended) fusion install claude-code --plugin The server, the /fusion:* commands, the skills and the fusion-advisor subagent
Only the tools, for all your projects fusion install claude-code The MCP server in your user config
Only the tools, shared with the team fusion install claude-code --scope project A fusion entry merged into the project's .mcp.json
The same, from the Claude Code prompt /plugin marketplace add alexandre0sheva/fusion-code-orchestrator, then /plugin install fusion@fusion-code-orchestrator The plugin, with no install command

--scope user|project also applies to --plugin (default user). Options for every form:

Option Meaning
--dry-run Print what would be done and the commands it would run; change nothing
--ref TAG Pin the server to a git tag, branch or commit (git+URL@TAG). Pin a release tag such as v0.3.0
--local-checkout PATH Run the server from a clone: uv run --directory PATH fusion mcp
--force Replace a different fusion server that is already registered
--no-verify Skip the launch check

The installer is safe to run again: it does nothing when fusion is already registered with the same command, and refuses (without --force) to replace one that differs. Before registering anything it starts the server the way Claude Code would and lists its tools, on the mock provider, so the check needs no keys and costs nothing; a server that does not start is not registered. .mcp.json is merged, never overwritten, and a malformed file is refused untouched. Everything else goes through the claude command (claude mcp add, claude plugin install), so Claude Code's own config file is never edited behind its back. A PyPI release (uvx fusion-code-orchestrator) would be a shorter command; it is not published, so none is documented.

By hand, the equivalent of the server-only install is:

claude mcp add --scope user fusion -- uvx --python '>=3.11' --managed-python --from git+https://github.com/alexandre0sheva/fusion-code-orchestrator fusion mcp

and, from a local clone, claude mcp add --scope user fusion -- uv run --directory /path/to/fusion-code-orchestrator fusion mcp.

What the plugin adds

Name Use
Commands (you type them) /fusion:ask, /fusion:review, /fusion:debug, /fusion:plan, /fusion:decide, /fusion:eval, /fusion:digest, /fusion:patch, /fusion:feedback One per tool (/fusion:plan and /fusion:decide are the two kinds of fusion_plan); they name the input (the files, the diff_ref range, the error) and tell Claude how to read the answer. /fusion:patch returns a diff for Claude to apply, /fusion:digest answers a question about large files in a few hundred tokens, /fusion:feedback tells Fusion what became of its last answer
/fusion:stats Spend, savings and shadow A/B win-rate
/fusion:bench Summarise the latest benchmark run from bench-results/ (read-only; never starts a study)
/fusion:ab Run a task with and without Fusion and compare the two
Skills (Claude loads them) fusion-orchestrator, fusion-review, fusion-debug, fusion-decide, fusion-plan, fusion-eval, fusion-patch Each says when to call Fusion and when not to, so Claude skips it for trivial edits
Subagent fusion-advisor Runs on Haiku 5.5 (model: claude-haiku-5-5, so Claude Code 2.1.327 or newer), calls Fusion in its own context and returns a verdict of at most 15 lines, with what it checked against the code. It can read files and call Fusion; it cannot edit or run commands

Example prompts: "Use Fusion to review this diff before I merge", "Have the fusion-advisor look at this stack trace", "Run fusion_plan with kind: decision for Redis vs Postgres caching".

Treat Fusion output like another model's answer: apply changes and run tests yourself. For measuring whether Fusion helps, see BENCHMARKING.md.

The cheap-executor recipe

Claude Code's own model is most of what a session costs, so the cheap setup is a small executor with Fusion as its advisor: install the plugin, then start Claude Code on Haiku 5.5 or Sonnet 5.5 (claude --model claude-haiku-5-5; Claude Code 2.1.327 or newer knows it). The executor edits and runs the tests; when it reaches a risky diff, a hard bug or a design choice it calls /fusion:review, /fusion:debug or /fusion:plan, or hands the question to the fusion-advisor subagent (also on Haiku 5.5, so even the go-between is cheap). /fusion:digest replaces reading many files into the executor's context, and /fusion:patch returns a patch checked in a sandbox for the executor to apply.

What the live study measured (4 test coding tasks, hidden tests decide, host tokens counted at catalog prices; one run per task and arm, so it shows direction, not a result):

Arm Solved Total $ per run Fusion calls per run
Opus 5.5 alone 4 of 4 $0.0678 0
Sonnet 5.5 alone 4 of 4 $0.0256 0
Haiku 5.5 alone 3 of 4 $0.0027 0
Haiku 5.5 + Fusion 4 of 4 $0.0058 0.2

Haiku with Fusion solved what Sonnet and Opus solved at 23% of Sonnet's and 9% of Opus's cost per solved task, but most of that is Haiku being cheap: Fusion was called in 2 of its 12 runs, and the one task it solved that Haiku alone did not is one task. Sonnet and Opus with Fusion cost about twice as much as without it in that study, because the tool list and the prompt sent to the host every turn cost more than Fusion saved on four small tasks. The tool list has since been cut by more than half (how large it is); no live study was re-run after that, so the cost of the Fusion arms is unmeasured since then.

Smoke test

After installing, in a project directory with keys set:

  1. /mcp lists plugin:fusion:fusion (or fusion after a server-only install) as connected, with eleven tools.
  2. /fusion:stats returns a summary without calling a model: spend, savings, host tokens saved and, once a fusion bench e2e study exists, its table.
  3. /fusion:ask How should I retry a failed HTTP call? shows progress (panel 1/2 done ...) and returns a short answer with a cost line.
  4. Make a small change, then /fusion:review: it reads the diff and reports findings with a cost line and ~N host tokens saved.
  5. /fusion:digest What does src/ do? src/**/*.py returns a few hundred tokens and names any path it could not read.
  6. /fusion:plan Add a retry to the HTTP client and /fusion:decide Redis or Postgres? both call fusion_plan (check with /mcp: no fusion_plan_feature or fusion_decide_architecture).
  7. /fusion:patch Fix <a small bug> tests: python -m pytest -q tests/test_x.py returns a diff and an apply line; apply it, run the tests, then /fusion:feedback used (or wrong and why).
  8. Ask "use the fusion-advisor to review my last change": the reply is a short verdict, and /agents shows the advisor on Haiku 5.5.
  9. fusion install claude-code --plugin again reports "nothing to do".

Troubleshooting

  • The server does not connect. The first start downloads and builds Fusion (a clone and a build, up to a minute). Run /mcp reconnect all, or raise Claude Code's startup timeout: MCP_TIMEOUT=120000 claude. uvx must be on the PATH Claude Code sees.
  • Two fusion servers. A server-only install and the plugin both define one. Keep the plugin and run claude mcp remove fusion.
  • A call is moved to the background. Claude Code backgrounds MCP calls that run longer than two minutes (CLAUDE_CODE_MCP_AUTO_BACKGROUND_MS); Fusion's own soft limit returns a digest after 90 seconds by default (below).
  • Uninstall. claude plugin uninstall fusion@fusion-code-orchestrator, and claude mcp remove fusion for a server-only install.

Cursor

Requirements: uv and Cursor. One command, run in the project:

uvx --python '>=3.11' --from git+https://github.com/alexandre0sheva/fusion-code-orchestrator fusion install cursor

Or, from a checkout: uv run fusion install cursor. It merges the fusion server (the same uvx --from git+... command as Claude Code) into .cursor/mcp.json and writes .cursor/rules/fusion.mdc, a rule that tells the agent when to call Fusion and when not to (it applies "intelligently": Cursor loads it when the description fits the task). Restart Cursor, then check Settings > Tools & MCP shows fusion with its tools.

Option Meaning
--global Register for every project in ~/.cursor/mcp.json. No rule is written: Cursor has no global rules file, so paste the body of integrations/cursor/rules/fusion.mdc into Settings > Rules if you want it everywhere
--no-rules Register the server only
--dry-run, --ref TAG, --local-checkout PATH, --force, --no-verify As for Claude Code (--force also replaces an edited rule)

The merge keeps every other server and key in mcp.json, refuses a different fusion entry or an edited rule without --force, refuses a malformed file untouched, and does nothing when run again. Every refusal is decided before anything is written. By hand, the file is integrations/cursor/mcp.json. Provider keys come from the environment Cursor starts in (launch it from a shell that has them exported).

Smoke test. (1) Settings > Tools & MCP lists fusion with eleven tools. (2) In Agent chat ask "call fusion_stats": it answers with a spend summary and calls no model. (3) Ask "use Fusion to review this diff" with a staged change: the agent calls fusion_review_diff and reports findings. (4) fusion install cursor again says "nothing to do".

Codex

Requirements: uv and Codex (CLI, IDE extension or the desktop app; they share ~/.codex/config.toml).

uvx --python '>=3.11' --from git+https://github.com/alexandre0sheva/fusion-code-orchestrator fusion install codex

Or, from a checkout: uv run fusion install codex. It adds [mcp_servers.fusion] to ~/.codex/config.toml (or $CODEX_HOME/config.toml) and a managed block to ~/.codex/AGENTS.md that tells the agent when to call Fusion. Besides command and args it sets three keys, because Codex's defaults do not suit Fusion:

Key Set to Why
startup_timeout_sec 120 (Codex default 10) The first start clones and builds Fusion
tool_timeout_sec 180 (Codex default 60) A call takes tens of seconds and Fusion's own soft limit is 90 s; at 60 s Codex would abort first
env_vars the four provider keys (OPENROUTER_API_KEY included) Codex forwards only the variables listed here to an MCP server, so without it the server runs without keys

A larger value you already have is kept, never lowered. The file is edited with tomlkit, so your comments, ordering and other servers stay as they were; a different fusion entry is refused without --force (which replaces only its command, keeping env and other keys); a malformed file is refused untouched; running it again does nothing. The AGENTS.md block sits between <!-- fusion:begin ... --> and <!-- fusion:end -->: a re-run refreshes what is between the markers and never touches the rest. By hand, add integrations/codex/config.toml.snippet to the config and integrations/codex/AGENTS.fusion.md to AGENTS.md.

Option Meaning
--project Use .codex/config.toml and ./AGENTS.md in this project (Codex reads a project config only after you trust the project)
--no-agents-md Register the server only
--dry-run, --ref TAG, --local-checkout PATH, --force, --no-verify As for Claude Code

Export the provider keys in the shell you start Codex from.

Smoke test. (1) codex mcp list shows fusion enabled with startup_timeout_sec: 120 and tool_timeout_sec: 180. (2) In Codex ask "call fusion_stats": it answers without calling a model. (3) Ask "use Fusion to review my uncommitted diff": expect a call to fusion_review_diff, with no progress shown until it returns. (4) fusion install codex again says "nothing to do".

Which client supports what

Claude Code Cursor Codex
Tools yes yes yes
Progress notifications yes not stated in its docs no
Resources (fusion://runs/{id}, fusion://stats, fusion://strategies) yes yes no
Prompts (review-this-diff, debug-this-error, plan-this-feature) not confirmed yes no
When-to-call guidance plugin skills .cursor/rules/fusion.mdc AGENTS.md block

This is what each client's documentation says (read 2026-10-06), not something exercised by driving the client; the smoke tests are how to check a given install. Where a feature is missing:

  • No progress: the call looks like it is hanging for up to a minute. Fusion's soft limit still returns a digest after 90 s, and strategy: "solo-haiku" answers in a few seconds.
  • No resources: ask for detail: "full" instead of reading fusion://runs/{run_id}; the stats come from fusion_stats.
  • No prompts: the tools are the same, and the guidance file (rule, AGENTS.md block) already says when to call each one.

fusion doctor hook points

fusion.install.checks.inspect_clients() returns read-only findings for every client: a ClientCheck (client, location, status of ok, warn, error or absent, message and the fix command) per config file (project and user). It reads the files and starts nothing. It reports a malformed file, a fusion entry that does not run fusion mcp, and for Codex a disabled server, timeouts below Fusion's needs, or no forwarded provider key. absent is only a fault if you use that client. fusion doctor shows them, with the rest of the setup checks (CONFIGURATION.md).

MCP tool reference

Tools

Every tool is annotated readOnlyHint: true and destructiveHint: false (Fusion changes nothing on your machine; it writes only its own run database, and fusion_propose_patch runs its checks in temporary copies it deletes), openWorldHint: true (it calls provider APIs; fusion_stats and fusion_select_patch call none, and those two are idempotentHint: true; fusion_feedback calls one only with the experience library on) and idempotentHint: false. Each has a typed outputSchema. The descriptions the client shows the model say when to call the tool, when not to, and that a call takes tens of seconds and costs cents.

fusion_plan replaces 0.2.0's fusion_decide_architecture (now kind: "decision", the question in request) and fusion_plan_feature (kind: "feature", feature_description is now request). The old names still answer for this release, with a deprecation line in warnings, but are no longer listed.

Tool Call it for Do not call it for
fusion_ask A second opinion on a hard, self-contained coding question Trivial edits; anything the code in front of you answers
fusion_review_diff A non-trivial or risky diff before commit or merge Typo, formatting or one-line changes
fusion_debug_error Ranked root causes and verification steps for an error that is not obvious An error whose message names the cause
fusion_plan kind: "feature" (default): a plan for a multi-file feature whose approach is unclear. kind: "decision": a hard-to-reverse design choice, with options Small changes; choices that are easy to reverse or settled by convention
fusion_eval_answer Scoring a draft answer against a rubric Finding out whether code works or a fact is true
fusion_digest A short answer about material too large to read yourself: what a module does, where something is handled, what a big diff changes A file you are about to edit; one short file
fusion_propose_patch A bug fix or small change where a wrong patch is costly and checks can tell right from wrong: a patch returned as a diff, never applied (Patches) Large refactors; edits you can make directly
fusion_select_patch The second step of verify: "host": pick from the results of running the checks yourself (free, no model) Anything else
fusion_feedback After you acted on or rejected a Fusion answer: run_id, outcome (used, partly, wrong, ignored) and a one-line note. With the experience library on, one cheap call distils at most one per-project lesson (the response says whether one was created, updated, dropped or none); off, nothing is stored Runs you have not checked
fusion_compare_claude_runs Measuring Claude Code + Opus against Claude Code + Fusion Normal work
fusion_stats Spend, savings and shadow A/B win-rate (free, calls no model)

The size of the tool list

The host pays for every listed tool's name, description and input schema on every turn, whether or not Fusion is called, so the list is kept small: 11 tools and about 6,700 tokens (20,000 characters at Fusion's 3 characters per token), down from 12 tools and about 14,600 in 0.2.0. A test (tests/test_mcp_tool_surface.py) fails if the list grows past its budget. What was cut: the two planning tools were merged, descriptions were shortened (the long strategy text lives in the fusion://strategies resource), and the schema leaves out inputs a host rarely sets and empty defaults. The left-out inputs are still accepted:

Tool Accepted, not advertised
every panel tool file_snippets, budget, shadow_baseline (described below)
fusion_ask, fusion_review_diff changed_files, max_models, include_raw_outputs
fusion_debug_error recent_changes, environment (put them in context, or name the change in diff_ref)
fusion_eval_answer expected_criteria
fusion_compare_claude_runs opus_label, fusion_label, opus_run_id, fusion_run_id, opus_latency_ms, fusion_latency_ms, include_raw_evals

Inputs

The orchestration tools share these inputs (each tool adds its own, such as diff or error_message; fusion_digest takes question and max_answer_tokens, default 600):

Input Meaning
context The one place for background text. repo_context and repo_summary (review) and code_context (debug) are still accepted, folded into context, and no longer in the schema
paths Project files for Fusion to read itself, instead of pasting them (Reading the project)
globs Patterns such as src/**/*.py; at most 200 files
diff_ref A git revision or range (HEAD~1, main...HEAD, a sha) whose git diff Fusion reads. For fusion_review_diff it replaces diff, which is then optional; other tools get the diff as background
file_snippets Short code excerpts, each prefixed with its path; prefer paths
strategy A strategy name (panel-nano-pick, the default; auto, auto-frontier, solo-haiku, panel-duo, panel-nano, panel-mid, panel-refine, panel-cascade, panel-vote, panel-digest, panel-nano-union); overrides budget. The list is the fusion://strategies resource; see CONFIGURATION.md
budget The older preset (low, medium, high, local_only); selects a strategy
max_cost_usd A hard cap for this call, lowering (never raising) the strategy's own; the run is shifted to a cheaper form or refused before any model is called, see CONFIGURATION.md
detail compact (default) or full, below
shadow_baseline Force or suppress a shadow A/B run for this call

With panel-digest no model merges the answers: the response lists the points several models share, the disputed ones and the single-model ones, then each model's answer, and the calling agent is the aggregator. The tool descriptions say so, so the agent keeps what the models agree on and checks the rest against the code before relying on it.

Reading the project

Fusion reads only what a call names in paths, globs and diff_ref, read-only, and never writes to the project. Paths are relative to the project root: the client's first root when the client answers roots/list, else FUSION_READ_ROOT, else the directory the server runs in.

Client Root in practice
Claude Code The project directory: Claude Code starts the stdio server there
Cursor The client's root if it answers roots/list; otherwise set FUSION_READ_ROOT in the server's env in mcp.json
Codex The server's working directory (Codex's cwd for the server); otherwise set FUSION_READ_ROOT
fusion mcp --transport http Set FUSION_READ_ROOT: an HTTP server is not started in your project

The Cursor and Codex rows are from their documentation, not from driving the clients. A quick check is fusion_digest with paths: ["README.md"]: a wrong root shows up as not found in the warnings. Roots are deprecated in the MCP 2026-07-28 revision, and transports without a channel for server-to-client requests cannot ask for them; that is when the fallbacks apply.

What is refused or skipped, each with its reason in warnings and in the stored run: paths outside the root (../, absolute paths elsewhere, symlinks that lead out), anything inside .git, files .gitignore excludes, secret files (.env*, keys and certificates, secrets.*; the list is in SECURITY.md), binaries, files over 128 KB, and files past 320 KB read in one call (about 80K tokens). A diff_ref diff counts against the same limit; one that is too large is refused with a message to narrow the range. Everything read has secrets redacted before it goes to a model. The limits are FUSION_WORKSPACE_MAX_FILE_BYTES and FUSION_WORKSPACE_MAX_BYTES (CONFIGURATION.md).

Each response that read the project carries host_tokens_saved_estimate: the bytes Fusion read that the host did not have to send, divided by 4. fusion_stats sums it.

Responses

The text content is display_markdown; the same record is returned as structured content.

Field Compact (default) Meaning
display_markdown yes The answer, the top five claims, confidence and one cost line, cut at about 1,500 tokens (the cut says where the rest is)
run_id, details_uri yes Handle for the stored run: fusion://runs/{run_id}
strategy, confidence, cost_usd, latency_s, models_called yes Headline numbers; cost_usd is absent when a price is unknown
warnings yes Timeouts, provider failures, cost-cap shifts, soft-limit notices, project paths not read
host_tokens_saved_estimate yes Present when the call named paths, globs or diff_ref: tokens the host did not send. The compact text ends with the same figure (~N host tokens saved), so the host sees it without parsing the record
lessons_used yes Present when the experience library added lessons to the panel prompt: their ids. Send fusion_feedback for the run so they keep or lose their standing
partial, halted yes partial: the soft time limit cut the run short and the answer is the panel digest. halted: why there is no answer (insufficient_context, quorum, budget, timeout)
result full only Task-specific structured result
claims, agreement full only The panel's claims grouped across models; agreement score, evidence rate, calibrated confidence
usage, cost_comparison, routing, evals full only Per-model tokens, cost and latency; Fusion versus the baseline (COSTS.md); why these models; scoring of each stage
raw_outputs full only, with include_raw_outputs Each panel answer
workspace full only What was read from the project (path, bytes, redactions) and what was skipped, with reasons

fusion_propose_patch returns the same headline fields: cost_usd, host_tokens_saved_estimate, apply (how to apply the diff, or what to do next) and, in sandbox mode, confidence: the share of the checks (and your tests_cmd) that the returned patch passes.

fusion_digest cuts its compact text at max_answer_tokens plus about 200 tokens for the heading and cost line.

fusion_feedback returns recorded, action (created, updated, dropped or none), the lesson it created or updated and cost_usd. fusion_stats returns display_markdown, warnings and result: spend against the baseline, the host tokens saved, the shadow A/B and, when fusion bench e2e has run in the benchmark directory, result.e2e and a "Claude Code end to end" section with the latest study's arms (a simulated study is labelled as such); fusion_compare_claude_runs adds evals.

Patches

Inputs: task (the change), the code in paths/globs/diff_ref (required), tests_cmd (a shell command that runs the tests from the project root) and verify; the shared inputs above apply, and strategy defaults to verified-synth (three cheap models; with verify: "none", panel-nano-select). Each member writes a complete patch from its approach (minimal fix, root-cause fix) and one to three checks that judge any fix (ARCHITECTURE.md).

verify What happens You get
sandbox (default) Fusion copies the project (no ignored or secret files) and runs every check, and tests_cmd, against every patch in its own sandbox copy; the patch that passes the most checks the other members wrote wins patch (a unified diff against the project as it is), files, checks with the winner's result on each, matrix, isolation
host Fusion runs nothing: checks are validated and identical patches grouped, and one cheap call ranks them candidates (the top two diffs) and every valid check's script. Run them in a scratch worktree, then call fusion_select_patch with run_id, results ({candidate: {check id: pass\|fail\|error\|timeout}}, your own tests under a new id such as tests) and baseline (each check on the code as it is)
none No checks; one patch is selected patch

sandbox falls back to host, with a warning, when verify.sandbox_enabled is false, when the machine has no sandbox (fusion doctor says), or when the project is over the copy limits (CONFIGURATION.md). Either way the project is only read; what runs where is in SECURITY.md. The tool has no soft time limit (the checks run after the panel answers): a call takes tens of seconds to a few minutes.

Apply it yourself. Every patch is returned as text with an apply line: save it and run git apply --check fix.patch && git apply fix.patch, or make the same edits with your edit tool, then run the tests. A candidate whose patch does not apply cannot win, and when no patch applies patch is null and the warnings say why. The response states the cost and the host tokens Fusion saved by reading the files itself.

Progress, cancellation and the soft time limit

  • Progress. A client that sends a progress token receives a notification per step: routing, panel: asking 3 models, panel 1/3 done ... panel 3/3 done, refining the panel's answers, synthesizing, checking the final answer. A cascade also reports escalation. Progress counts up and has no total.
  • Cancellation. When the client cancels a request, every provider call still in flight is cancelled with it (nothing runs on after the host gave up). Calls cancelled mid-flight are on the run's ledger with unknown cost, since the provider may have billed them.
  • Soft time limit. If a call is still running after FUSION_TOOL_SOFT_TIMEOUT_S seconds (default 90; 0 or off disables), it stops waiting for models and returns the best result it has, with a warning and partial: true: the panel's digest (the answers and what they share and dispute, no synthesis) when the panel had answered, or an explanation and halted: timeout when no answer was ready. The limit does not apply to benchmark runs, and a partial answer is never cached. The limit is measured from the start of the panel, so a slow run is cut when it reaches the limit, not forecast to.

Resources and prompts

Resource Contents
fusion://runs/{run_id} One stored run: the full answer, claims, per-call cost, warnings and what was read from the project (not the text you sent)
fusion://stats The fusion_stats summary
fusion://strategies The strategies a call may name and what each budget preset means
Prompt Starts
review-this-diff (diff, focus) A review with fusion_review_diff (by diff_ref when no diff is given), then checking each finding against the code
debug-this-error (error, context) A diagnosis with fusion_debug_error, then running its verification steps
plan-this-feature (feature, constraints) A plan with fusion_plan, then fitting it to the repository

Transports

fusion mcp speaks stdio, which the client spawns (the default). fusion mcp --transport http [--host 127.0.0.1] [--port 8765] serves streamable HTTP at /mcp for clients that cannot spawn a process. It has no authentication and every call spends provider money, so it binds only to a loopback address; another --host is refused unless you pass --allow-remote.

Clients that implement less

Fusion works without any of the optional parts. A client that ignores progress sees a normal blocking call, one without resources gets the whole answer with detail: full, and one without prompts just uses the tools. Which client supports what is above.