Verdict: Laguna S 2.1 is the first genuinely frontier-class open-weight coding model to come out of a Western lab in roughly a year, and it does it with a trick most people underestimate — tiny per-token cost. Built by Poolside (San Francisco, founded 2023 by ex-GitHub CTO Jason Warner and Eiso Kant), it packs 118 billion parameters but only turns on 8 billion of them for any single token. On Terminal-Bench 2.1 it scores 70.2%, ahead of DeepSeek's 1.6-trillion-parameter DeepSeek-V4-Pro-Max at 64.0% — at roughly one-sixth the active parameters and a fraction of the inference cost. For builders evaluating local AI now, this is the most consequential open release of July 2026.
TL;DR · Last verified: 2026-07-24
- 118B total / 8B active parameters, Mixture-of-Experts architecture, 1M-token context window (Poolside, official spec).
- 70.2% on Terminal-Bench 2.1 (with thinking mode on); beats DeepSeek-V4-Pro-Max (1.6T params, 64.0%) on agentic coding.
- Open weights, OpenMDW-1.1 license, free on Hugging Face and OpenRouter (256K context tier).
- Runs on a single NVIDIA DGX Spark at NVFP4 quanitization, or on two Sparks at higher precision (NVIDIA + Poolside day-one support).
- Two modes: "off" and "max" thinking; max thinking lifts Terminal-Bench from 60.4% to 70.2%.
- Pricing/limits are volatile and can change — last checked 2026-07-24.
What is Laguna S 2.1?
Laguna S 2.1 is an open-weight Mixture-of-Experts (MoE) language model from Poolside designed specifically for agentic coding — long-horizon tasks where the model has to plan across many steps, call tools, and reason about partial results. It was released July 21, 2026 under the permissive OpenMDW-1.1 license, with weights on Hugging Face and hosted inference through OpenRouter and several other providers.
Its headline architectural number is "118B total / 8B active." That distinction is the whole point of Mixture-of-Experts: the model has 118 billion parameters sitting in memory like an on-call roster of 257 specialists (256 routed experts plus one shared expert, per the official Hugging Face model card), but for any single chunk of text it routes through only the ~8 billion parameters that matter for that chunk. Inference cost and speed scale with the 8B active count, not the 118B total.
That's also why it runs on surprisingly modest hardware. While the full BF16 checkpoint needs ~236 GB of memory (two high-end GPUs minimum), the NVFP4 quantized variant Poolside co-developed with NVIDIA fits on a single DGX Spark, the desktop-class Grace-Blackwell machine with 128 GB of unified LPDDR5x memory.
How does Mixture-of-Experts make a 118B model cheap to run?
Mixture-of-Experts keeps the knowledge of a 118-billion-parameter model but spends the per-token compute of an 8-billion-parameter one. Think of a hospital with 257 specialists on staff: you don't summon all of them for a broken arm — you call in the two or three who handle that injury. The rest stay on standby. The MoE router does this routing inside the network on every single token.
Laguna's specific architecture, from the Hugging Face model card, is:
- 48 layers, with 12 using global attention and 36 using sliding-window attention (512-token window).
- 256 routed experts + 1 shared expert, top-10 routing (the 10 best-matching specialists run on each token, plus the always-on shared one).
- Grouped-query attention, 8 key/value heads, head dimension 128, with per-head softplus output gating.
- Vocabulary of 100,352 tokens, shared across the Laguna family tokenizer.
- Context window of 1,048,576 tokens (1M).
The payoff is concrete. Because the model only ever computes 8B parameters per token, the throughput you actually experience is closer to an 8B dense model than a 118B one — but the knowledge surface, the "what does this model understand?" capacity, is the full 118B. That combination is what lets a mid-size MoE behave like a frontier model while staying cheap to serve.
Is Laguna S 2.1 actually better than DeepSeek and other larger rivals?
On agentic coding benchmarks, yes — within its weight class. On the absolute frontier, no; closed models like Claude Fable 5 and Kimi K3 still lead on several measures. The honest framing Poolside itself uses is "best in weight class," not "best in world."
Here's the public benchmark table Poolside published at release, sourced from the official announcement:
| Model | Total / Active params | Terminal-Bench 2.1 | SWE-Bench Multilingual | SWE-Bench Pro | DeepSWE v1.1 | SWE Atlas |
|---|---|---|---|---|---|---|
| Laguna S 2.1 | 118B / 8B | 70.2 | 78.5 | 59.4 | 40.4 | 46.2 |
| Tencent Hy3 | 295B / 21B | 71.7 | 75.8 | 57.9 | – | – |
| Inkling (Thinking Machines) | 975B / 41B | 63.8 | – | 54.3 | – | – |
| Nemotron 3 Ultra (NVIDIA) | 550B / 55B | 56.4 | 67.7 | – | – | – |
| DeepSeek-V4-Pro-Max | 1.6T / 49B | 64.0 | 76.2 | 55.4 | 9.0 | 27.2 |
| Qwen 3.7 Max | – | 74.5 | 78.3 | 60.6 | – | – |
| Muse Spark 1.1 | – | 80.0 | – | 61.5 | 53.3 | 42.2 |
| Kimi K3 | 2.8T / 50B | 88.3 | – | – | 69.0 | – |
| Claude Fable 5 | (closed) | 88.0 | – | 80.3 | 70.0 | – |
Scores marked with asterisks in Poolside's full table are third-party-reported (Artificial Analysis, Scale AI, Toolathlon leaderboard). Full evaluation trajectories are published at trajectories.poolside.ai.
Three things to read from this:
- The weight-class story is real. Laguna S 2.1 is 1/135th the total parameter count of Kimi K3 (which scored 88.3) yet lands 70.2 on the same measure. About one-sixth the active parameters of DeepSeek-V4-Pro-Max and 6 points ahead on Terminal-Bench.
- DeepSWE is where headroom still lives. Laguna scores 40.4 on DeepSWE v1.1 versus DeepSeek's 9.0 — a 4.5× gap on a benchmark that isn't saturated yet. This is the most telling agentic-coding signal.
- Closed frontier models still lead outright. Claude Fable 5 sits at 88 on Terminal-Bench and 80 on SWE-Bench Pro. Laguna is the best open model in its weight class, not the best model in the world. Poolside is explicit about this distinction, and so should you be before betting an architecture on it.
If you're comparing open-weight rivals — see our own Qwen 3.8 vs Kimi K3 vs GPT-5.6 vs Fable 5 comparison for the frontier-class landscape, and DeepSeek V4: The 1.6T Open-Weight Model That Closes the Frontier Gap for the very DeepSeek model Laguna competes with on the agentic-coding axis.
What's the thinking mode, and how much does it change results?
Laguna S 2.1 ships with two modes: thinking off and thinking max (enabled by default). In thinking mode the model pauses and reasons through a problem step-by-step before acting — comparable to the difference between someone blurting out an answer and someone who works through it on paper first. For simple, fast tasks you can turn thinking off and skip the latency. For harder agentic work, max thinking flips a different version of the model on in your head.
The benchmark gap is large enough to plan around. Poolside reports that max thinking lifts Terminal-Bench 2.1 from 60.4% to 70.2% and DeepSWE v1.1 from 16.5% to 40.4% — more than a doubling on DeepSWE. Those gains cost tokens: DeepSWE trajectories Poolside measured run about 249k completion tokens in thinking mode versus 99k without. The lesson for anyone serving Laguna is that thinking is where the model's real capability lives, but it is not free compute.
Notable detail: there is currently no user-configurable low/medium/high thinking-effort control. Poolside has said future models will add effort control. For now it's either off or max.
What are the headline real-world tests Poolside published?
Three unedited trajectories came with the release, meant to demonstrate behavior rather than round-number scores.
1. A full HTML/CSS rendering engine from scratch. Poolside gave Laguna an empty folder and asked it to build a browser engine in vanilla JavaScript. Over a 50-minute session with 181 steps and no human intervention, the model built a full pipeline — parser → cascade → layout → renderer. Because Laguna has no vision capabilities, it verified its own work by running headless Chromium, reading canvases back, and comparing screenshots numerically against its own canvas rendering.
2. Optimizing Poolside's own production agent harness. This is the most operationally interesting demo if you're a builder. Poolside ran Laguna against its own internal agent code under a strict research loop: one approach at a time, benchmark after every change, keep only winners. The model found an O(n²) string concatenation bottleneck in streaming-token accumulation, replaced it with buffers, memoized materializations, and pre-allocated slices. Result: a 5.2% speedup and roughly 70% lower memory allocation. When speedup gains went marginal, the model autonomously pivoted to optimizing memory allocation instead of halting.
3. Re-deriving an Erdős combinatorics problem. Laguna re-derived a closed-form infinite family of solutions to a binomial-coefficient problem over 68 minutes — using Perl as a brute-force tool because the sandbox lacked Python. Tellingly, Laguna's 8-index family is structurally different from the previously-published 6-index family, which means it was a genuine re-derivation rather than reciting prior work.
Can you actually run Laguna S 2.1 yourself, and on what hardware?
Yes — that's the whole pitch. The NVFP4 quantized variant Poolside co-developed with NVIDIA runs on a single DGX Spark (the Grace-Blackwell GB10 desktop, 128 GB unified memory, ~1 petaFLOP of FP4 throughput). Higher precision (BF16, FP8, INT4) is available too, and NVFP4 in particular needs careful deployment tooling — NVIDIA published a ready-to-run config for it on the DGX developer forums.
At BF16 the checkpoint is ~236 GB, which calls for two linked Sparks or a multi-GPU datacenter node. Quantized variants cut this substantially. Here's the broad-stroke picture from the model card and community deployment guides:
| Configuration | Approx. memory | Typical hardware | Note |
|---|---|---|---|
| BF16 (full) | ~240 GB | 2× DGX Spark or 3× A100/H100 80GB | Full quality |
| FP8 quantized | ~120 GB | 2× A100/H100 80GB | Near-full quality |
| INT4 / NVFP4 | ~60 GB | 1× DGX Spark, or 1× A100 80GB | Single-Spark deployment |
| GGUF (llama.cpp) | varies | consumer GPUs with CPU offload | Poolside's llama.cpp fork branch laguna |
The model ships day-one support for vLLM, SGLang, TRT-LLM, Ollama, and llama.cpp (Poolside's own fork), so the deployment path matches most existing agent stacks. If you want to go deeper on the local-AI hardware decision itself, see our Should You Buy a GPU for Local AI in 2026? breakdown — it covers the cost-vs-API tradeoff that makes choosing between self-hosting and OpenRouter genuinely interesting here.
How much does it cost to use Laguna S 2.1?
Two paths.
Hosted (OpenRouter). Poolside offers Laguna S 2.1 through OpenRouter with a free tier (up to 256K context) and a paid tier for the full 1M context at $0.10 / $0.20 / $0.01 per 1M input / output / cache-read tokens (per Poolside's official announcement; pricing can change).
Self-hosted. Download the weights from Hugging Face under OpenMDW-1.1 and run on your own hardware. You pay for the box once and pay nothing per token forever after. That's the case for any team with data-residency rules, air-gapped requirements, or per-token costs that have crossed into "we should just own the compute."
For a worked version of the self-host-vs-API decision for an entire workspace, see Self-Hosted AI Workspaces in 2026, and for the broader direction of open-weight AI economics, Open-Weight vs Closed-Weight AI in July 2026. For another angle on cutting inference spend specifically, Cut AI Inference Costs 60% With Open-Source Model Routing covers how routed MoE setups change the per-token math.
How does Laguna S 2.1 fit the open-weight landscape in 2026?
Two contexts matter.
Western gap-filling. Poolside points out that for roughly 11 months before Laguna S 2.1, no Western lab had released an open-weight model in this size class — the strongest open weights were coming out of Chinese labs like DeepSeek, Qwen, and Moonshot. Laguna is the first from a US-headquartered lab to compete at this weight on agentic coding. It's both a technical claim and an ecosystem/bet: that radical transparency (full trajectories, exact scores side-by-side with competitors) and small efficient open weights is how a smaller lab competes with frontier-scale capital.
Release velocity. Laguna XS 2.1 (33B total / 3B active, sliding-window attention) shipped July 2, 2026 specifically to run locally on a single desktop GPU. Three weeks later Laguna S 2.1 (118B / 8B) arrived. Poolside has stated it's shipping new models roughly every ~5 weeks — which means whatever Laguna S 2.1 can do today, a better version is plausibly here in a month or two.
For builders, this is exactly the same pattern affecting the broader frontier: the AI model pricing war of 2026 where frontier labs have lost pricing power and builders profit. Models land faster than most procurement cycles can absorb them. Plan for that.
What does this mean for you?
If you're building agentic coding tools and you have NVIDIA DGX-grade hardware (or can rent it), Laguna S 2.1 is the open-weight model to benchmark against right now. It occupies a genuinely interesting cost/quality spot — out-thinking DeepSeek-V4-Pro-Max on agentic coding while using a fraction of the active compute. Run a real eval on your own tasks before committing. Poolside's benchmark numbers are self-reported (not independently verified), so treat them as a signal, not a proof.
If you're a small team or solo builder evaluating "can I own my AI?," this is the cleanest example yet of the trend we've been tracking all year: how you can run a capable coding assistant locally without paying a per-token tax to a closed API. It doesn't out-Claude Claude, but it doesn't need to — at this size and price it changes what's possible on your own desk.
If you're routing models for a business, the per-token economics matter here even if you don't self-host the weights. An 8B-active MoE is cheap to serve, and open weights mean multiple competing providers show up fast. The practical pattern is still route to the right model per task — use Laguna for agentic-coding-shaped work where its self-verification behavior pays off, and lean on larger or closed models where raw frontier performance is the binding constraint.
Watch the volatile facts. Model versions, benchmark scores, pricing, and hardware support in this category change roughly every few weeks. Whatever this article says as of July 24, 2026, re-verify before a procurement commitment — especially quantization support and hosted pricing, which are the most volatile.
FAQ
Q: What is Laguna S 2.1? A: Laguna S 2.1 is an open-weight Mixture-of-Experts coding model released by Poolside on July 21, 2026. It has 118 billion total parameters but only activates 8 billion per token, supports a 1 million-token context window, and is licensed under OpenMDW-1.1 (free for commercial and non-commercial use).
Q: How does Laguna S 2.1 compare to DeepSeek and Qwen? A: On Terminal-Bench 2.1 Laguna S 2.1 scores 70.2%, ahead of DeepSeek-V4-Pro-Max (1.6 trillion parameters, scoring 64.0%) and Tencent Hy3 (295B params, 71.7%). It trails closed frontier models like Kimi K3 (88.3%) and Claude Fable 5 (88%). The honest framing is "best open-weight model in its 118B weight class," not "best in world."
Q: Can you run Laguna S 2.1 on a single GPU or desktop? A: Yes, at NVFP4 quantization it runs on a single NVIDIA DGX Spark (Grace-Blackwell GB10, 128 GB unified memory). The full BF16 checkpoint needs roughly 240 GB of VRAM, which requires two linked Sparks or multiple datacenter GPUs. Quantized variants (FP8, INT4, NVFP4, GGUF) reduce the requirement substantially.
Q: What is the thinking mode in Laguna S 2.1? A: Laguna S 2.1 has two thinking modes: off and max (max is enabled by default). In "max" mode the model reasons step-by-step before acting. Poolside reports that max thinking lifts Terminal-Bench 2.1 from 60.4% to 70.2% and DeepSWE v1.1 from 16.5% to 40.4%. There is currently no user-configurable low/medium/high effort control.
Q: Is Laguna S 2.1 free to use? A: The weights are free to download from Hugging Face under the OpenMDW-1.1 license (free commercial use). Hosted access through OpenRouter has a free tier up to 256K context and a paid tier at $0.10/$0.20/$0.01 per 1M input/output/cache-read tokens for the full 1M context (pricing as of July 2026 and is subject to change).
Q: What is Mixture-of-Experts and why does it matter here? A: Mixture-of-Experts (MoE) is a sparse architecture where a model has many "expert" sub-networks but only activates a few per token. Laguna has 256 routed experts plus one shared expert and activates 10 routed experts per token. This means per-token compute scales with the 8B active count, not the 118B total — making inference much cheaper and faster than a dense 118B model of equivalent capacity.
Discussion
0 comments