Version: Latest

Fusion

Overview

fusion is a looper algorithm for multi-model deliberation. It fans a prompt out to an analysis panel, asks a judge model for structured analysis, and then asks the judge/calling model to produce the final answer.

It aligns to config/algorithm/looper/fusion.yaml.

The same runtime also supports a direct Fusion model slug through global.integrations.looper.fusion.model_names. The built-in default is vllm-sr/fusion; add openrouter/fusion there only when you intentionally want an OpenRouter-compatible alias. Direct Fusion is still signal-driven: vLLM-SR evaluates the request against Fusion-capable decisions and then executes the matched decision's judge and panel policy.

Key Advantages

Runs analysis models concurrently instead of choosing only one model.
Produces structured judge analysis before final synthesis.
Keeps Fusion policy inside vLLM-SR decisions: vllm-sr/auto can choose any route, while vllm-sr/fusion intelligently chooses among Fusion routes only.
Lets clients override the judge, analysis panel, templates, trace flags, and grounding policy per request with plugins[].id = fusion.
Degrades on partial panel failures while preserving failed model metadata.

Algorithm Principle

Fusion executes a three-stage flow:

Panel: dispatch the original request to the configured analysis models in parallel.
Judge analysis: ask the judge model for structured JSON covering consensus, contradictions, partial coverage, unique insights, and blind spots.
Final synthesis: ask the judge/calling model to write the user-facing answer using the panel responses and structured analysis.

Execution Flow

What Problem Does It Solve?

Some prompts benefit from multiple independent attempts and a judge pass rather than a single route decision. fusion makes that orchestration a router-owned policy, so clients can use it through the same chat completions endpoint. Unlike a fixed provider-side Fusion endpoint, vllm-sr/fusion first uses vLLM-SR signals and decision priority to pick the right Fusion route for the request.

When to Use

You want a panel of models to inspect the same prompt.
Contradictions or blind spots matter more than lowest latency.
A route should return one final answer but retain panel evidence for debugging.
Clients need an OpenRouter-style request override for panel composition.

Known Limitations

Fusion costs multiple model calls per request.
Streaming is emitted after panel and judge phases complete.
The first implementation does not include OpenRouter web search/fetch parity.
Final quality depends on the configured judge/calling model.

Configuration

Decision-level Fusion:

routing:
  decisions:
    - name: deliberation
      output_contract: Preserve any explicit output format exactly.
      modelRefs:
        - model: qwen3-32b
        - model: deepseek-worker
      algorithm:
        type: fusion
        fusion:
          model: qwen3-32b
          analysis_models:
            - qwen3-32b
            - deepseek-worker

output_contract is decision-scoped prompt text. Use it for benchmark or application format requirements that should apply across Fusion, Flow, and ReMoM instead of hard-coding task-specific prompts into an algorithm. Use output_contract_spec for typed router-executable normalization and post-processing such as choice extraction, terminal-action JSON normalization, or reference dereferencing. Extraction defaults to exact content matching; use extract.sources or extract.mode: json_object only when the decision explicitly permits a wider parser.

Algorithm-only fragment:

algorithm:
  type: fusion
  fusion:
    model: qwen3-32b
    analysis_models:
      - qwen3-8b
      - qwen3-32b
    max_concurrent: 2
    max_completion_tokens: 512
    round_timeout_seconds: 90
    min_successful_responses: 1
    temperature: 0.2
    include_analysis: true
    include_intermediate_responses: true
    on_error: skip
    judge_prompt_version: fusion-v1

Automatic routing aliases:

global:
  router:
    auto_model_names:
      - vllm-sr/auto
      - auto
      - MoM

vllm-sr/auto evaluates all decisions. If the matched decision uses algorithm.type=fusion, the request enters Fusion; otherwise it follows the matched non-Fusion route.

Direct Fusion slug registration:

global:
  integrations:
    looper:
      endpoint: http://localhost:8899/v1/chat/completions
      fusion:
        model_names:
          - vllm-sr/fusion

global.integrations.looper.fusion only registers direct request model names. It does not own route policy, a default route, judge selection, panel selection, concurrency, templates, or error handling.

The judge model, analysis panel, concurrency, templates, and error policy belong under routing.decisions[].algorithm.fusion. Direct slug calls evaluate only Fusion-capable decisions, so vllm-sr/fusion cannot silently fall back to a normal single-model route. Request-level plugins[].id = fusion can still override the decision panel for one call; if no Fusion decision matched, a plugin override with analysis_models can provide a request-only panel.

To expose an OpenRouter-compatible alias, opt in explicitly:

global:
  integrations:
    looper:
      fusion:
        model_names:
          - vllm-sr/fusion
          - openrouter/fusion

Request-level override:

