Skip to main content
The Fusion Router (openrouter/fusion) gives your model access to a multi-model deliberation tool. When invoked, a panel of models answers your prompt in parallel, then a judge model compares their responses and returns structured analysis — consensus, contradictions, coverage gaps, unique insights, and blind spots. Your model uses that analysis to write a better final answer.

​
Overview

Use Fusion when a single model isn’t enough — research questions, expert critique, “compare and contrast” prompts, or anything where the cost of being wrong outweighs the cost of a few extra completions.

​
How it works

  1. You send a request with model: "openrouter/fusion". The router resolves the alias to a real model and attaches the openrouter:fusion tool.
  2. Your model reads the prompt and decides whether the task warrants deliberation. If so, it invokes openrouter:fusion. (Use tool_choice: "required" to guarantee invocation.)
  3. The panel — a set of models — answers your prompt in parallel, each with openrouter:web_search and openrouter:web_fetch enabled.
  4. The judge receives all panel responses, with openrouter:web_search and openrouter:web_fetch available, and compares them — it doesn’t merge them. It returns structured analysis as JSON: what all or most models agreed on (treated as higher-confidence consensus), where they disagreed, what only some models covered, unique insights from individual models, and blind spots none of them addressed.
  5. Your model receives the analysis and writes the final answer.
openrouter:web_search and openrouter:web_fetch are enabled on both the panel and the judge calls, so models can pull fresh sources while they answer and analyze.

​
Two ways to use it

{
  "model": "openrouter/fusion",
  "messages": [
    { "role": "user", "content": "What are the strongest arguments for and against carbon taxes?" }
  ]
}
Both hit the same pipeline. The model alias is simpler — it auto-injects the tool so you don’t have to declare it. The server tool form gives you more control (choose your own outer model, combine fusion with other tools). In both cases, the model decides when to call openrouter:fusion. For prompts that don’t need deliberation, it answers directly — including invoking any other tools you’ve defined. Add tool_choice: "required" to force fusion on every request.

​
Quick start

import { OpenRouter } from '@openrouter/sdk';

const openRouter = new OpenRouter({
  apiKey: '<OPENROUTER_API_KEY>',
});

const completion = await openRouter.chat.send({
  model: 'openrouter/fusion',
  messages: [
    {
      role: 'user',
      content: 'Survey the strongest arguments for and against a carbon tax. Where do experts disagree?',
    },
  ],
});

console.log(completion.choices[0].message.content);

​
Configuration

Override the default panel and judge via the plugins array or the tools array. Both are optional — omit them entirely and fusion uses the Quality preset defaults. Pass a fusion plugin entry alongside model: "openrouter/fusion". This is the same pattern the Pareto Router uses for min_coding_score. 
const completion = await openRouter.chat.send({
  model: 'openrouter/fusion',
  plugins: [
    {
      id: 'fusion',
      analysis_models: [
        '~anthropic/claude-opus-latest',
        '~openai/gpt-latest',
        '~google/gemini-pro-latest',
      ],
      model: '~openai/gpt-latest',
    },
  ],
  messages: [
    {
      role: 'user',
      content: 'Compare ridge, lasso, and elastic-net regression. Where does each shine?',
    },
  ],
});

​
Tool config (when using your own outer model)

When you bring your own model and add openrouter:fusion as a server tool, configure it via the tools array instead: 
const completion = await openRouter.chat.send({
  model: '~anthropic/claude-opus-latest',
  messages: [
    {
      role: 'user',
      content: 'Compare ridge, lasso, and elastic-net regression. Where does each shine?',
    },
  ],
  tools: [
    {
      type: 'openrouter:fusion',
      parameters: {
        analysis_models: [
          '~anthropic/claude-opus-latest',
          '~openai/gpt-latest',
          '~google/gemini-pro-latest',
        ],
        model: '~openai/gpt-latest',
      },
    },
  ],
});
FieldDefaultDescription
analysis_modelsQuality preset (~anthropic/claude-opus-latest, ~openai/gpt-latest, ~google/gemini-pro-latest)Models that form the panel. Each runs in parallel with openrouter:web_search and openrouter:web_fetch enabled. 1–8 models allowed.
modelYour outer modelThe judge model that produces the structured analysis JSON. Defaults to the same model handling your request.
max_tool_calls8Max tool-calling steps each panel model and the judge may take in their openrouter:web_search / openrouter:web_fetch loop before they must return text. Range 1–16.
max_completion_tokensProvider defaultMax output tokens (including reasoning) per inner panel/judge call. Keeps reasoning-heavy models from exhausting their budget before producing visible text.
reasoningProvider defaultReasoning config forwarded to the panel and judge calls — an object with optional effort and max_tokens.
temperatureProvider defaultTemperature (0–2) forwarded to the panel calls. The judge always runs at temperature 0.

​
Forcing fusion on every request

By default, the model decides when to call openrouter:fusion. To guarantee it runs on every request, set tool_choice: "required": 
const completion = await openRouter.chat.send({
  model: 'openrouter/fusion',
  messages: [
    {
      role: 'user',
      content: 'Compare ridge, lasso, and elastic-net regression.',
    },
  ],
  tool_choice: 'required',
});
Because openrouter/fusion only injects one tool (openrouter:fusion), requiring some tool call effectively forces fusion. If your request also includes other tools, the model may pick one of those instead.

​
Response

The response model field reports the concrete model that handled the request — not the openrouter/fusion alias: 
{
  "id": "gen-...",
  "model": "anthropic/claude-opus-4.5",
  "choices": [
    {
      "message": {
        "role": "assistant",
        "content": "..."
      }
    }
  ]
}
To confirm a generation went through the Fusion Router, check the generation metadata. The router field reports openrouter/fusion: 
{
  "data": {
    "id": "gen-...",
    "model": "anthropic/claude-opus-4.5",
    "router": "openrouter/fusion"
  }
}

​
Cost

Fusion runs N panel calls + 1 judge call in addition to your normal request. With the default 3-model panel, expect roughly 4–5× the cost of a single completion on the same prompt. Cost scales linearly with panel size.

​
Recursion protection

Inner fusion calls carry an x-openrouter-fusion-depth header. Panel and judge models cannot recursively invoke openrouter:fusion — the plugin refuses to inject the tool a second time, keeping deliberation bounded to a single level.