Costs and Baseline Comparison¶
Fusion tracks cost and usage at provider-call granularity. The goal is transparent comparison, not false precision.
Canonical for the cost and pricing methodology: where prices come from, how a call and a run are priced, what the baseline comparison means, and the per-strategy cost table (generated from the catalog).
Pricing: the model catalog¶
Prices live in the model catalog, src/fusion/config/catalog.yaml, next to each model's provider
ID and capabilities. That file is the single source of truth for the numbers; this page does not
repeat them. Run uv run fusion models list to see current IDs and prices.
Each model has one or more price schedules (USD per 1M tokens):
input_per_1mandoutput_per_1m;- optional
cached_input_per_1m,cache_write_per_1mandreasoning_per_1m(only when reasoning tokens are billed separately from output tokens); effective_from/effective_untilfor scheduled provider changes, for example an introductory price that ends on a known date (the right schedule is chosen by today's date);above_prompt_tokensfor a long-context price (see below);verified_onandsource_url: every cloud price must name where and when it was verified.
Long-context prices¶
Some models charge more for a large prompt: Claude Haiku 5.5 above 100,000 prompt tokens, and the
GPT-6.x models above 272,000. A price row with above_prompt_tokens: N applies to a request whose
prompt (every input token, cached ones included) is larger than N, and then to the whole request,
as the providers bill it. Each call is priced on its own prompt size: the ledger uses the call's
reported input tokens, and the max_cost_usd forecast uses the planned prompt size (prompt plus
900 tokens of overhead). A Haiku 5.5 call with a 150K prompt is priced at $0.50 / $2.50, not
$0.10 / $0.50.
Price tiers¶
A model's tier is computed from its price, never written by hand. The tiering: block of
catalog.yaml sets the weights and thresholds:
blended = (3 × input + output) / 4 USD per 1M tokens (a 3:1 input:output mix, typical of review
and debug calls).
| Tier | Blended price | Example |
|---|---|---|
nano |
below $0.50 | $0.10 / $0.50 → $0.20 |
low |
$0.50 to below $2.50 | $1 / $5 → $2.00 |
medium |
$2.50 to below $6 | $2 / $10 → $4.00 |
high |
$6 to below $12 | $4 / $20 → $8.00 |
premium |
$12 and above | $8 / $40 → $16.00 |
The tier follows the price in effect on a date and for a prompt size, so it moves with a scheduled
price change (Gemini 4 Carbon and Argon go from medium to high on 2026-12-01; Gemini 3.8 Flash
from low to medium on 2027-01-01) and with a long prompt (Haiku 5.5 is low above 100K).
fusion models list shows each model's blended price, tier and coming tier changes
(--on YYYY-MM-DD prices the catalog on another date). A model with no price in effect counts as
premium.
Local and mock models need no price block and are free. Token accounting rules:
input_tokens includes cached tokens, which are billed at the cached rate (or the input rate when
no cached rate is configured); reasoning tokens are assumed to be part of output_tokens unless a
separate reasoning_per_1m is set.
If provider billing returns an actual cost, Fusion prefers that (OpenRouter does: every call
through it asks for usage.cost, which the ledger records as billed, not estimated). Otherwise it estimates from the
catalog price in effect today and the reported token usage. If pricing or token usage is missing,
cost is marked unknown rather than invented.
Keeping prices honest¶
uv run fusion models check # stale prices, price changes and retirements coming up
uv run fusion models check --live # also ask each provider's free list-models endpoint, and OpenRouter
check warns when a price was verified more than 60 days ago, when a price changes within 30 days
(with the tier change, if any), when an enabled model is not the newest of its family in the
catalog, and when a provider's earliest retirement date for a model is within 60 days. --live
sends your API keys (in headers) to the providers' free models endpoints only, and also flags an
ID the provider does not list, a family where the provider lists a newer model (Flash-Lite and
other suffixed variants count as other families), and a price source_url that redirects. It also
reads OpenRouter's public model list (no key) and, for every model with an OpenRouter ID, flags an
ID OpenRouter does not list (UNKNOWN), a price more than 5% away from OpenRouter's in either
direction, long-context and time-of-day rates included (DRIFT), and a newer model of the same
family, by version and listing date (NEWER); and it reads OpenRouter's provider list for hosts
that may train on prompts missing from openrouter.provider_ignore (POLICY). The vendors'
list-models endpoints carry no prices, so prices are compared with OpenRouter only. It
makes no completion calls and costs nothing. fusion doctor shows the same warnings (the live ones
with --live).
Baseline models¶
Baselines are configured in src/fusion/config/baseline.yaml as catalog aliases:
baselines:
- name: "Opus 5.5"
model: claude-opus
enabled: true
estimate_strategy: "same_input_and_output_tokens"
The provider, model ID and price are resolved from the catalog. The first enabled baseline is the one used for cost comparison and the shadow A/B; further entries are extra comparison arms for the benchmark mode (GPT-6.2 Sol, and the benchmark-only Claude Fable 5.2, GPT-6.2 Astra and Gemini 4 Carbon). The default strategy estimates the cost of sending the same aggregate input/output token volume to the baseline model. This is useful for directional comparison, but it is not the same as actually running the baseline model.
What a task costs, by strategy¶
The synthesis call reads every answer, so it is a large share of a panel's cost (about half of
panel-nano, most of panel-cheap-strong-synth). That is why strategies can drop it (digest,
vote, best_of) or skip it on easy tasks (cascade). The table below prices
each packaged strategy for a typical task: every call reads 5,000 tokens (the task plus system
prompt and schema) and every answer is 1,500 tokens, at the catalog prices in effect on the date
below. It is generated by the same arithmetic the cost cap uses (fusion.routing.budget), not
typed by hand, and tests/test_cost_table.py fails when it drifts from the catalog.
| Strategy | Calls | Cost per task | Relative to solo-opus |
|---|---|---|---|
auto (answered at rung 0, nano-solo) |
1 | $0.0013 | 0.02x |
auto-frontier (answered at rung 0, nano-solo) |
1 | $0.0013 | 0.02x |
solo-haiku |
1 | $0.0013 | 0.02x |
solo-haiku-check |
1 | $0.0013 | 0.02x |
solo-luna |
1 | $0.0013 | 0.02x |
panel-cascade (first wave agrees) |
2 | $0.0025 | 0.05x |
panel-duo (panel agrees) |
2 | $0.0026 | 0.05x |
panel-haiku-lenses |
3 | $0.0039 | 0.08x |
panel-luna-lenses |
3 | $0.0039 | 0.08x |
panel-duo (synthesizes) |
3 | $0.0043 | 0.09x |
panel-luna-approaches |
4 | $0.0050 | 0.10x |
panel-mixed |
4 | $0.0055 | 0.11x |
panel-open |
5 | $0.0089 | 0.18x |
solo-flash |
1 | $0.0094 | 0.19x |
best-of-n-verified |
3 | $0.0119 | 0.24x |
panel-vote |
3 | $0.0119 | 0.24x |
panel-digest |
3 | $0.0124 | 0.25x |
panel-nano-union |
3 | $0.0124 | 0.25x |
solo-terra |
1 | $0.0125 | 0.25x |
panel-nano-pick |
4 | $0.0133 | 0.27x |
panel-nano-select |
4 | $0.0133 | 0.27x |
verified-synth |
4 | $0.0133 | 0.27x |
auto (answered at rung 1, nano-panel) |
4 | $0.0144 | 0.29x |
auto-frontier (answered at rung 1, nano-panel) |
4 | $0.0144 | 0.29x |
panel-nano |
4 | $0.0144 | 0.29x |
panel-nano-auto |
4 | $0.0144 | 0.29x |
solo-hydrogen |
1 | $0.0187 | 0.37x |
solo-argon |
1 | $0.0250 | 0.50x |
solo-carbon |
1 | $0.0250 | 0.50x |
solo-sol |
1 | $0.0250 | 0.50x |
solo-sonnet |
1 | $0.0250 | 0.50x |
panel-refine |
7 | $0.0297 | 0.59x |
auto-frontier (answered at rung 3, frontier) |
1 | $0.0500 | 1.00x |
solo-opus |
1 | $0.0500 | 1.00x |
panel-cascade (escalates) |
4 | $0.0504 | 1.01x |
panel-cheap-strong-synth |
4 | $0.0509 | 1.02x |
auto (answered at rung 2, mid-panel) |
4 | $0.0975 | 1.95x |
auto-frontier (answered at rung 2, mid-panel) |
4 | $0.0975 | 1.95x |
panel-mid |
4 | $0.0975 | 1.95x |
solo-astra |
1 | $0.1000 | 2.00x |
solo-fable |
1 | $0.1000 | 2.00x |
auto (climbs rungs 0-2, at most) |
9 | $0.1131 | 2.26x |
auto-frontier (climbs rungs 0-2, at most) |
9 | $0.1131 | 2.26x |
How to read it: auto has a row per rung that can answer (where an easy, normal or hard request
starts and ends) and one for the longest climb a run may make; a real climb costs less than that
row, because a higher rung reuses the answers below it instead of asking those models again. A
refinement round re-reads the peers' answers, a synthesizer reads every answer
plus the claim clusters, and the cascade rows are its two outcomes (the two cheapest models agree
and the run stops, or it escalates to the whole panel and the synthesizer). The numbers are an
illustration of how strategies compare, not a measurement: real answer lengths differ, reasoning
tokens are billed as output, and quality is not in the table (the benchmark mode measures it).
Local models are free and left out.
Regenerate after a catalog or strategy change (or to price another date):
uv run python evals/runners/cost_table.py --write # rewrite the table in this file
uv run python evals/runners/cost_table.py --on 2027-01-01 # print it for another date
Cost caps¶
A strategy's max_cost_usd is a hard cap enforced twice (settings in
CONFIGURATION.md). Before any call, the run's planned
calls are priced with the assumptions above, using the prompt's real size, and the strategy is
shifted down until the forecast fits; a forecast that cannot fit even the cheapest model alone
refuses the run with no spend. During the run, each optional stage is priced against the money
already spent, using the answers' real sizes, and skipped if it would pass the cap. The forecast
is an estimate: a run's reported cost always comes from the ledger, and a run that still ends over
its cap says so in its warnings.
What the comparison reports¶
CostComparison includes:
- baseline name and model ID;
- Fusion total cost;
- baseline estimated cost;
- savings in USD;
- savings percent;
- whether Fusion was cheaper;
- whether both costs are known;
- notes explaining estimate assumptions.
UsageSummary includes:
- total input/output/token counts;
- per-model usage and failures;
- Fusion wall latency;
- panel wall latency;
- synthesis latency;
- summed model-call latency;
- max panel latency.
What Claude Code sees¶
Every orchestration response carries a compact cost section in display_markdown plus the
machine-readable usage and cost_comparison objects:
Cost & usage:
- Fusion cost: $0.0180 estimated
- Opus 5.5 baseline estimate: $0.0710 estimated
- Estimated savings: $0.0530 / 74.6%
- Fusion wall time: 8.4s
- Panel: 4 models, 3 succeeded, 1 failed
From the second run on, a lifetime footer is appended (aggregated by fusion stats and the
fusion_stats tool):
- Lifetime: 42 runs · $0.85 spent vs $6.40 baseline est. (86.7% saved) · shadow win-rate 62% (n=8)
When a shadow A/B ran, the baseline cost and latency in cost_comparison are actual values rather
than estimates, and shadow cost is never counted as Fusion cost.
Latency caveat¶
Fusion can accurately report its own wall time and model-call latencies. It does not invent baseline latency. Baseline latency remains unknown unless a benchmark explicitly calls the baseline model.
Operational guidance¶
Run config validation after editing model, routing, pricing, or baseline YAML:
uv run fusion config validate
Use stored run comparisons for auditing:
uv run fusion runs show RUN_ID
uv run fusion runs compare-baseline RUN_ID
uv run fusion runs costs
When pricing changes, update the entry's price, source_notes and updated_at.