Laguna S 2.1 costs $0.10 per million tokens: where it replaces Claude and GPT

Summary. Poolside released Laguna S 2.1 on 21 July 2026: a 118B-parameter Mixture-of-Experts model with 8B parameters active per token, a 1,048,576-token context window, and open weights under the OpenMDW-1.1 licence. It lists on OpenRouter at $0.10 per million input tokens and $0.20 per million output tokens. Claude Fable 5, which sits at the top of the same benchmark table, lists at $10 and $50. That is 100 times the input price and 250 times the output price for a Terminal-Bench 2.1 score of 88 per cent against Laguna's 70.2 per cent, and 80.3 per cent against 59.4 per cent on SWE-Bench Pro. On a 2 billion input plus 400 million output token month, the two bills are $280 and $40,000. Neither number is the answer on its own. The answer is which tasks you send where, and this piece works through the arithmetic with Poolside's own published benchmark table and current list prices as of 4 August 2026.

What Poolside actually shipped

The model card is unusually specific, which makes this an easier evaluation than most releases.

Laguna S 2.1 is 118B total parameters with roughly 8B activated per token across 256 routed experts (top-10) plus one shared expert. It runs 48 layers in a 1:3 global-to-sliding-window ratio: 12 global attention layers, 36 sliding-window layers with a 512-token window. Attention is grouped-query with 8 KV heads and head dimension 128. The context window is 1,048,576 tokens, the vocabulary is 100,352 tokens, and reasoning is native with interleaved thinking between tool calls, controlled per request via enable_thinking.

It sits in the middle of the family, between Laguna XS 2.1 at 33B-A3B and Laguna M.1 at 225B-A23B. Weights ship in BF16 with FP8, NVFP4, INT4 and GGUF variants, plus a separately trained DFlash draft model for speculative decoding. The licence is OpenMDW-1.1, which permits commercial use and modification.

Serving is unfussy. vLLM, SGLang, TRT-LLM and llama.cpp all work, though the flag names differ between engines in ways that will cost someone an afternoon:

# vLLM
vllm serve \
    --model poolside/Laguna-S-2.1 \
    --tensor-parallel-size 4 \
    --tool-call-parser poolside_v1 \
    --reasoning-parser poolside_v1 \
    --enable-auto-tool-choice \
    --served-model-name laguna \
    --default-chat-template-kwargs '{"enable_thinking": true}'

# TRT-LLM: note --tool_parser, and the reasoning parser is "laguna", not "poolside_v1"
trtllm-serve poolside/Laguna-S-2.1 --trust-remote-code \
    --tool_parser poolside_v1 --reasoning_parser laguna

Hosted access is on OpenRouter, where a single provider serves it directly, and on Vercel's AI Gateway.

The benchmark table, unedited

