Sakana Fugu Pricing: Plans, API Rates, and Costs

Sakana Fugu's pricing is more interesting than most AI model pricing because the model itself does not behave like other models. When you send one request, Fugu might call three different underlying AI models behind the scenes, run verification rounds, synthesize the outputs, and return one answer. The bill needs to account for all of that.

Sakana's approach is to keep the surface pricing simple: subscription tiers from $20 to $200 a month, and pay-as-you-go API rates that match standard frontier model pricing. The complexity hides in how the orchestration tokens are counted and how Fugu's dynamic routing affects your actual per-call cost.

This guide breaks down every pricing dimension: the subscription tiers, the API rates for both Fugu variants, the hidden cost in orchestration tokens, and a head-to-head comparison against Claude Fable 5, Opus 4.8, and GPT-5.5.

Pricing at a Glance

Sakana Fugu offers two billing models. Both include access to Fugu and Fugu Ultra.

Subscription plans:

Pay-as-you-go API pricing (Fugu Ultra):

Pay-as-you-go API pricing (Fugu standard): Charged at the rate of whichever top-tier underlying model is active for that request. Sakana does not stack fees when multiple agents are involved.

There is a launch offer running through July 2026: subscribe before month-end at any tier and get a second month free.

How Each Pricing Tier Actually Maps to Usage

The subscription tiers are not described with precise message counts because Fugu's token consumption varies based on which underlying models get activated and how much orchestration work each query requires. Sakana's tiers are best understood as relative multiples of Standard.

Standard ($20/month): A few API calls per day. Side projects. Learning the platform. Testing whether Fugu fits your workload before committing more. If you are running fewer than ten complex queries per week, Standard is enough.

Pro ($100/month): Regular daily use. A developer who runs Fugu inside their coding workflow several times an hour. A researcher running 5 to 10 deep queries per day. The 10x multiplier over Standard gives meaningful headroom for sustained daily work without constantly watching the meter.

Max ($200/month): Heavy, sustained, often parallel use. A team or individual running long agentic workflows. Batch document processing. Multi-hour Fugu Ultra sessions on hard problems. The 30x multiplier over Standard is designed for workloads where capacity, not cost, is the binding constraint.

The honest read: most individual developers fit on Pro. Most teams running production workloads outgrow Max within a quarter and move to pay-as-you-go.

The Hidden Cost: Orchestration Tokens

This is the most important nuance in Sakana Fugu's pricing, and the one most articles gloss over.

When Fugu processes a query, three categories of tokens get consumed:

1. User-visible input tokens. What you sent to the API.
2. User-visible output tokens. What gets returned to you in the response.
3. Orchestration tokens. Everything in between. Tokens consumed when Fugu delegates subtasks, verifies intermediate results, runs synthesis logic, or calls itself recursively.

Sakana's API response separates these out in token_details fields, but all three categories count toward your final bill at standard rates. The orchestration tokens are not absorbed by Sakana. They are real token usage, and you pay for them.

What this means in practice: a single user-facing request to Fugu Ultra can consume significantly more tokens than its visible output suggests. A query that returns a 500-token answer might actually consume 5,000 to 15,000 tokens once orchestration is included, depending on how much verification and re-delegation Fugu did internally.

This is not hidden in a bad way. Sakana is transparent about it. But it changes how you should budget. If you are coming from a single-model API like GPT-5.5 or Claude Opus 4.8 and assume a similar token-per-query profile, you will get billing surprises.

The practical implication: log token consumption per request from day one. Sakana's per-request cost reporting makes this easy. Build your cost model on observed data, not on rate cards.

Sakana Fugu vs Other Frontier Models on Price

How does Fugu Ultra's $5/$30 pricing compare to the alternatives you might be using instead?

On sticker price, Fugu Ultra is identical to GPT-5.5 on output and matches Opus 4.8 on input. It is exactly half the price of Claude Fable 5.

But sticker price is misleading for orchestration models. Because Fugu Ultra consumes orchestration tokens that single models do not, the effective cost per task is typically higher than the per-token rate suggests. A query that costs $0.10 on GPT-5.5 might cost $0.30 to $0.60 on Fugu Ultra for the same user-visible output, because Fugu is calling other models, verifying, and synthesizing in the background.

The flip side: Fugu Ultra's verification rounds catch errors that single models miss, so the quality lift can justify the cost on hard tasks. The arithmetic only works in Fugu's favor when verification matters.

How to Reduce Your Sakana Fugu Costs

Three levers actually move the needle on cost.

1. Prompt Caching (Up to 90% Off Cached Reads)

Cached input on Fugu Ultra costs $0.50 per million tokens instead of $5. That is a 90% discount on the input side for repeated context.

For agentic workflows where the same system prompt and reference documents get sent across many turns, prompt caching pays for itself within a few calls. Sakana's OpenAI-compatible API supports caching out of the box, the same way you would use it on Claude or OpenAI.

The catch: caching only applies to input tokens. Output tokens at $30/1M get no discount. For output-heavy workloads (long-form generation, detailed analysis), caching is less of a lever than it looks.

2. Default to Fugu, Escalate to Fugu Ultra

The single biggest cost reduction is routing. Most queries do not need Ultra's verification depth. Fugu, on pay-as-you-go pricing that matches the underlying model's rate, is often dramatically cheaper than Fugu Ultra for the same answer quality on routine tasks.

