Frontier-grade answers from any mix of models — now in your own MCP server.
OpenRouter showed that synthesizing the outputs of several models consistently beats any single frontier model — and that you don't even need expensive models to get there. In their Fusion announcement, a panel of cheap models fused together outperformed solo frontier models on deep-research tasks, landing within striking distance of top-tier models at a fraction of the cost.
The catch: you had to use OpenRouter.
OpenFusion removes that catch. It's a local MCP server that brings the exact same Fusion architecture to any MCP-capable coding agent or client — Claude Code, Cursor, Cline, Zed, Codex, Gemini CLI, Continue, and 18+ others. Bring your own keys for any provider; OpenFusion runs entirely on your machine.
OpenRouter's headline finding: a budget panel of cheap models, fused, landed within ~1% of Claude Fable 5 on deep research — at roughly half the price. OpenFusion lets you build that budget panel yourself, with the cheapest models from any providers you like. Fable-5-class answers, at budget-panel cost, from the agent you already use.
OpenFusion is a fusion engine, not an agent. It doesn't browse, doesn't call tools, doesn't do research itself — you give it the prompt (and any context you've gathered), and it does one thing very well:
your prompt ──► fan out to 2–5 candidate models (parallel, single-shot)
│ Promise.allSettled + per-candidate timeout
▼
survivors (≥2 required)
│
▼ judge step 1: structured analysis
{ consensus · contradictions · partial coverage · unique insights · blind spots }
│
▼ judge step 2: synthesis (candidates + analysis only)
one consolidated answer ◄── returned to your agent
The two-step judge is the magic. OpenRouter found that ~¾ of the performance lift comes from the synthesis step itself, not just model diversity — splitting "analyze the candidates" from "write the final answer" is what makes the output measurably better than any single contributor. Both steps use the same judge model you configure.
Every fusion is logged to a local SQLite database and visualized in a glass-morphic dashboard — per-model cost, tokens, and latency, with each fusion expandable into its constituent calls.
- Complex reasoning & architecture decisions where a second (and third) opinion genuinely helps.
- Deep research & source synthesis across multiple perspectives.
- Cross-model verification for high-stakes answers where independent agreement builds confidence.
- Budget-conscious quality — a panel of cheap models, fused, can beat a single expensive one.
And when not to: routine coding, simple lookups, single-turn Q&A. Fusion is 2–3× slower and costlier than one call, so the shipped SKILL.md teaches your agent to reach for it selectively.
Requires Node.js 22+. Published to npm — no clone or build needed.
Quick start (3 steps):
- Register OpenFusion with your MCP client:
npx openfusion-setup # interactive: picks your client, writes its config, installs the agent skill - Restart your MCP client so it loads OpenFusion. The client spawns the server, which on first run prints a banner and opens the dashboard at
http://localhost:9077. - Configure in the dashboard: add 2–5 candidate models + a judge + an API key per provider (use Test to validate each). The ● Configured badge turns green and
fusionworks immediately.
That's it — the fusion + open_dashboard tools are now available to your agent.
One-command (recommended): npx openfusion-setup writes the correct snippet for your client (Claude Code, Cursor, Cline, Zed, Codex, Gemini CLI, ZCode, Claude Desktop, …) and installs the skill.
Manual registration: point your MCP client at npx -y openfusion-mcp. See INSTALL.md for exact recipes for 18+ clients. (Claude Code and ZCode also auto-load the repo's .mcp.json when you open the project.)
From source (if you cloned):
pnpm install && pnpm build # tsc -> dist/ ; vite -> ui-dist/
node dist/index.js # start the server + dashboard
# then register with `node /abs/path/to/openfusion/dist/index.js` in your clientNative build note:
better-sqlite3compiles a native addon at install. On most platforms a prebuilt binary is fetched automatically. If install fails, runnpm rebuild better-sqlite3(requires Python 3 + a C++ toolchain — Xcode CLT on macOS,build-essentialon Linux). If the addon is missing at runtime, OpenFusion prints a clear fix-it message instead of a cryptic stack trace.
OpenFusion stores config, encrypted keys, and the SQLite DB under OPENFUSION_HOME — defaulting to your OS data dir (~/Library/Application Support/openfusion on macOS, ~/.local/share/openfusion on Linux). The path is printed on every startup, so you always know where your config/secrets are. Set OPENFUSION_HOME to override (e.g. for a separate profile), and restart the server after changing it — two servers with different OPENFUSION_HOMEs see different configs.
- Open http://localhost:9077 (or start the dashboard anytime with
npx openfusion-ui, ornode dist/ui-only.jsfrom source). - Add 2–5 candidate models (provider + model each), pick a judge, and enter an API key per referenced provider. Use Test to validate each before saving.
- The ● Configured badge turns green → the
fusiontool works immediately (no restart).
Keys are AES-256-GCM encrypted at rest (secrets.enc + a chmod-600 machine-bound master.key); the dashboard binds to 127.0.0.1 only.
| Tool | Input | Returns |
|---|---|---|
fusion |
{ prompt, context? } |
one consolidated answer (+ progress notifications) |
open_dashboard |
{} |
opens http://localhost:9077 |
Glass-morphic, OpenFusion-branded · KPIs · fusions-per-day · cost-by-model · token-usage-by-model · expandable activity log
Every fusion writes one activity row + N+2 sub-call rows (each candidate + the two judge steps) — so you can see exactly which model said what, cost how much, and took how long. That's the "activity as a dimension" powering the charts.
TypeScript (ESM, ES2022, NodeNext) · @earendil-works/pi-ai (provider layer) · @modelcontextprotocol/sdk v1 · better-sqlite3 · Express 5 (loopback-only) · React + Vite + Tailwind + recharts · Vitest.
npx openfusion-setup # interactive installer (writes client config + installs skill)
npx openfusion-mcp # run the MCP server + dashboard
pnpm build # tsc -> dist/ ; vite -> ui-dist/ (from source)
pnpm test # 50 tests, deterministic (pi-ai faux providers — no real API calls)
node dist/index.js # MCP server (stdio) + dashboard (from source)
node dist/ui-only.js # standalone always-on dashboardgit pull && pnpm install && pnpm build # from source; or just re-run npx for the published versionThen restart the server so it loads the new code — a running process won't pick up changes. Config schema upgrades are automatic on load (a one-time notice prints to stderr, e.g. config upgraded from v1 → v2). You won't lose your candidates/judge/keys.
Client tool-call timeouts: a fusion with several candidates + a judge can take ~30–90s (sometimes more). Some MCP clients enforce a tight tool-call ceiling (e.g. 60s). If a
fusioncall appears to fail from the client side, the server likely completed and logged it anyway — check the Generations or Errors tab in the dashboard (http://localhost:9077) for the result.
src/ server (fusion engine, MCP, REST API, config, SQLite) — see ARCHITECTURE.md
ui/ React dashboard (Vite + Tailwind + recharts)
skill/ SKILL.md — agent guidance, shipped with the package
specs/ speckit design record (spec / plan / contracts / tasks)
public/ logo + banner
Contributions welcome — see CONTRIBUTING.md. The project has a constitution of seven design principles that changes must respect. AGENTS.md has the coding guidelines.
- OpenRouter for the Fusion research and architecture that this project implements locally.
- pi-ai (Mario Zechner / earendil-works) for the excellent multi-provider LLM abstraction.
- The Model Context Protocol team for the open standard this plugs into.
MIT © Hashan Wickramasinghe
Frontier-grade fusion. Any providers. Your machine. No lock-in.