Poolside published its comparison rather than a headline. This is the table from the model card, benchmarks as of 21 July 2026, with an asterisk marking third-party reported scores (Artificial Analysis for Terminal-Bench 2.1 and DeepSWE, Scale AI's leaderboard for SWE Atlas, and the Toolathlon leaderboard).

Model	Size	Terminal-Bench 2.1	SWE-bench Multilingual	SWE-Bench Pro	DeepSWE
Laguna S 2.1	118B-A8B	70.2%	78.5%	59.4%	40.4%
Tencent Hy3	295B-A21B	71.7%	75.8%	57.9%	not reported
Inkling	975B-A41B	63.8%	not reported	54.3%	not reported
Nemotron 3 Ultra	550B-A55B	56.4%	67.7%	not reported	not reported
DeepSeek-V4-Pro Max	1.6T-A49B	64.0%*	76.2%	55.4%	9.0%*
Kimi K3	2800B-A50B	88.3%	not reported	not reported	69%
Qwen 3.7 Max	not stated	74.5%*	78.3%	60.6%	not reported
Muse Spark 1.1	not stated	80%	not reported	61.5%	53.3%
Claude Fable 5	not stated	88%	not reported	80.3%	70%

Source: Poolside model card for Laguna S 2.1, Hugging Face, 21 July 2026.

Two things stand out. Laguna S 2.1 leads every open disclosed-size model on SWE-bench Multilingual at 78.5 per cent, including DeepSeek-V4-Pro Max at more than thirteen times its total parameter count. And on DeepSWE, the hardest long-horizon benchmark in the set, it scores 40.4 per cent against Claude Fable 5's 70 per cent. The gap is not uniform. It widens as tasks get longer and harder, which is exactly the shape that should drive a routing rule rather than a replacement decision.

What the two bills actually look like

Prices below are list prices on OpenRouter as of 4 August 2026, and Anthropic's published API rate for Claude Fable 5. The workload is a deliberately ordinary coding-agent month: 2 billion input tokens and 400 million output tokens, which is roughly what a 30-engineer team running agentic reviews, test generation and refactors gets through without trying.

Model	Input per 1M	Output per 1M	2B in + 400M out	Multiple of Laguna
Laguna S 2.1	$0.10	$0.20	$280	1x
Muse Spark 1.1	$1.25	$4.25	$4,200	15x
Kimi K3	$2.90	$14.00	$11,400	41x
Claude Fable 5	$10.00	$50.00	$40,000	143x

Sources: OpenRouter model pages for Laguna S 2.1, Muse Spark 1.1 and Kimi K3; Claude Platform pricing for Fable 5. List prices before prompt caching, which OpenRouter reports can cut effective cost 60-80 per cent on repeated context.

The delta between the top and bottom rows is $39,720 a month, or roughly $476,000 a year. That is the number that makes the conversation worth having, and also the number that makes people jump to the wrong conclusion. Fable 5 resolves 80.3 per cent of SWE-Bench Pro against Laguna's 59.4 per cent. If a failed agent task costs an engineer 40 minutes of cleanup, the 21-point gap eats the saving quickly on the tasks where it applies. The trick is that it does not apply to most tasks.

Where a cheap model genuinely wins

The tasks where Laguna S 2.1 is the right call share one property: the cost of a wrong answer is low and immediately visible.

High-volume, verifiable work. Test generation, docstring and comment passes, type annotation, lint-driven refactors, dependency bumps with a green build as the oracle. The build tells you if the model was wrong, in seconds, for free.

Retrieval and codebase question answering. Laguna scores 46.2 per cent on SWE Atlas, the codebase QnA benchmark, and it has a million-token context window. Answering "where is this handled" over a large repository is not the same problem as fixing a subtle concurrency bug.

Wide fan-out patterns. If your harness runs eight candidate patches in parallel and picks the one that passes CI, per-token price dominates and per-task accuracy matters less. At 143 times the price you cannot afford to fan out with Fable 5; at $0.10 you can afford to fan out wide and let the test suite adjudicate.

First-pass triage in a two-tier route. Send everything to Laguna, let it attempt the change, and escalate to a frontier model only when tests fail or the diff exceeds a size threshold. Our note on request-level model routing to cut cost covers the plumbing; the economics here are unusually favourable because the cheap tier is 143 times cheaper rather than the usual 3 or 4.

Data residency and air-gapped work. Open weights under a commercial-use licence means the model can run inside your own boundary, which no amount of API discounting gets you.

Where it does not

Long-horizon agentic work with a compounding error rate. DeepSWE at 40.4 per cent against 70 per cent is the honest signal here. A 20-step task where each step has a meaningfully higher failure probability does not finish more cheaply; it finishes less often.

Anything where the reviewer is expensive. If a senior engineer reviews every agent diff, their time is the dominant cost and the model price is a rounding error. Optimising the rounding error is a category mistake.

Novel or ambiguous specification work. Benchmarks measure resolution of well-specified issues. They do not measure the ability to notice that the ticket is wrong.

Third-party reported scores you cannot reproduce. Four of the comparison scores in Poolside's own table are marked as reported by Artificial Analysis, Scale AI or Toolathlon rather than run in-house. That is honest labelling, and it is also a reason to run your own eval on your own repository before rewiring a fleet. We have written before on evaluating agent tool-use reliability rather than trusting a leaderboard.

Self-hosting: the arithmetic most people get backwards

Open weights invite the reflex that self-hosting must be cheaper. At these prices it usually is not.

The model card puts the BF16 checkpoint at roughly 236 GB of weights and recommends tensor parallelism of 4. FP8 halves that to roughly 118 GB, INT4 roughly quarters it, before any KV cache. And the KV cache is not a footnote when the context window is 1,048,576 tokens: long-context agentic sessions are exactly the workload that inflates it.

Take a modest self-hosted deployment: three 48 GB GDDR6 cards to hold an FP8 checkpoint with room for cache. E2E Networks lists the NVIDIA L40S in India at ₹102 per hour, so three cards running continuously for a 730-hour month is about ₹223,000, and that is before storage, egress, the engineer who owns the deployment, and the utilisation problem. A coding-agent workload is bursty; you pay for the idle hours.

The hosted API for the same model, at the 2.4 billion token month above, costs $280. Self-hosting Laguna S 2.1 to save money only starts to make sense at volumes far beyond that, or when you are already paying for the GPUs and they have idle capacity. The reasons to self-host this model are data residency, latency control, and not having a single hosted provider in your critical path. Cost is not one of them at typical volumes. Our break-even analysis for self-hosting Kimi K3 reaches the same shape of conclusion from a different starting price, and India GPU cloud rental pricing has the underlying rate cards.

The one exception worth noting: DFlash speculative decoding ships as a trained draft model, and on a saturated self-hosted deployment that materially improves tokens per second per GPU. If you are already committed to self-hosting, use it:

# vLLM with the DFlash draft model
--speculative-config '{"model":"poolside/Laguna-S-2.1-DFlash","num_speculative_tokens":7,"method":"dflash"}'

A routing rule you can implement this week

Task class	Route to	Why	Escalation trigger
Test generation, lint fixes, dep bumps	Laguna S 2.1	Build is the oracle; volume dominates	Two consecutive CI failures
Codebase QnA and search	Laguna S 2.1	46.2% SWE Atlas, 1M context	Answer cites files that do not exist
Single-file bug fix with a failing test	Laguna S 2.1 first	78.5% SWE-bench Multilingual	Test still red after two attempts
Multi-file refactor across a service	Frontier model	59.4% vs 80.3% on SWE-Bench Pro	Route directly
Long-horizon agentic task, 15+ steps	Frontier model	40.4% vs 70% on DeepSWE	Route directly
Anything touching auth, payments or migrations	Frontier model plus human review	Cost of a wrong answer is not recoverable	Route directly

The escalation trigger column is the part teams skip. A router without an explicit failure signal is not a router, it is a coin flip with extra steps.

India-specific considerations

For Indian teams the arithmetic is sharper in one direction and softer in another.

Sharper, because engineering salaries make the reviewer-time argument land differently. If a frontier model's higher resolution rate saves review hours, the value of those hours is lower in India than in the US, which pushes the break-even further towards the cheap model. More of your task mix belongs on Laguna than a US-centric analysis would suggest.

Softer, because a $40,000 monthly model bill is a much larger share of an Indian product team's budget than of a US one, so the pressure to route aggressively is higher and the appetite for a two-tier setup is greater.

On data residency: an open-weight model under a commercial licence is one of the few ways to keep source code and prompts entirely inside your own infrastructure, which matters if you are handling client code under contractual restrictions or personal data under the Digital Personal Data Protection Act 2023. That is a residency argument, not a cost argument, and it should be made on its own terms. Our DPDP engineering playbook covers the wider obligations.

What we would do

Run a 200-task eval on your own repository before changing anything. Not a benchmark, your repository, with your test suite as the grader. Two weeks of real tickets is enough.

Wire the two-tier route with an explicit escalation signal, and log which tier resolved each task. After a month you will know your actual mix, and the mix is the only number that determines the saving.

Do not self-host to save money at these prices. Self-host if residency or provider risk requires it.

Re-run the eval when prices move. The gap between $0.10 and $10 is wide enough that a single price cut on either side changes nothing, but a capability release changes everything. Our pillar comparison of Gemini, GPT and Claude Fable 5 tracks the frontier tier, and coding-agent cost per task is the metric to hold steady while models churn underneath it.

FAQ

What is Laguna S 2.1?

Laguna S 2.1 is an open-weight coding model released by Poolside on 21 July 2026. It is a 118 billion parameter Mixture-of-Experts design that activates roughly 8 billion parameters per token, supports a 1,048,576-token context window, and ships under the OpenMDW-1.1 licence, which permits commercial use and modification.

How much does Laguna S 2.1 cost?

OpenRouter lists it at $0.10 per million input tokens and $0.20 per million output tokens, with a 1,048,576-token context window and a maximum output of 131,072 tokens. For comparison, Claude Fable 5 lists at $10 per million input tokens and $50 per million output tokens on Anthropic's published API pricing.

Is Laguna S 2.1 as good as Claude Fable 5?

No, and Poolside's own published table says so. Laguna scores 70.2 per cent on Terminal-Bench 2.1 against Fable 5's 88 per cent, and 59.4 per cent against 80.3 per cent on SWE-Bench Pro. The gap widens on longer tasks: 40.4 per cent against 70 per cent on DeepSWE. It is a routing decision, not a replacement.

What hardware do I need to self-host it?

The model card puts the BF16 checkpoint at roughly 236 GB of weights and shows tensor parallelism of 4 in its vLLM example. FP8, NVFP4, INT4 and GGUF quantised variants reduce that substantially, with FP8 landing near 118 GB before any KV cache. Long-context sessions inflate the cache considerably.

Which serving engines support it?

The model card documents vLLM, SGLang, TRT-LLM and llama.cpp, using the same laguna architecture as Laguna XS 2.1. Flag names differ between engines: TRT-LLM uses tool_parser and a reasoning parser named laguna, while vLLM uses tool-call-parser and reasoning-parser set to poolside_v1.

Does self-hosting save money against the hosted API?

Usually not at typical volumes. Three 48 GB cards at the ₹102 per hour that E2E Networks lists for an L40S run to roughly ₹223,000 for a 730-hour month, against $280 for the same 2.4 billion token workload through the hosted API. Self-host for residency, latency or provider risk instead.

What is DFlash and should I use it?

DFlash is a separately trained draft model published alongside Laguna S 2.1 for speculative decoding, which lowers serving latency. It is worth enabling on a self-hosted deployment where you control the serving stack and are paying for GPU hours regardless. On a hosted endpoint the provider decides, so it is not your lever.

How should I split traffic between the two models?

Send high-volume verifiable work with a cheap oracle to Laguna: test generation, lint fixes, dependency bumps, codebase question answering. Route multi-file refactors, long-horizon agentic tasks and anything touching auth, payments or migrations to a frontier model. Set an explicit escalation trigger such as two consecutive test failures.

How eCorpIT can help

eCorpIT is a CMMI Level 5 and ISO 27001:2022 certified technology organisation in Gurugram, and our senior engineering teams build and operate LLM routing, evaluation and serving infrastructure for product companies. We can run the eval on your own repository rather than a leaderboard, build the two-tier router with escalation signals and per-tier cost logging, and size a self-hosted deployment honestly, including telling you when the hosted API is the cheaper answer. Talk to us at /contact-us/ if you want that decision made with your own numbers.

References

1. poolside/Laguna-S-2.1 model card, Poolside on Hugging Face, 21 July 2026.
2. Laguna S 2.1 API pricing and providers, OpenRouter, accessed 4 August 2026.
3. poolside/Laguna-S-2.1-FP8, Poolside on Hugging Face, 2026.
4. poolside/Laguna-S-2.1-DFlash draft model, Poolside on Hugging Face, 2026.
5. Kimi K3 API pricing and benchmarks, OpenRouter, accessed 4 August 2026.
6. Muse Spark 1.1 API pricing and benchmarks, OpenRouter, accessed 4 August 2026.
7. Claude Platform pricing, Anthropic, accessed 4 August 2026.
8. Introducing Claude Fable 5 and Claude Mythos 5, Anthropic, 2026.
9. Poolside drops Laguna S 2.1, an open-weight coding model that beats rivals 10x its size, VentureBeat, July 2026.
10. Poolside releases Laguna S 2.1, an open-weight agentic coding model, MarkTechPost, 21 July 2026.
11. Poolside model release notes, Poolside documentation, accessed 4 August 2026.
12. Laguna S 2.1 on Vercel AI Gateway, Vercel, accessed 4 August 2026.
13. OpenMDW licence, Open Model Definition and Weights, accessed 4 August 2026.
14. Rent NVIDIA L40S GPU in India, E2E Networks, accessed 4 August 2026.
15. Qwen3.7 Max API pricing and benchmarks, OpenRouter, accessed 4 August 2026.

Last updated: 4 August 2026.