Poolside is selling a 118B coding model for 10 cents in and 20 cents out. It also published how many tokens a task burns, which is the number that decides your bill.

Two rate cards, and neither is on poolside's own site

Worth stating plainly up front: poolside does not publish a pricing page. Its models page says the model is free to use for a limited time and that licenses vary. The numbers everyone is quoting, including poolside's own launch post, come from the OpenRouter listing. So when we say "the price" below, we mean the price of the hosted OpenRouter endpoint, which is currently the only rate card that exists.

The free row is the one to read twice. OpenRouter's listing states that if you use Laguna S 2.1 for free, your inputs and outputs may be used to train and improve the models. That is a perfectly ordinary trade and poolside is being upfront about it, but it is a trade, and it is the wrong one for anything touching a private codebase. Throughput is capped too: 20 requests a minute, 50 a day if you have bought less than 10 credits in your account's lifetime, 1,000 a day above that. A free tier that allows 1,000 requests daily is a generous evaluation budget and not a production plan.

The 1M context window is real, and you probably do not have it

Coverage of this launch has split between "1M context" and "256K context" and both camps are right, which is why the disagreement has not resolved itself. The BF16 checkpoint supports 1,048,576 tokens. The quantized checkpoints are configured for 262,144, and the vLLM recipe poolside ships launches with a max model length of exactly that. The free endpoint is capped at 262,144 as well.

Practically: 1M if you pay for the hosted endpoint or run BF16 yourself on enough VRAM to hold it. 256K in every quantized deployment, which is to say in most self-hosted setups, since running BF16 is what makes self-hosting expensive in the first place. Anyone quoting 256K is quoting the config they can actually run. Architecture behind it is 48 layers, 12 of them global attention and 36 sliding-window with a 512-token window, and 256 routed experts selecting the top 10 plus one shared expert.

Pricing the task instead of the token

Here is where this launch is genuinely useful to anyone doing cost modelling. Poolside published its completion-token counts directly in the launch table: roughly 249,000 per trajectory on DeepSWE v1.1 in thinking mode, about 99,000 without it. It released the full trajectories alongside them, so the claim is checkable rather than asserted, and MarkTechPost was quick to flag how much of the model's story those two numbers carry. Vendors almost never give you this. Without it, a per-million rate card tells you nothing about what one agent run costs, and comparisons between a terse model and a verbose one are meaningless.

So take poolside's 249,000 output tokens as one unit of agentic coding work and price that unit across the field. This is the output side only, because poolside published completion tokens and not prompt tokens, and it deliberately holds the token count fixed rather than assuming each model is equally terse.

A thousand agent runs for fifty dollars against seven and a half thousand. The honest caveat is that frontier models are more token-efficient, so a real head to head would narrow the gap. It would not close it. Sol would have to finish the same work in under 1,700 output tokens to match Laguna at 249,000, and no coding agent does that. Run your own numbers on the cost calculator if your trajectories are shorter.

Thinking mode pays for itself, almost to the cent

Reasoning modes usually force a judgement call: you buy accuracy with tokens and have to decide whether the exchange rate is any good. On Laguna S 2.1 the exchange rate is almost exactly 1.00, which we did not expect. Thinking mode takes DeepSWE v1.1 from 16.5% to 40.4%, a 2.45x improvement, and it spends 2.52x the completion tokens to do it. Divide cost by score and the two modes land on top of each other.

A 2.7% premium per point of accuracy, for a mode that more than doubles how often the model finishes the job. Leave it on. The wider lesson is the one we keep coming back to: every headline benchmark you have seen for this model was produced in thinking mode, which spends two and a half times the tokens of the quiet mode. So if you sized your budget off a non-thinking trial run and then turned thinking on to chase the published scores, expect the bill to roughly two-and-a-half. It is still cheap. It is just not the number you first modelled.

About that 70.2%

Poolside reports 70.2% on Terminal-Bench 2.1, 78.5% on SWE-Bench Multilingual, 59.4% on SWE-Bench Pro Public, 46.2% on SWE Atlas and 49.7% on Toolathlon Verified. Every one of those is self-reported. We checked the official tbench.ai Terminal-Bench 2.1 leaderboard today: 17 entries, no Laguna. Artificial Analysis has no model page for it at all. Nothing improper about a lab publishing its own evals, and poolside releasing the trajectories is more transparency than most, but self-reported is self-reported.

The reason to be careful is that the two public boards do not even agree with each other on models they both cover. GPT-5.6 Terra reads 88.0% on Artificial Analysis and 78.4% on tbench.ai, a spread of nearly ten points on the same model and the same named benchmark. Two things drive that: tbench pairs a model with a specific agent harness while Artificial Analysis runs its own, and the AA figure is a max-effort configuration while the tbench entry does not state an effort level. Dropping poolside's 70.2% into either table is comparing three different measurement setups. For scale, the tbench.ai board tops out at 83.8% for Claude Code paired with Fable 5 and 83.1% for Codex with GPT-5.5; Claude Code with Opus 4.8 sits at 78.9% and with Opus 4.7 at 68.9%. So poolside's claim lands next to Opus 4.7 and roughly nine points below Opus 4.8, twelfth of seventeen entries, which is a more sober placing than the launch coverage implies. Even that assumes the number survives an independent run, and nobody has run one.

