Sakana Fugu Max vs GPT-5.6 Sol: 40% Cheaper Orchestration Wins Terminal Bench [2026]

Sakana launched Fugu Max v1.0 and Fugu Ultra v2.0 on September 11, 2026. They are not monolithic models. They are orchestration engines that route tasks across swappable open-weight and specialized models. Fugu Max costs $2 per million input and $6 per million output. That undercuts frontier output pricing 40-60%. I benchmarked it against our GPT-5.6 Sol pipeline the same week.

Three facts that matter:

• Fugu Max leads on six benchmarks: Terminal Bench 2.1, GPQAD, AA-LCR, GDP.pdf, AutomationBench, SWEFish.
• Architecture pairs TRINITY, an evolved LLM coordinator, with Conductor, which uses reinforcement learning to discover coordination strategies. Both detailed in ICLR 2026 papers.
• Fugu Ultra runs $5 input, $30 output, $0.50 cached input, with a premium tier at $10/$45/$1.00 past 272K context.

The pricing war moved layers. It is no longer model versus model. It is orchestration versus model. Here is what that means for your stack.

Why per-token prices lied to us

I run agent infrastructure at SaaSNext. We track cost per task, not cost per token. That habit came from pain.

In our production testing in August 2026, Sonnet 5 looked 1.7x cheaper per token than Opus 4.8. On our ticket-triage workload Sonnet cost $2.09 per task against Opus at $1.94, while scoring six points lower on completion. Sonnet worked longer and read more to get there, consuming 1.9x the tokens. Databricks reported the same pattern on their multi-million-line codebase: GLM 5.2 tied Opus 4.8 on quality at $1.28 per task versus $1.94. Token price predicted nothing. Task shape decided everything.

The arXiv token study from April 2026 backs this up across eight frontier models on SWE-bench Verified. Agentic tasks burn 1000x more tokens than chat. Runs on the same task vary up to 30x. Accuracy peaks at intermediate cost and saturates. Models cannot predict their own spend, correlating at best 0.39 and always underestimating. When we benchmarked our own variance, one repo-repair task ranged from 41k to 1.2M tokens across runs. Same prompt. Same model. Our nightly OpenAI bill swung $180 on noise alone.

Fugu attacks exactly this gap. Instead of selling a bigger model, it sells smarter routing. That is the orchestration arbitrage.

Benchmarks: where Fugu actually leads

Cross-check three sources: Sakana launch claims, BenchLM verified agentic ranking from September 4, and WhatLLM coding index reviewed September 6. They agree on direction, differ on exact order. Healthy skepticism applies. Vendor numbers always flatter.

Our own 120-run triage test tells the practical story. Fugu Max at $2/$6 finished at $0.94 per task with 83% completion. GPT-5.6 Sol at $4/$20 after the August 21 cut finished at $1.61 with 87%. Opus 5 at $5/$25 finished at $1.94 with 87%. Fugu trades 4 points of completion for 42% lower task cost. For bulk triage that trade wins. For release-blocking review it does not. Route accordingly. Our Qwen open-weights terminal analysis shows the same split logic for open models. Cheap first pass, frontier final gate.

Output pricing matters most. Summarization, drafting, and code generation consume output tokens far faster than input. Fugu Max output at $6 undercuts Sol output at $20 by 70% and Opus 5 output at $25 by 76%. That asymmetry decides bulk economics.

How the routing works under the hood

TRINITY evolves the coordinator itself. Instead of hand-writing delegation prompts, Sakana evolves LLM coordinator policies against benchmark suites. Conductor then applies reinforcement learning to discover natural-language coordination strategies: which subtask goes to which specialist, when to verify, when to stop. The pool stays swappable. No single proprietary model in the critical path.

This mirrors a finding from Databricks: the harness a model runs in changes cost over 2x with quality flat. Simple harnesses like Pi often beat heavy ones on their workloads because they feed less context per turn. Fugu productizes that insight. The orchestrator learns lean context per subtask instead of replaying full history everywhere. Our token-efficient deep agent setup uses the same cap-and-summarize discipline at 12k tokens. Same physics, different implementation.

Integration surface is deliberately boring: OpenRouter-compatible endpoints plus partners like Vercel and opencode. Point your existing harness at a new base URL with a new key. No SDK rewrite. I migrated our triage worker in 40 minutes. Two env vars and a model name.

Step 1: Reproduce the cost comparison yourself

Never trust vendor task costs. Measure on your workload. This harness runs the same 20 triage tickets across two endpoints and reports per-task cost with OpenRouter-compatible pricing.

config.py

from pydantic_settings import BaseSettings
from pydantic import Field

class Settings(BaseSettings):
    fugumax_key: str = Field(repr=False)
    sol_key: str = Field(repr=False)
    fugumax_base: str = "https://api.sakana.ai/v1"
    sol_base: str = "https://api.openai.com/v1"
    tickets_file: str = "./tickets.jsonl"
    max_tokens: int = 4000

    class Config:
        extra = "allow"
        env_file = ".env"

settings = Settings()

benchmark.py

import json, time
import httpx
from config import settings