{
  "model": "vllm-sr/fusion",
  "messages": [{"role": "user", "content": "..."}],
  "plugins": [{
    "id": "fusion",
    "model": "qwen3-32b",
    "analysis_models": ["qwen3-8b", "qwen3-32b"],
    "max_concurrent": 2,
    "max_completion_tokens": 1024,
    "round_timeout_seconds": 90,
    "min_successful_responses": 1,
    "include_analysis": true,
    "include_intermediate_responses": true,
    "grounding": {
      "enabled": true,
      "reference": "hybrid",
      "policy": "weight"
    }
  }]
}

Parameters

Parameter	Type	Default	Description
`model_names`	list[string]	`["vllm-sr/fusion"]`	Direct request model slugs that trigger Fusion execution
`model`	string	first analysis model	Judge/calling model used for analysis and final synthesis
`analysis_models`	list[string]	`modelRefs`	Panel models for parallel analysis
`max_concurrent`	int	panel size	Maximum concurrent panel calls
`max_completion_tokens`	int	request default	Max completion tokens applied to Fusion subrequests
`round_timeout_seconds`	int	wait for all	Stop waiting for a panel round after this many seconds
`min_successful_responses`	int	panel size	Continue once this many panel responses succeed
`temperature`	float	request default	Temperature applied to Fusion subrequests
`include_analysis`	bool	`true`	Include structured judge analysis in the response trace
`include_intermediate_responses`	bool	`true`	Include raw panel responses in the response trace
`on_error`	string	`skip`	`skip` partial panel failures or `fail` on the first panel error
`analysis_template`	string	built-in	Custom judge analysis prompt with `{{original}}` and `{{responses}}`
`synthesis_template`	string	built-in	Custom final prompt with `{{original}}`, `{{responses}}`, and `{{analysis}}`
`judge_prompt_version`	string	`fusion-v1`	Version marker included in Fusion response trace
`grounding`	object	disabled	Optional grounding-aware synthesis (see below)

Grounding-Aware Synthesis

By default the judge reads raw panel text with no grounding oracle. Grounding-aware synthesis scores each panel response for faithfulness before the judge runs, then uses those scores to guide synthesis toward the better-grounded responses. It makes no extra LLM calls — it uses local encoder models (the hallucination/groundedness detector and an NLI entailment model).

Reference selection (what each answer is scored against):

context — score answers against provided RAG/tool context via the detector (strongest, but only when the request carries context such as system/tool messages).
panel — score answers against each other via cross-model NLI; the panel acts as its own mutual reference (no external dependency, works on any query).
hybrid (default) — use context when the request carries it, otherwise panel.

Policy (how the scores are used):

weight (default) — keep every response and instruct the judge to weight each panel answer by its score, while explicitly protecting a correct lone dissenter.
annotate — keep every response and pass the scores to the judge as notes, without a weighting instruction.
filter — hard-drop responses scoring below min_score (always keeping min_keep); only this policy uses min_score/min_keep.

Grounding measures faithfulness/consistency, not truth. With no authoritative source it can down-weight the least-supported responses, not certify correctness. Hard-dropping the least mutually-consistent response (the filter policy) measurably hurts on contested factual questions — three models can be confidently wrong together while the lone dissenter is right — so the default is weight. See bench/grounded_fusion/FINDINGS.md for the evaluation behind this default.

Requires the hallucination detector (and, for the panel/cross-model path, the NLI model) to be configured under global hallucination mitigation. If the backends are unavailable, on_error: skip falls back to plain Fusion.

algorithm:
  type: fusion
  fusion:
    model: qwen3-32b
    analysis_models: [qwen3-8b, qwen3-32b]
    grounding:
      enabled: true
      reference: hybrid          # hybrid | context | panel
      policy: weight             # weight | annotate | filter
      min_score: 0.0             # filter policy only: drop below this (0-1)
      min_keep: 1                # filter policy only: keep at least this many
      nli_contradiction_penalty: 1.0
      on_error: skip             # skip (fall back to plain fusion) | fail

When enabled, the Fusion response trace.grounding records the reference mode, the policy, and per-response score, flagged_spans, and whether each was dropped (only under the filter policy).

Grounding parameters

Parameter	Type	Default	Description
`enabled`	bool	`false`	Enable grounding-aware synthesis
`reference`	string	`hybrid`	`hybrid`, `context`, or `panel`
`policy`	string	`weight`	`weight` (soft-weight, keep all), `annotate` (notes, keep all), or `filter` (hard-drop)
`min_score`	float	`0.0`	`filter` policy only: drop responses scoring below this (0–1)
`min_keep`	int	`1`	`filter` policy only: keep at least this many top-scoring responses
`nli_contradiction_penalty`	float	`1.0`	Weight of a peer contradiction in the `panel` reference
`on_error`	string	`skip`	`skip` (fall back to plain Fusion) or `fail`

Fusion

Overview​

Key Advantages​

Algorithm Principle​

Execution Flow​

What Problem Does It Solve?​

When to Use​

Known Limitations​

Configuration​

Parameters​

Grounding-Aware Synthesis​

Grounding parameters​