A working pattern:

• Default every request to Fugu
• Detect when Fugu's output quality is insufficient (low confidence, verification failure, downstream errors)
• Re-run failed cases on Fugu Ultra
• Only send tasks you know in advance are hard directly to Ultra

This blended approach typically lands somewhere between 30 and 60% of Fugu Ultra's straight-through cost while preserving quality on hard tasks.

3. Subscription for Predictable Workloads, Pay-As-You-Go for Bursty Ones

If your usage is steady and predictable, the subscription tiers are usually cheaper than pay-as-you-go. The Pro tier at $100/month effectively gives you 10x the Standard quota, which is more than most individual developers consume.

If your usage is spiky (heavy on some days, light on others) or scales unpredictably, pay-as-you-go is more efficient. You only pay for what you actually use, and the API surface is the same.

Mix the two if it makes sense. A team can put steady-state internal usage on a Max subscription and route production-scale workloads through pay-as-you-go for elastic capacity.

What You Actually Need to Budget For

If you are evaluating Fugu and trying to model your costs, here is a realistic budgeting framework.

For individual developers:

• Pro subscription at $100/month covers most regular use
• Add prompt caching for any repeated-context workflow
• Expect to occasionally exceed quota on heavy days; have a pay-as-you-go fallback configured

For small engineering teams (3 to 10 users):

• Multiple Pro subscriptions or a Max subscription per heavy user
• Pay-as-you-go for production workloads with prompt caching enabled
• Realistic monthly spend: $500 to $2,500 depending on workload intensity

For larger teams or production workloads:

• Skip subscriptions, go pure pay-as-you-go
• Mandate prompt caching for all repeated-context calls
• Route Fugu vs Fugu Ultra by task complexity
• Expect orchestration tokens to add 30 to 100% to your visible-output token bill
• Realistic monthly spend: $5,000 to $50,000+ depending on volume

The wide ranges reflect how much variance there is in real workloads. The best way to get accurate numbers for your situation is to run a two-week pilot on actual production traffic and measure.

Why Per-Request Cost Reporting Matters

One feature of Sakana's API that does not get enough attention: every Fugu response includes detailed token usage and cost data per request.

This is a meaningful operational advantage. Most AI APIs give you cumulative usage reports that you reconcile at the end of the billing cycle. By then, runaway costs from a misconfigured prompt or a verbose user have already happened.

Fugu's per-request reporting lets you:

• Build real-time cost dashboards instead of waiting for monthly bills
• Set per-user or per-feature spending caps in your application
• Identify expensive query patterns and optimize them before they scale
• Forecast monthly spend based on observed token consumption, not estimates

For any team running Fugu in production, building observability around the per-request data is the highest-leverage thing you can do in week one. Treat it as table stakes, not a nice-to-have.

Building Production Apps on Top of Sakana Fugu

Fugu's pricing makes sense for what it is: a smart orchestration layer that delivers frontier-level reasoning with vendor diversity built in. But if you are building a real product on top of Fugu, the orchestration model is only one line item in your total cost of getting to production.

The harder work, and where most AI-powered product launches stall, is everything around the model: a UI users can actually use, a database, authentication, payments, hosting, observability, deployment. Building that stack from scratch is the part that takes months and burns down engineering budgets.

This is why teams shipping production AI products in 2026 are turning to platforms like Emergent, which generates the entire application stack from natural language. You describe what you want to build, and Emergent ships a real, production-ready app with frontend, backend, database, auth, and deployment all handled. Not a prototype. A working full-stack product.

What makes Emergent genuinely different from every other no-code or AI builder in the market is the depth of what it actually generates. The platform reasons through how the full system should work before writing it, then produces real code you fully own. The output syncs directly to your GitHub repository, so there is no platform lock-in. You can export it, deploy it elsewhere, or extend it with your engineering team.

The integration story is just as important. Emergent lets you connect any tool with APIs, payment gateways, CRMs, and third-party tools (including AI model APIs like Sakana Fugu) by describing what you want to integrate. No glue code, no SDK wrangling. When something breaks in production, Emergent's multi-agent framework analyzes backend logs and resolves issues without human intervention.

For enterprise teams, Emergent is SOC 2 Type I certified with SSO/SAML authentication, role-based access control, and audit logging built into the platform. Combined with the speed of going from idea to live product in hours, this is what makes it a different category from both traditional no-code tools and AI coding assistants.

If you are calculating the total cost of shipping an AI product, the model bill is one variable. The platform that turns the model into a working product for real users is the other. Get both right and the math changes meaningfully.

The Bottom Line

Sakana Fugu's pricing is competitive on sticker rate and transparent on mechanics. The subscriptions work for predictable workloads. The pay-as-you-go pricing matches standard frontier model rates. The cached input discount and dynamic Fugu routing give you real cost levers.

The honest caveat: orchestration tokens make Fugu's effective per-query cost higher than the rate card suggests, especially on Fugu Ultra. Budget with observed data, not estimates. Use the per-request cost reporting from day one. Default to Fugu and escalate to Ultra only when verification is the value.

Done right, Fugu's pricing is competitive with running multiple model APIs and building your own routing layer. Done casually, it can quietly become more expensive than you expected. The difference is whether you treat orchestration token consumption as a thing to manage or a thing you discover at month-end.