The three-layer AI bill: model + tools + orchestration
The short answer. Until September 2026 a cost-per-task model had two layers: the model's tokens and the tools it called. Sakana's Fugu Max, released on 2026-09-11, adds a third by selling the routing decision itself as a metered API SKU - a router that wraps a pool of frontier models behind one endpoint and bills its own orchestration tokens at standard input and output rates. On the fixed workload worked below (10,000 tasks a month), that third layer costs $95.00 a month while the rate-card advantage it exists to capture is worth $48.00 a month, so the orchestrated build comes to $404.30 a month against $376.00 for simply calling one frontier model on every task.
1. What changed: routing became a priced layer
Fugu Max is sold as an API-compatible endpoint, not as a framework you host: you send a normal chat completion and the product decides which model in its pool answers it. Sakana describes the policy as routing each task to "the leanest model capable of solving them". That is ordinary routing. What is new is that the routing step has its own meter.
| Model (provider id) | Input /1M | Output /1M | Cached input /1M | Context | Max output | Listed | Source |
|---|---|---|---|---|---|---|---|
Fugu Max (fugu-max-v1.0; OpenRouter sakana/fugu-max) | $2.00 | $6.00 | $0.25 | 1,000,000 * | 128,000 * | 2026-09-11 | console.sakana.ai/pricing; OpenRouter models API |
Fugu Ultra v2 (fugu-ultra-v2.0; OpenRouter sakana/fugu-ultra-v2) | $5.00 | $30.00 | $0.50 | 1,000,000 * | 128,000 * | 2026-09-11 | console.sakana.ai/pricing; OpenRouter models API |
| Fugu Ultra v2, context above 272K (vendor tier) | $10.00 | $45.00 | $1.00 | 272K threshold (vendor-stated) | not published | 2026-09-11 | console.sakana.ai/pricing |
web_search / web_fetch, per call | $0.007 | per call, not per 1M tokens; held identical in every scenario below | not applicable | 2026-09-11 | console.sakana.ai/pricing | ||
* The 1,000,000-token context and 128,000-token output ceiling are OpenRouter's figures. Sakana publishes no context window for Fugu Max at all, so those two cells are sourced to openrouter.ai/api/v1/models and not to the vendor. The $2.00 / $6.00 / $0.25 rate card and the $0.007 call fee are confirmed on two surfaces: console.sakana.ai/pricing and openrouter.ai/api/v1/models. Launch date and the public model names come from sakana.ai/fugu-max-release/. All retrieved 2026-09-11.
The billing mechanic that creates the third layer. Sakana's own rate card, verbatim: the orchestration tokens "represent real token usage outside of the input and output tokens and will be counted in the final price of the request. The price will be the same as standard input and output tokens." The usage fields are exposed as orchestration_input_tokens, orchestration_input_cached_tokens and orchestration_output_tokens. A rate-card saving is therefore only real if the router prevents retries or multiplies work - not if it adds a parallel pass of its own.
The counter-mechanic, from the same page. "Multiple agents - We never stack model fees. You are charged a single rate based on the top tier model involved." That rule bounds the worst case and produces the price variant labelled (c2) below.
2. The same workload, priced three ways
One workload, three scenarios, no other variable moved. The tool layer is deliberately identical in all three, so the routing decision is the only thing that changes the bill.
| Workload input | Value |
|---|---|
| Tasks per month | 10,000 |
| Input tokens per task | 4,000 |
| Output tokens per task | 1,200 |
| Tool calls per task | 2.0 |
| Tool-result tokens re-sent as input, per call | 900 |
| Billed input tokens per task | 5,800 (4,000 + 2.0 x 900) |
| Tool-call fee | $0.007 per call = $0.014 per task |
| Monthly tool layer | $140.00 (10,000 x $0.014) |
The three rate cards in the comparison, priced per task against that workload:
| Rate card | In $/1M | Out $/1M | $ per task | Source |
|---|---|---|---|---|
| (a) frontier - Claude Sonnet 5 | $2.00 | $10.00 | $0.02360 | OpenRouter models API |
| (b) cheap - GLM-5.3 | $1.26 | $3.96 | $0.01206 | OrcaRouter, GLM-5.3 Z.ai list rate |
| (c) orchestrator - Fugu Max | $2.00 | $6.00 | $0.01880 | console.sakana.ai/pricing |
Routing one task down from the frontier card to the cheap card is worth $0.01154 per task ($0.02360 - $0.01206). That is the entire prize the orchestrator is competing for.
| Scenario | Model tokens | Orchestration tokens | Tool calls | Total $/month | $ per task | vs (a) |
|---|---|---|---|---|---|---|
| (a) frontier on every task | $236.00 | $0.00 | $140.00 | $376.00 | $0.0376 | baseline |
| (b) cheap model on every task | $120.60 | $0.00 | $140.00 | $260.60 | $0.0261 | −$115.40 |
| (c1) Fugu Max orchestrating the cheap model | $166.85 | $95.00 | $142.45 | $404.30 | $0.0404 | +$28.30 |
| (c2) same routing, vendor's single-rate mechanic | $191.29 | $95.00 | $142.45 | $428.74 | $0.0429 | +$52.74 |
| (c0) reference: Fugu Max as a plain model, no orchestration tokens | $188.00 | $0.00 | $140.00 | $328.00 | $0.0328 | −$48.00 |
(c1) and (c2) differ on one published mechanic only. (c1) meters the routed-down traffic at the cheap model's own rate - a two-meter reading. (c2) applies the vendor's stated rule that model fees are never stacked, so routed traffic is still billed at the top-tier rate and routing down produces no differential on task tokens at all. (c2) is the upper bound on what a customer pays; (c1) is the reading used in the rest of this page. Both sit above (a). Scenario (b) is a floor, not a plan: it assumes every one of the 10,000 tasks is routable down, which the model explicitly rejects.
The routing premium, as its own line item
The premium is what (c) costs above the cheap-model floor (b). It has exactly three components, and only one of them is the router's own tokens.
| Component | Formula with the actual numbers | $ / month |
|---|---|---|
| 1. Orchestration tokens | 10,000 x (4,300/1e6 x $2.00 + 150/1e6 x $6.00) | $95.00 |
| 2. Traffic billed at frontier rates on its first pass (routed up, 36.5%) | 10,000 x 36.5% x $0.01154 | $42.12 |
| 3. Retried misroutes (1.8% of traffic, one full frontier re-run plus tools each) | 10,000 x 1.8% x $0.03760 | $6.58 |
| Routing premium vs (b) | $143.70 |
| Line item inside (c1) | Tasks | $ / month | $ / task |
|---|---|---|---|
| Cheap-leg task tokens (routed down, correctly) | 6,175 | $74.47 | $0.0074 |
| Cheap-leg task tokens (routed down, wrongly - retry follows) | 175 | $2.11 | $0.0002 |
| Frontier-leg task tokens (routed up) | 3,650 | $86.14 | $0.0086 |
| Retry pass, frontier model (model tokens only) | 175 | $4.13 | $0.0004 |
| Orchestration tokens (billed at Fugu Max rates) | 10,000 | $95.00 | $0.0095 |
| Tool calls, base workload | 10,000 | $140.00 | $0.0140 |
| Tool calls, retry passes | 175 | $2.45 | $0.0002 |
| Total (c1) | 10,000 | $404.30 | $0.0404 |
The orchestration row is 23.5% of the (c1) bill, and it buys no tokens the task itself needed. The single-line version: the rate-card advantage Fugu Max holds over Sonnet 5 on this workload is worth exactly $48.00 per month (10,000 x ($0.02360 - $0.01880)), and the mid-profile orchestration layer costs $95.00. Any router overhead above $48.00 a month makes the Fugu Max rate card a net loss against the model it is supposed to undercut.
3. Break-even: how much traffic has to route down
Let N be tasks per month, delta the per-task saving from routing a task down ($0.01154), O the orchestration tokens in $/month and R the retry cost in $/month. Orchestration pays for itself only when p x N x delta > O + R, so:
p* = (O + R) / (N x delta) = ($95.00 + $6.58) / (10,000 x $0.01154) = 88.02%
Without retries the bar is 82.32%. The share of this workload that genuinely belongs on the cheap model is 65.0% (the other 35% needs the frontier model). 88.02% > 65.0%, so on this workload orchestration loses. Stated a second way, as token headroom: the router may spend at most $0.01154 per task on its own tokens - about 5,770 Fugu Max input tokens per task at $2.00/1M - before routing destroys the saving it is chasing. The mid profile spends 4,300, i.e. 0.7x the headroom.
The deciding term is the router's weight, not its accuracy. No vendor publishes orchestration token counts, so the model carries three profiles:
| Router profile | Orchestration tokens in / out per task | O $/month | (c1) $/month | vs (a) | p* |
|---|---|---|---|---|---|
| low - one classification call on a compressed 1,000-token routing view | 1,300 / 120 | $33.20 | $342.50 | −$33.50 | 28.77% |
| mid - classification call on the full 4,000-token prompt plus routing system prompt | 4,300 / 150 | $95.00 | $404.30 | +$28.30 | 82.32% |
| high - classify plus verify/synthesize | 9,650 / 350 | $214.00 | $523.30 | +$147.30 | 185.44% |
Only the light profile beats the frontier baseline. Accuracy moves the bill by $49.87 between 70% ($445.86) and 100% ($395.99) - $420.92 at 85% and $404.30 at 95% - and every accuracy row, including a flawless router, stays above (a) $376.00. That is the opposite of how routing products are usually sold: the router's token spend decides the outcome, and the vendor publishes no figure for it, so a buyer cannot tell from the rate card which column they are standing in.
Sensitivity in the other direction, for completeness: against Claude Opus 5 ($5.00/$25.00) the same router needs only 20.24% of traffic routed down and saves $190.29 a month; against Kimi K3 at Moonshot's list rate ($3.00/$15.00) it needs 40.70%. Against Kimi K3 on OpenRouter's effective rate ($1.7955/$9.006) p* is 103.70% - arithmetically impossible, because the two cards are too close for a router to take a cut. Orchestration is worth most against the worst-priced model on the list.
4. Orchestration arbitrage: the definition
Orchestration arbitrage - the margin an orchestrator can capture by charging for the routing decision rather than for the model it routes to, once routing itself becomes a metered API SKU. Forkast named the term on 2026-09-11 in "The Orchestration Arbitrage: How Sakana's Fugu Max Rewrites the Pricing War" (analysis by Lena Park), framing the launch as value migrating "away from the model providers and toward the orchestrators" and arguing that "value is increasingly captured by those who control the traffic". It is commentary, not a measurement: the arbitrage is real only on traffic where the router's own tokens cost less than the rate-card gap they route to capture - $95.00 of orchestration tokens against a $48.00 gap on the workload worked out above.
Quoted fragments are from Forkast's analysis piece, retrieved 2026-09-11; Forkast's own masthead describes its output as "Reported by minds", so it is cited here as commentary. The $95.00 and $48.00 figures are this page's arithmetic on published rate cards, not Forkast's numbers.
A related term worth keeping separate: cost per completed task is not cost per token. OrcaRouter's working conclusion is that "orchestration saves money when it prevents retries, not when it adds parallelism for its own sake" - which is exactly the condition the (c1) line items above test, and the reason the retry line ($6.58) and the misroute line ($42.12) are broken out rather than folded into the token rate.
5. Frequently asked questions
Sakana Fugu Max pricing
Fugu Max is $2.00 per 1M input tokens, $6.00 per 1M output tokens and $0.25 per 1M cached input, launched September 11, 2026. Sakana's own console rate card and OpenRouter's model API both list that rate card. The 1,000,000-token context window and 128,000-token output ceiling are OpenRouter's figures only - Sakana publishes no context window for Fugu Max, so do not attribute those two numbers to the vendor. The sibling model launched the same day, Fugu Ultra v2, is $5.00/$30.00/$0.50, rising to $10.00/$45.00/$1.00 above a 272K-token context, and web_search or web_fetch calls are $0.007 each. The part of the pricing that decides the bill is not the token rate: Sakana bills orchestration tokens at standard input and output rates and counts them in the final price.
what is an orchestration model
An orchestration model takes one request and decides which model in a pool should answer it, instead of serving the request itself once. Sakana's Fugu Max is the first instance sold as a standard API-compatible endpoint rather than as a framework you host: the buyer sends a normal chat completion and the product chooses between the models in its pool, describing the policy as routing each task to "the leanest model capable of solving them". For cost purposes the defining property is that the routing step is itself billed - it emits orchestration_input_tokens and orchestration_output_tokens, and Sakana's rate card states those represent real token usage that will be counted in the final price at the same rates as standard input and output tokens. That is what turns a two-layer cost model (model tokens plus tool calls) into a three-layer one (model, tools, orchestration).
is orchestration cheaper than a single model
Not automatically, and on the fixed workload worked on this page it is more expensive: Fugu Max orchestrating a cheap model costs $404.30 a month against $376.00 for calling one frontier model on every task. The reason is that the orchestration layer is metered on the same tokens it re-routes - $95.00 a month at a mid-weight router profile - while the rate-card advantage it is routing to capture is only $48.00 a month. Whether orchestration is cheaper is therefore an arithmetic question with three inputs: how much of your traffic genuinely belongs on a cheaper model (routable share), how many tokens your router spends deciding, and which model you are routing away from. Break-even is p* = (O + R) / (N x delta): 82.32% of traffic must route down at the mid profile, 88.02% once retries are counted, against the 65.0% this workload actually offers. On a light router profile the same workload does win ($342.50 against $376.00), and against an expensive baseline orchestration wins easily - it needs only 20.24% of traffic routed down against Claude Opus 5, and 40.70% against Kimi K3 at list. No vendor publishes routing accuracy, router token counts or cache-hit rates, so all three are modelled ranges here, not vendor figures.
Fugu Max vs Kimi K3 cost
It depends which Kimi K3 price you use, because Kimi K3 carries two published ones. Against Moonshot's list rate of $3.00 input and $15.00 output per 1M, Fugu Max at $6.00 output is 60.0% cheaper on output and 33.3% cheaper on input; against OpenRouter's listed/effective Kimi K3 rate of $1.7955 input and $9.006 output the output saving falls to 33.4% and the input side reverses - Fugu Max at $2.00 input is 11.4% more expensive. The 40-60% band Sakana leads with is the vendor's own sentence on its release page and reproduces exactly against Sonnet 5 (40.0%) and Kimi K3 at list (60.0%) on output only; OrcaRouter, a competing gateway that sells Kimi K3 at 0% markup, reproduces the 60% figure against the list rate while disputing the framing. On the input side the claim does not hold as a range at all: 0% against Sonnet 5 and GPT 5.6 Terra, 33.3% against Kimi K3 at list, -11.4% against Kimi K3 on OpenRouter. State the baseline and the rate, or the comparison is not checkable.
multi-agent orchestration cost 2026
This query returns two different intents and they should not be blended. Most current results price multi-agent orchestration as a professional-services build - budget bands in the $30,000-$180,000 range - which is a project cost, not a token cost. The token-economics answer is different and is what this page prices: on a fixed workload of 10,000 tasks a month (4,000 input and 1,200 output tokens per task, two tool calls each, 5,800 billed input tokens per task), a single frontier model at $2.00/$10.00 per 1M costs $376.00 a month, a cheap model at $1.26/$3.96 per 1M costs $260.60, and Fugu Max orchestrating the cheap model costs $404.30 with the orchestration layer broken out as a $95.00 monthly line item. Tool calls are held identical at $140.00 a month in all three scenarios, so the comparison isolates the routing decision. The two numbers a services quote cannot tell you are the routable share of your traffic and your router's own token spend; both decide the answer.
6. What this page does not claim
- No independent evaluation of Fugu Max exists. No Artificial Analysis page for any Fugu model, per OrcaRouter (2026-09-11). Sakana's six "best overall" benchmark wins are unquantified rank statements - no values, no margins - and are not reproduced here as scores.
- No published latency or throughput for Fugu Max, so wall-clock cost cannot be modelled from public data.
- The cache-hit rate is undisclosed and OpenRouter reports
supports_implicit_caching: falsefor the endpoint, so no caching credit is modelled anywhere on this page. That is conservative - a real cache hit rate would lower (c1) - but there is no published basis for a number. - Router overhead and routing accuracy are assumptions (A9-A11 in the model), not vendor figures. Every vendor leaves both unpublished, which is why they are shown as profiles and ranges rather than as single answers.
- The 40-60% saving is a vendor claim, not an independent finding, and it holds only on the output axis and only against named baselines. See the FAQ above for the four rates it does and does not reproduce against.
- No redirect is needed for
/sakana-fugu-max-pricing/: that path was never published on this site and returns 404.
Price your own traffic against all three layers
Open the AI Agent API Cost CalculatorThe calculator carries the model rows used here - Fugu Max, Claude Sonnet 5, GLM-5.3, Kimi K3 - alongside the models you already run in production.
Sources
- Sakana AI console rate card - Fugu Max and Fugu Ultra v2 rates, cached input, the $0.007-per-call web functions, the 272K tier and the orchestration-token billing paragraph: console.sakana.ai/pricing (retrieved 2026-09-11)
- Sakana AI release - launch date, public model names, the vendor's 40-60% sentence: sakana.ai/fugu-max-release/ (retrieved 2026-09-11)
- OpenRouter models API - Fugu Max and Fugu Ultra v2 listings, the 1,000,000-token context and 128,000-token output ceiling, provider model ids, and the frontier baseline rates (Claude Sonnet 5, GPT 5.6 Terra, Claude Opus 5): openrouter.ai/api/v1/models (retrieved 2026-09-11)
- OpenRouter model page and endpoints API - Kimi K3 listed/effective rates ($1.7955 / $9.006) and the
supports_implicit_caching: falseflag: openrouter.ai/moonshotai/kimi-k3 (retrieved 2026-09-11) - OrcaRouter - Kimi K3 list rate ($3.00/$15.00), the 33%/60% decomposition and the competing-gateway caveat: orcarouter.ai/blog/fugu-max-vs-kimi-k3 (retrieved 2026-09-11)
- OrcaRouter - GLM-5.3 rate card ($1.26/$3.96) and the "saves money when it prevents retries" conclusion: orcarouter.ai/blog/fugu-max-vs-glm-5-3 (retrieved 2026-09-11)
- Forkast - "The Orchestration Arbitrage: How Sakana's Fugu Max Rewrites the Pricing War", analysis by Lena Park, published 2026-09-11 2:45 PM UTC (quoted in section 4): forkast.news (retrieved 2026-09-11)
- Third-party serialisation used for the two Kimi K3 prices and the Fugu Max capability gap: orcarouter.ai/models/kimi/kimi-k3 (retrieved 2026-09-11)
Method note: every rate on this page is a published rate with a source and a 2026-09-11 retrieval date, taken from the verified fact sheet compiled for this piece. Every assumption in the worked comparison (task volume, token counts, routable share, routing accuracy, router overhead profile) is modelled here and labelled as such - none of them is attributed to a vendor, and every vendor in this market leaves routing accuracy and router token spend unpublished. The arithmetic was generated from a single source-of-truth model and independently recomputed cell by cell (78 checks, 0 failures) before publication; the comparison uses the (c1) two-meter reading, with (c2) shown as the vendor's single-rate upper bound. Re-verify rates before quoting them: this is launch-day pricing from a vendor that has published no independent evaluation of the model.