Fusion

Fusion is a server tool: Routeplane runs it mid-generation instead of handing the call back to your client. A panel of models answers your prompt in parallel, a judge model compares (not merges) their answers into structured analysis, and the calling model writes the final answer grounded in that analysis. Use it for hard, high-stakes questions where one model’s blind spots are worth catching.

Quick start

The simplest way to use Fusion is the routeplane/fusion model alias — set it as your model and Routeplane expands it into a deliberation using your deployment’s default panel and judge. This works on any protocol, including Chat Completions:

<Tabs items={[‘Model alias (cURL)’, ‘Explicit panel (Responses)’]}>

curl http://127.0.0.1:4356/v1/chat/completions \
  -H "Authorization: Bearer $OPENAI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "routeplane/fusion",
    "messages": [
      {"role": "user", "content": "Should we migrate our event pipeline from Kafka to a managed alternative? Trade-offs."}
    ]
  }'

The alias rewrites the request onto a default outer model, attaches the Fusion declaration, and nudges the model to call the tool once. You get back a single, deliberated answer.

Declare Fusion yourself to pick the exact panel, judge, and (optionally) a dedicated synthesizer. Fusion rides the request tools array as a server tool:

curl http://127.0.0.1:4356/v1/responses \
  -H "Authorization: Bearer $OPENAI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "anthropic/claude-opus-4.8",
    "input": "Should we migrate our event pipeline from Kafka to a managed alternative?",
    "tools": [
      {
        "type": "fusion",
        "panel": [
          {"model": "anthropic/claude-opus-4.8"},
          {"model": "openai/gpt-5.5"},
          {"model": "google/gemini-3-pro-preview"}
        ],
        "judge": {"model": "anthropic/claude-opus-4.8"}
      }
    ]
  }'

**Protocol support.** The explicit `tools`-array declaration works on the **OpenAI Responses API** (`/v1/responses`) and the **Anthropic Messages API** (`/v1/messages`), which both carry server tools on the wire. The **Chat Completions** `tools` array only accepts `{type:"function"}` entries, so declare Fusion there with the **`routeplane/fusion` model alias** instead.

How it works

1. Panel — every model in the panel answers your prompt in parallel. Each member can be given provider web tools (e.g. web search) to ground its answer.
2. Judge — the judge model compares the panel’s answers and returns structured analysis: consensus, contradictions, partial_coverage, unique_insights, and blind_spots. The judge compares, it does not merge — it surfaces where the models agree and disagree rather than blending them into mush.
3. Synthesis — the calling model (or a dedicated synthesizer) reads that analysis and writes the final answer.

Configuration

Declared on the tools-array entry:

Field	Type	Description
panel	array	One entry per model answering in parallel. Each is { "model": string, "tools"?: array }, where tools are provider web tools forwarded to that member. Defaults to a single member on the request model. Capped at 8 members.
judge	object	{ "model": string } — the model that compares the panel answers. Defaults to the request model.
synthesizer	string	Optional dedicated model to write the final answer. When omitted, the calling model writes it from the returned analysis.

The deployment-wide defaults that the routeplane/fusion alias expands to — panel, judge, synthesizer, and the web tools forwarded to every member — are set in the server_tools.fusion config section. An explicit declaration on a request overrides them.

**Bounded by the server-tool loop.** Like all server tools, a Fusion turn runs inside a bounded loop — a default of 10 tool rounds, 30s per tool, and a 120s total budget per turn. A panel that exceeds the budget terminates with a truncation finish reason.

On Cloud

Fusion is enabled and managed on Routeplane Cloud — a curated default panel and judge back the routeplane/fusion alias out of the box, with per-run cost and the full panel→judge→synthesis chain visible in the request log. Self-hosters enable it by adding a server_tools.fusion block to their config (its presence turns on both the fusion server tool and the routeplane/fusion alias).

See also

• Sub-agent — delegate a self-contained task to a single worker model
• Advisor — consult one stronger model mid-task
• Provider selection — control which provider serves each panel model