Verdict: Poolside's Laguna S 2.1 is the strongest open-weight coding model the West has produced in 2026 — a 118B-parameter Mixture-of-Experts design that activates only 8B per token, scores 70.2% on Terminal-Bench 2.1, and runs on a single NVIDIA DGX Spark desktop. For small teams that value data privacy and predictable costs, self-hosting is now viable. But it still trails frontier closed models like Claude Fable 5 (88% on Terminal-Bench) by 10–18 percentage points, so teams solving the hardest coding problems should weigh raw capability against the freedom of local control.
Last verified: 2026-07-29
- 118B total / 8B active parameters (MoE) — open weights under OpenMDW-1.1
- 70.2% Terminal-Bench 2.1 · 78.5% SWE-Bench Multilingual (wins outright)
- 1M token context window · thinking and no-thinking modes
- Runs on NVIDIA DGX Spark (~$4,699) at 50–77 tokens/second
- API on OpenRouter: $0.10/$0.20 per 1M input/output tokens
- Trained start-to-launch in under 9 weeks (May 22 – July 21, 2026)
What Is Laguna S 2.1 and Why Does It Matter?
Laguna S 2.1 is an open-weight foundation model built specifically for agentic coding — the kind of task where an AI writes code, runs it, inspects the output, fixes what breaks, and iterates until the work is done. Poolside, a San Francisco AI startup founded in 2023 by former GitHub CTO Jason Warner and software entrepreneur Eiso Kant, released it on July 21, 2026 under the permissive OpenMDW-1.1 license (free for commercial and non-commercial use) (Poolside blog post; Hugging Face model card).
What makes this model notable isn't that it's the biggest or the smartest — it's neither. It's that a 118-billion-parameter model with only 8B active parameters per token can match or beat systems several times its size on real coding benchmarks, while being compact enough to run on a single desktop computer. For the previous 11 months, no Western lab had released an open-weight model in this class; the open-weight frontier had been dominated by Chinese labs like DeepSeek, Qwen, and Kimi (VentureBeat).
How Can a 118B Model Be This Fast? (Mixture of Experts Explained)
The key to Laguna S 2.1's efficiency is its Mixture-of-Experts (MoE) architecture. Think of it like a hospital with 118 doctors on staff — you don't need all 118 in the room for a broken arm. You call in the two or three specialists who can actually help, and the rest stay on standby. Laguna S 2.1 has 256 routed expert sub-networks plus one shared expert, and for each token it processes, only the top 10 experts (amounting to ~8 billion parameters) are activated. The remaining 110 billion parameters sit idle (Hugging Face model card).
This is why the model is fast, cheap to run, and still performs like a much larger system:
| Metric | Value | Why It Matters |
|---|---|---|
| Total parameters | 118B | Full model weight resident in memory |
| Active parameters per token | ~8B (top-10 of 257 experts) | Determines compute cost and speed |
| Memory footprint (BF16) | ~236GB | Needs multiple GPUs at full precision |
| Memory footprint (NVFP4 quantized) | ~70GB | Fits on a single DGX Spark (128GB) |
| Context window | 1,048,576 tokens | Holds an entire codebase in memory |
| Generation speed on DGX Spark | 50–77 tokens/second | Practical for interactive development |
The architecture uses 48 layers in a 1:3 global-to-sliding-window attention ratio (12 global attention layers, 36 sliding-window layers with a 512-token window), grouped-query attention with 8 KV heads, and softplus gating on the router. For teams already familiar with serving models via vLLM or SGLang, the integration is straightforward — Poolside shipped same-day support for vLLM, SGLang, Transformers, TRT-LLM, llama.cpp, and Ollama (Hugging Face model card).
How Does Laguna S 2.1 Compare on Coding Benchmarks?
On the benchmarks Poolside reported (as of July 21, 2026), Laguna S 2.1 is competitive with models two to twenty-four times its size, though it does not lead every category:
| Benchmark | Laguna S 2.1 (118B-A8B) | Top Open Competitor | Top Closed Competitor |
|---|---|---|---|
| Terminal-Bench 2.1 | 70.2% | DeepSeek-V4-Pro Max (64.0%) | Kimi K3 (88.3%), Claude Fable 5 (88%) |
| SWE-Bench Multilingual | 78.5% (wins outright) | Qwen 3.7 Max (78.3%) | — |
| SWE-Bench Pro (Public) | 59.4% | Qwen 3.7 Max (60.6%) | Claude Fable 5 (80.3%) |
| DeepSWE v1.1 | 40.4% | DeepSeek-V4-Pro Max (9.0%) | Claude Fable 5 (70%) |
| SWE Atlas (Codebase QnA) | 46.2% (wins outright) | Muse Spark 1.1 (42.2%) | — |
| Toolathlon Verified | 49.7% | DeepSeek-V4-Pro Max (55.9%) | Muse Spark 1.1 (75.6%) |
Sources: Poolside model card and release blog post, July 21, 2026. Third-party scores marked with asterisks are reported by Artificial Analysis, Scale AI, and the Toolathlon official leaderboard. Full evaluation trajectories are available at trajectories.poolside.ai.
The honest takeaway: Laguna S 2.1 wins outright on SWE-Bench Multilingual and SWE Atlas, stays competitive on Terminal-Bench 2.1 (beating DeepSeek-V4-Pro Max's 64%), but trails frontier closed models by a meaningful margin on Terminal-Bench (70.2% vs. 88%), SWE-Bench Pro (59.4% vs. 80.3%), and DeepSWE (40.4% vs. 70%). Poolside's own team acknowledges the model is "not yet at the frontier" (Poolside blog post).
What Can Laguna S 2.1 Actually Do in the Real World?
Poolside published three case studies that move beyond benchmark numbers into demonstrated real-world capability (Poolside blog post):
1. Built an HTML/CSS rendering engine from scratch. Starting from an empty folder with no starter code, Laguna S 2.1 worked through 181 steps over approximately 50 minutes. It even opened a headless Chromium browser to validate its output by comparing screenshots against expected results — self-verifying, not just generating plausible-looking code.
2. Optimized Poolside's own production code. In an automated research loop, Laguna S 2.1 improved the company's internal agent harness: a 5.2% speedup and approximately 70% lower memory allocation. The root cause it found and fixed was O(n²) string concatenation from streaming-token accumulation, replaced with proper buffering. The final run was validated with Go's race detector and go vet. This isn't a toy demo — it's a real company letting an AI model touch production code and coming out with verified improvements.
3. Re-derived an Erdős math problem. Over 68 minutes, the model independently discovered a proof for Erdős problem #397 (previously solved by GPT-5.2 Pro in January 2026), finding a structurally different eight-index family of solutions from the known six-index family.
These examples matter because they demonstrate the model's core differentiator: it doesn't just write code — it plans, executes, verifies, and iterates. As Poolside's Pengming Wang, Co-head of Applied Research, put it: "What we've done in this model is not necessarily add more intelligence, but improve the behaviors that lead to a more capable model: more verification, less taking things for granted, not declaring victory early, and being more persistent" (Poolside blog post).
Should You Self-Host Laguna S 2.1 or Use the API?
For small teams and business owners, the decision comes down to four factors: cost, privacy, capability gap, and maintenance load.
Cost Comparison: Self-Hosting vs. API
| Approach | Upfront Cost | Variable Cost | Break-Even Point | Best For |
|---|---|---|---|---|
| Self-host on DGX Spark | ~$4,699 (hardware) + power + maintenance | $0 per token | ~6,265 hours of sustained use* | Privacy-critical, constant use |
| API via OpenRouter | $0 | $0.10/1M input, $0.20/1M output | N/A (pay as you go) | Intermittent use, no hardware |
| API via Poolside directly | $0 | $0.10/1M input, $0.20/1M output | N/A | Same rates, direct provider |
| Cloud-rented DGX Spark | $0 | $0.75/hour | N/A | Testing before buying |
At $0.75/hour rental, you'd need roughly 2.2 years of near-constant use to justify the $4,699 hardware purchase over renting (Enverge Spark Cloud). The API route stays cheaper for most intermittent workloads.
When Self-Hosting Wins
- Data privacy is non-negotiable. If you're working with proprietary code, client code, or regulated data that can't leave your premises, self-hosting is the only option that gives you full control.
- You run coding tasks near-constantly. If your team uses an AI coding assistant 4+ hours per day every day, the hardware cost amortizes quickly vs. per-token API charges.
- You want predictable costs. A one-time hardware purchase with no per-token metering makes budgeting simple.
- You need the full 1M-token context window. While the API also supports 1M tokens, self-hosting ensures you're never rate-limited or throttled.
When the API Wins
- You use AI coding tools intermittently. A few times a week or less — pay only for what you use.
- You need frontier-level capability. Laguna S 2.1 trails closed models like Claude Fable 5 by 10–18 points on key benchmarks. If raw capability matters more than data sovereignty, the API route lets you switch models without buying new hardware.
- You don't want to manage infrastructure. Self-hosting means maintaining a Linux machine, keeping inference engines updated, and troubleshooting when things break. An API eliminates all of that.
What Hardware Do You Need to Run Laguna S 2.1 Locally?
At 118B total parameters, the BF16 (full-precision) checkpoint requires approximately 236GB of memory and multiple GPUs. But the quantized variants make local deployment practical (Hugging Face model card):
| Variant | Memory Footprint | Hardware | Speed |
|---|---|---|---|
| NVFP4 | ~68B effective | NVIDIA DGX Spark (128GB) | 50–77 tok/s |
| INT4 | ~121B effective | DGX Spark (128GB) | Slightly slower |
| GGUF (Q4_K_M) | Compressed | DGX Spark or Mac Studio | Via llama.cpp / Ollama |
| BF16 (full precision) | ~236GB | Multi-GPU server (4× GPUs) | Full quality |
The NVIDIA DGX Spark — a $4,699 desktop "AI supercomputer" with a GB10 Grace Blackwell Superchip and 128GB of unified memory — is the platform Poolside specifically targets for self-hosting. The NVFP4 quantized model fits with room left over for context and KV cache (MindStudio; Hugging Face model card). For deeper coverage of local AI hardware options, see our guide to running open-source models on your own hardware.
The simplest path to running Laguna S 2.1 locally is Ollama:
ollama run laguna-s-2.1
Quantized tags like q4_K_M, q8_0, and f16 are available — pick based on your memory budget (Hugging Face model card).
For more advanced serving, vLLM with tensor parallelism across 4 GPUs gives full-precision inference:
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}'
How Does the Thinking Mode Work and When Should You Use It?
Laguna S 2.1 ships with two operating modes: thinking mode (enabled by default) and no-thinking mode. In thinking mode, the model pauses and reasons through a problem step-by-step before answering. In no-thinking mode, it responds immediately, like a quick reflex answer.
The performance difference is significant. Poolside's own benchmarks show that thinking mode lifts the Terminal-Bench 2.1 score from 60.4% to 70.2% — a nearly 10-point improvement. On DeepSWE, the gap is even wider: 16.5% without thinking vs. 40.4% with thinking enabled (Poolside blog post).
Use thinking mode for complex, multi-step coding tasks like building a feature from scratch, debugging a tricky race condition, or optimizing an architecture. Use no-thinking mode for quick questions, code completions, and simple syntax fixes where speed matters more than depth. The model autonomously determines how much test-time compute to spend — you can override it per-request.
How Fast Is Poolside Shipping and What Comes Next?
Poolside published Laguna XS 2.1 (a smaller 33B-A3B model for local/consumer hardware) on approximately July 2, 2026, and Laguna S 2.1 on July 21, 2026 — three weeks apart. The company states they are shipping new models roughly every 5 weeks (benchable.ai).
The Laguna family now spans three tiers:
| Model | Total Params | Active Params | Context | Target Use |
|---|---|---|---|---|
| Laguna XS 2.1 | 33B | ~3B | 262K | Consumer hardware, local dev |
| Laguna S 2.1 | 118B | ~8B | 1M | Desktop/workstation self-hosting |
| Laguna M.1 | 225B | ~23B | 262K | Enterprise/data center |
If the 5-week cadence holds, whatever Laguna S 2.1 can do today, the next version will likely do better within a month or two. For teams deciding whether to buy hardware now, the rapid iteration rate means the model you deploy will improve without needing new equipment — your DGX Spark will run successive models.
This matters for the broader open-weight landscape too. If you're comparing Laguna against the latest Chinese open models, our practical decision guide to Chinese AI models covers DeepSeek, Kimi, GLM, and Qwen in depth — and the recent Kimi K3 release has its own open-weights story worth understanding (Kimi K3 analysis).
What This Means for You
For small teams and solo builders: Laguna S 2.1 makes the case that you no longer need to rent processing from a big tech API to get capable AI coding help. You can download the model, run it on a single desktop machine, and use it without paying per-token fees. The practical skills the model demonstrates — planning steps, writing code, verifying output, iterating — transfer directly to building landing pages, internal tools, and simple applications for your business. If you're already running a local AI stack, our guide to AI agent loop design walks through how to build workflows that keep models like Laguna productive over long sessions.
For engineering teams: The honest assessment is that Laguna S 2.1 is not yet at frontier-level coding — Claude Fable 5 leads by 10–18 points on key benchmarks. But it's the best open-weight option in its weight class by a wide margin, and the combination of a 1M-token context window, thinking mode, and real agentic iteration makes it a strong choice for privacy-sensitive work, long-context codebase tasks, and cost-predictable self-hosting. The existing Laguna S 2.1 explainer on this site covers the architecture in more technical depth.
For the open-weight ecosystem: For 11 months, no Western lab released a competitive open-weight model in this size class. Poolside's 3-model lineup, shipped in roughly 9 weeks of total training time, signals that the gap between Western and Chinese open-weight development is closing — not because they've caught up to frontier, but because they've proven you don't need a trillion parameters to be useful.
FAQ
Q: Is Laguna S 2.1 free to use? A: Yes. The model weights are available on Hugging Face under the OpenMDW-1.1 license, which permits both commercial and non-commercial use at no cost. You can also access it free via OpenCode with the full 1M context window. Running it locally or through OpenRouter costs $0.10 per million input tokens and $0.20 per million output tokens if you use the API (Hugging Face model card).
Q: Can Laguna S 2.1 actually run on a desktop computer? A: Yes, when quantized. The NVFP4 variant fits in approximately 70GB of memory, which means it runs on an NVIDIA DGX Spark (128GB unified memory) at 50–77 tokens per second. The full-precision BF16 version needs ~236GB and multiple GPUs. Quantized versions are also available in GGUF format for Ollama and llama.cpp (Hugging Face model card).
Q: How does Laguna S 2.1 compare to Claude or GPT models? A: Laguna S 2.1 still trails frontier closed models. On Terminal-Bench 2.1, it scores 70.2% versus Claude Fable 5's 88% and Kimi K3's 88.3%. Poolside acknowledges the model is "not yet at the frontier." However, Laguna wins outright on SWE-Bench Multilingual (78.5%) and SWE Atlas (46.2%), beating larger open and closed competitors on those specific benchmarks (Hugging Face model card).
Q: What is Mixture of Experts and why does it matter? A: Mixture-of-Experts (MoE) is an architecture where the model has many specialist sub-networks but only activates a small subset for each token. Laguna S 2.1 has 256 routed experts (plus one shared), and activates only the top 10 per token — that's 8B of 118B total parameters. This keeps compute cost and memory requirements far lower than a dense 118B model, while delivering comparable performance (Hugging Face model card).
Q: What is the context window and why does 1 million tokens matter? A: Laguna S 2.1 supports a 1,048,576-token context window. A token is roughly ¾ of a word, so 1M tokens can hold an entire codebase — every file, function, and dependency — at once, without forgetting earlier parts. This matters for agentic coding because the model can maintain full project context throughout long tasks instead of losing the thread mid-session (Hugging Face model card).
Q: Should I buy a DGX Spark to run Laguna S 2.1? A: Only if you run coding tasks near-constantly AND data must stay on your hardware. At $0.10/$0.20 per 1M tokens via API, intermittent use stays far cheaper than a $4,699 hardware purchase. Renting a cloud DGX Spark at $0.75/hour is a good middle ground for testing before you commit to buying. The right choice depends on your utilization rate and privacy requirements (Enverge Spark Cloud).
Discussion
0 comments