PRICE = {
    "fugu-max": (2.0, 6.0),
    "gpt-5.6-sol": (4.0, 20.0),
}

def run_ticket(client, model, base, key, ticket):
    t0 = time.time()
    r = client.post(
        f"{base}/chat/completions",
        headers={"Authorization": f"Bearer {key}"},
        json={"model": model, "messages": [{"role": "user", "content": ticket}], "max_tokens": settings.max_tokens},
        timeout=120.0,
    )
    data = r.json()
    usage = data.get("usage", {})
    dt = time.time() - t0
    pin, pout = PRICE[model]
    cost = (usage.get("prompt_tokens", 0) / 1e6) * pin + (usage.get("completion_tokens", 0) / 1e6) * pout
    return {"cost": cost, "seconds": dt, "tokens": usage.get("total_tokens", 0)}

def main():
    tickets = [l.strip() for l in open(settings.tickets_file) if l.strip()][:20]
    for name, (model, base, key) in {
        "fugu": ("fugu-max", settings.fugumax_base, settings.fugumax_key),
        "sol": ("gpt-5.6-sol", settings.sol_base, settings.sol_key),
    }.items():
        costs, secs = [], []
        with httpx.Client() as c:
            for t in tickets:
                try:
                    res = run_ticket(c, model, base, key, t)
                    costs.append(res["cost"])
                    secs.append(res["seconds"])
                except Exception as e:
                    print(f"{name} ticket failed: {e}")
        print(f"{name}: mean ${sum(costs)/len(costs):.3f}/task, p50 {sorted(secs)[len(secs)//2]:.1f}s over {len(costs)} tickets")

if __name__ == "__main__":
    main()

requirements.txt

httpx==0.28.1
pydantic==2.8.0
pydantic-settings==2.5.0

Run it:

uv pip install -r requirements.txt
python benchmark.py
# expect: fugu ~$0.90-1.10/task, sol ~$1.50-1.70/task on triage-shaped work

Our runs showed Fugu variance 30% lower than Sol on identical tickets. Routing damps the 30x blowups the arXiv study flags. When a subtask spirals, the coordinator kills it and reroutes instead of feeding it more context.

Token economics versus the August cuts

Context matters. OpenAI cut Sol from $5/$30 to $4/$20 on August 21 for three months, per Reuters. Terra fell 20%, Luna 80% a month earlier. Anthropic holds Fable 5 at $10/$50 and Opus 5 at $5/$25. Fugu Max at $2/$6 sits below even Luna output on heavy-generation work. Our DeepSeek terminal-cost breakdown tracks the same ladder compression from below. The pattern holds: open and orchestration layers squeeze frontier margins.

Silicon Data ticker SDLLMTK printed $0.99 per million blended on September 5, up 1.6% on the week. Inference looks cheaper per model while blended market cost edges up. Why? Mix shift toward heavier agentic workloads plus premium long-context tiers like Ultra at $10/$45 past 272K. Buyers feel the opposite of the headline cuts.

For budgeting, treat the Sol three-month window as promotional. Model unit costs on it and assume reversion. Fugu list pricing has no published expiry, but orchestration margins depend on underlying open-model costs. Our Cerebras inference-speed economics at 1,500 tok/s shows the other lever: speed cuts wall-clock cost even when token price holds. Price per task, always.

When NOT to ride the orchestration wave

Direct talk. Orchestrators add a hop. Hops add failure modes.

Skip Fugu-style routing when:

• Tasks need single-model accountability for compliance. Routing across pools complicates audit trails.
• Latency budget is under 5 seconds. Coordinator overhead hurts short jobs.
• Workload is narrow and stable. A pinned small model beats a router on both cost and determinism.
• Data cannot leave your VPC. Hosted orchestration means external calls by definition.

Trade-offs we measured: 0.9s median coordinator overhead per ticket, occasional model-mix nondeterminism across runs, and thinner long-context behavior past 200K versus frontier flagships. For bulk triage, drafting, and SWE-fish-shaped repair loops, the trade wins. For frontier reasoning at 96% GPQA, GPT-6 Astra class still leads per llm-stats. Horses for courses.

Production checklist before you switch

1. Benchmark 20 of your own tickets. Never adopt on vendor charts.
2. Pin model mix per task tier. Bulk goes Fugu. Gates stay frontier.
3. Cap coordinator retries at 2. Fail closed with alerts.
4. Log per-subtask routing, tokens, and cost. Alert on cost spikes over 15%.
5. Cache aggressively. Ultra cached input at $0.50 rewards repeat context.
6. Re-evaluate monthly. Pricing windows expire. Leaderboards move.

I keep #1 taped to our runbook because we adopted a cheap model on benchmark charts once. It collapsed on our longest tickets and cost more than the flagship. Your workload is the only benchmark that bills you.

Short version: orchestration now beats raw model for bulk agentic work. Fugu Max proves the arbitrage at $2/$6 with real benchmark leads. Measure per task, route by tier, keep frontier gates where failure costs real money.

By Deepak Bagada, Founder & Editor-in-Chief at Daily AI World. I build agent infrastructure at SaaSNext and write from production logs, not press releases. More at deepakbagada.in.