One smaller ambiguity worth naming, since this section is about reading claims carefully. Poolside's blog says 4,096 H200s and under nine weeks from the start of training to the launch post. Its press release says 4,000 GPUs and under four weeks to train end to end. Those are probably not in conflict: nine weeks is a calendar window that includes post-training and release prep, four weeks is the training run itself, and four fits inside nine comfortably. Read the shorter figure as training time, not as how long it took to get from nothing to a shipped model.

Open weights, and why self-hosting still loses

The weights are genuinely downloadable under OpenMDW-1.1, with day-one vLLM, SGLang and Ollama support. Sizing catches people out, though: mixture of experts saves compute per token, not memory. All 118 billion parameters stay resident. Poolside's own vLLM recipe puts the BF16 checkpoint at about 235GB, FP8 at 121GB, and INT4 at 72GB, and states outright that BF16 does not fit on a single GPU. The 8 billion active parameters buy you speed, not a smaller box.

Published hourly rates for configurations that can actually hold it start at $5.85 an hour for a single B300 288GB, then $5.92 for four A100 80GBs, $8.04 for four H100s, $9.08 for two H200s. Take the cheapest, $5.85 an hour, roughly $4,212 a month running continuously. To spend $4,212 on the paid API at $0.20 per million output tokens you would have to generate 21.06 billion output tokens. At 249,000 tokens per trajectory that is about 84,600 agent runs a month, 2,800 a day, a sustained 8,100 output tokens per second for thirty days straight.

A B300 serving an 8B-active mixture of experts at high batch concurrency can plausibly approach that rate, so this is not a throughput impossibility. It is a staffing question. Sustaining 8,100 tokens a second every second for a month means you are running an inference service: capacity planning, batching, failover, someone on call. The API charges $0.20 a million and hands you all of that.

Which inverts the usual open-weights argument. Normally you self-host to save money. Here the API is priced below what your own hardware costs, so the weights are worth having for data isolation, air-gapped deployment, fine-tuning and insurance against the hosted endpoint changing its terms. Those are good reasons. Saving money is not one of them.

The small sibling, and the pricing muddle around it

Laguna XS 2.1 arrived three weeks earlier, on July 2: 33B total, 3B active, 256K context, same OpenMDW-1.1 license, 63.1% on SWE-Bench Multilingual against 78.5% for its larger sibling. Its price depends on who you ask. Poolside's blog says $0.10 input and $0.20 output with a $0.05 cache read. OpenRouter lists $0.06 and $0.12, marked as 40% off. Both can be true at once if the discount is a promotion, but nobody has said how long it runs, and it makes XS temporarily cheaper than S while being a bit over a quarter the size and materially worse. If you are choosing between them today, the discount is the only argument for XS, and discounts expire.

Poolside says a larger Laguna model began pre-training the week before the July 21 launch. No name, no size, no date. Given this one went from first token to release in about two months, the gap probably will not be long.

Where we would actually use it

High-volume, low-stakes agent work is the obvious fit. Test generation, dependency bumps, lint and codemod passes, first-draft PRs that a human reviews anyway, CI bots that run hundreds of times a day. In that shape the difference between $50 and $7,470 per thousand runs dwarfs a fifteen-point accuracy gap, because a failed run costs you a retry and the retry costs five cents.

We would not put it on the critical path yet. The benchmarks are unverified, OpenRouter is the only host, and there is no first-party rate card, which means no first-party commitment to keep the price where it is. A model that is free to use for a limited time is a model whose price can move. Cheap enough to evaluate this afternoon; not cheap enough to bet a production pipeline on before someone independent runs the evals.

And if you take one thing from this: go find out how many tokens your agent actually spends per task before you pick a model on its rate card. Poolside handed us that number and it changed the analysis. Most vendors will not, and the per-million price you are comparing is, on its own, not a cost.

Sources

• Poolside, Introducing Laguna S 2.1 for the launch, self-reported benchmarks, training run and quoted rates.
• OpenRouter, Laguna S 2.1 and the free endpoint for the $0.10/$0.20/$0.01 rate card, the 1M and 256K context split, and the training-data terms.
• Hugging Face model card for architecture, layer configuration and the OpenMDW-1.1 license.
• vLLM recipe for the BF16 1M versus quantized 256K distinction and the measured checkpoint sizes of roughly 235GB, 121GB and 72GB.
• Spheron GPU recommender for the hourly rates on each self-hosting configuration. Note its $1.48 A100 figure is per GPU inside a four-GPU deployment, not a single-card total.
• tbench.ai Terminal-Bench 2.1 leaderboard and Artificial Analysis for the independent scores and the gap between the two boards, both checked July 27, 2026.
• MarkTechPost for the thinking-mode completion-token counts of roughly 249,000 and 99,000 per trajectory.
• OpenRouter rate limits for the free-tier request caps.
• OpenAI, Anthropic, Google and DeepSeek pricing pages for the comparison table.