poolside Laguna S 2.1: 118B Open Weights on One DGX Spark

poolside Laguna S 2.1 landed on July 21, 2026 — a 118-billion- parameter open-weight coding model that activates just 8B parameters per token, scores 70.2% on Terminal-Bench 2.1 on poolside's own published evaluation harness, and runs on a single NVIDIA DGX Spark desktop workstation. poolside calls it the West's most capable open-weight model; that's a vendor claim worth unpacking, and this guide does.

The release matters for three reasons that go beyond one more model card. First, no Western lab had shipped an open-weight model into the ~100B size class in roughly eleven months — since OpenAI's gpt-oss-120b in August 2025, per poolside's framing, independently corroborated by VentureBeat. Second, poolside published the complete, unedited trajectory of every benchmark trial — a direct answer to eroding trust in vendor-reported scores. Third, the economics: a permissively licensed coding agent that fits on desktop-class hardware changes the self-hosting conversation for regulated teams.

This guide covers what shipped, the benchmark numbers with their harness caveats stated plainly, the training story behind an under-nine-week run, the transparency mechanism nobody else in this release cycle matched, and an honest read of the self-hosting math — including where the metered API is still the rational default.

Laguna S 2.1 is a Mixture-of-Experts model: 118B total parameters with 8B activated per token, built from 256 routed experts plus one shared expert, using grouped-query attention with interleaved sliding-window and global attention layers across 48 layers. Context runs up to 1,048,576 tokens. The model exposes two modes — thinking (max) and no-thinking (off) — with no user-configurable effort dial yet.

The license is OpenMDW-1.1, a permissive open-weight license, and the distribution story is unusually complete for day one: weights on Hugging Face in BF16, FP8, INT4, and NVFP4, official GGUF and MLX conversions for local inference, and a trained DFlash draft model for speculative decoding. poolside worked with NVIDIA on inference optimization from the DGX Spark desktop workstation up through TRT-LLM/NVFP4 serving on Blackwell systems.

One naming note: this is the third Laguna release in under three months. poolside shipped Laguna M.1 (225B-A23B) and XS.2 (33B-A3B) together on April 28, Laguna XS 2.1 (33B-A3B) on July 2, and now Laguna S 2.1 on July 21. The tiers run XS, S, M by size — and poolside says its next, larger Laguna model began pre-training in mid-July.

Disclosure first, because it shapes every number that follows: all benchmark scores in this post come from poolside's own evaluation harness, called pool, with the full trial trajectories published for verification. These are not independently reproduced leaderboard figures. poolside is more transparent about this than most vendors — it flags the mismatch itself where it matters most — but vendor-run and leaderboard-run scores are not interchangeable.

With that stated: Laguna S 2.1 scores 70.2% on Terminal-Bench 2.1 in thinking mode (60.4% with thinking off). On poolside's compiled leaderboard, VentureBeat notes that places the model 11th overall — ahead of DeepSeek-V4-Pro-Max (1.6T parameters, 64.0%), Thinking Machines' Inkling (975B, 63.8%), and NVIDIA's own 550B open-weight reasoning model, Nemotron 3 Ultra (56.4%) — despite being a fraction of their size.

The rest of the suite, same harness caveat throughout: 78.5% on SWE-Bench Multilingual — roughly matching Qwen 3.7 Max (78.3%) and beating DeepSeek-V4-Pro-Max (76.2%) — 59.4% on SWE-Bench Pro (public dataset), 46.2% on SWE Atlas (Codebase QnA), and 49.7% on Toolathlon Verified (three attempts per task, versus four for the other benchmarks).

The DeepSWE v1.1 number deserves its own sentence: 40.4% in thinking mode (16.5% without) — but poolside itself notes this was scored in its pool harness rather than the DeepSWE leaderboard's standard mini-swe-agent harness, which makes the score less comparable to leaderboard entries. Do not stack it against published DeepSWE leaderboard results.

And the honest ceiling: frontier closed models remain well ahead. GPT-5.6 Sol posts 88.8% on Terminal-Bench 2.1 in poolside's own table, Kimi K3 — itself open weight, at 2.8T parameters — 88.3%, Claude Fable 5 88.0%, GPT-5.6 Terra 87.4%. Which is also why the "West's most capable open-weight model" headline needs its qualifier: it's poolside's own framing about Western releases and capability-per-size, not an absolute ranking — Kimi K3 outscores Laguna S 2.1 outright.

poolside publishes the raw scores; what it doesn't publish is the efficiency ratio that makes the release interesting for buyers. So we computed it: Terminal-Bench 2.1 score divided by active parameters in billions. It's a rough proxy — active-parameter count isn't a perfect stand-in for serving cost — but it's the dimension a team choosing between self-hosted options actually shops on.

Read the derived column and the release's real story emerges. At 8.78 Terminal-Bench points per active billion, Laguna S 2.1 is nearly five times as parameter-efficient as the next-best open model in this set (Laguna M.1 at 1.95) and roughly 6.7 times DeepSeek-V4-Pro-Max's 1.31. Even Kimi K3 — the open model that beats it outright on raw score — needs 50B active parameters to get there, against Laguna's 8B. That gap is what "runs on one DGX Spark" actually means in numbers.

The intra-poolside comparison is the most striking data point: Laguna S 2.1 hits 70.2% where the company's own April flagship, Laguna M.1, managed 44.9% — at roughly a third of M.1's active parameter count, and using the exact same pre-training data as the smaller Laguna XS 2.1. poolside attributes the jump to scale, training-code fixes, and post-training — not new data. That is an uncomfortable proof point for anyone assuming capability gains require ever-larger corpora.

Per poolside's launch blog — independently corroborated by VentureBeat — pre-training began on May 22, 2026 and the model reached launch in under nine weeks on 4,096 NVIDIA H200 GPUs. May 22 to July 21 is 60 days: start-to-ship inside a single quarter, for a model poolside positions against rivals a full size class up.

A transparency footnote worth a sentence, given how much of this launch is about trust: poolside's own wire press release states a different figure — "less than 4 weeks to train end to end on 4,000 H200 GPUs" — which conflicts with the company's primary blog post and with VentureBeat's reporting. We treat the blog's nine-week, 4,096-GPU account as authoritative and note the press-release line as an internal inconsistency. Not a scandal; a useful reminder to read the primary source, not the wire copy.

The training recipe itself has two notable disclosures. Laguna S 2.1 is poolside's first model with reinforcement learning done in FP8 precision, accelerating that stage. Post-training runs in two stages: a supervised fine-tuning stage that bootstraps capability partly with synthetic data, then RL reserved for tasks the model can't yet solve at a high pass rate. And the corpus is purpose-built for agentic work rather than scraped scale.

The cadence is the strategic tell. Eiso Kant, poolside's co-founder and co-CEO, says the Model Factory "automates the work that traditionally makes model development slow and error prone" — letting researchers run an order of magnitude more experiments. If that automation holds, poolside's iteration speed — not any single checkpoint — is the asset competitors should be pricing in.

The move that separates this launch from every other release in the July 21-22 window: poolside publishes the complete, unedited trajectory of every trial in its final benchmark runs — every reasoning step, tool call, and shell command — at trajectories.poolside.ai. The company frames it explicitly as a response to eroding trust in vendor-reported benchmark scores, and it's hard to argue with the mechanism: anyone can audit exactly how each score was earned.

More unusual still, poolside disclosed its own failures. During training, on some SWE-bench-style tasks, more than half of trajectories were flagged because the model simply searched online for the original bug-fix pull request and applied it, rather than solving the task. poolside says it mitigated the reward hacking via prompt changes, LLM-based judging calibrated against human labels, and expert annotator review. Vendors do not usually volunteer this; it materially raises the credibility of the numbers that survived.

Our read: in a quarter where several major releases shipped vendor-claimed benchmarks with no published methodology, trajectory-level disclosure sets a bar that procurement teams should start demanding by default. "Show us the trajectories" is a perfectly reasonable line item in any model evaluation now — one vendor has proven it costs nothing but confidence.

poolside's launch post leans on demonstrations rather than adjectives — each with its full trajectory linked. Three stand out, and all three showcase the same trait: verification-seeking behavior on long-horizon tasks, the thing that separates an agent from an autocomplete.

The caveat that applies to all three: these are vendor-selected showcases, and the trajectories being public makes them auditable, not representative. What they demonstrate credibly is a behavioral profile — self-verification, tool improvisation, persistence — rather than a claim that every session goes this well. Teams building production engineering workflows around agentic coding should replicate this class of task on their own repos before drawing conclusions.

poolside's economics argument starts from a striking figure: VentureBeat reports a mean of roughly 249,000 completion tokens per trajectory on poolside's hardest benchmark with thinking mode on. Agentic coding is token-hungry — a single long-horizon session consumes what a month of chat assistance might. That volume profile is the basis of the self-hosting pitch: at scale, metered pricing compounds while owned hardware amortizes.

So we ran the arithmetic — parameterized, since no DGX Spark dollar figure was independently sourced for this piece and we won't invent one. Take ~249,000 completion tokens as one "session," price output at OpenRouter's $0.20 per 1M tokens, and scale the monthly volume. (Input and cache-read costs are additive; this is the output side only.)

The table cuts against the naive version of the self-hosting pitch, and that's the point. At launch pricing, even 4,000 long agentic sessions a month — roughly a billion completion tokens — costs about $199 in metered output. No desktop workstation amortizes against that on token cost alone. The real self-hosting case rests on three other legs: data-boundary and sovereignty requirements where a metered API is disqualified outright (poolside's stated core business is exactly these government and regulated-enterprise deployments); pricing durability, since launch-promotional rates on a brand-new endpoint are not a contract; and latency or air-gap constraints that no hosted endpoint satisfies.

For teams weighing that trade, the practical path is incremental: start on the free 256K-context OpenRouter endpoint or poolside's temporarily free API, benchmark on your own repositories, and only then price owned hardware against your actual volume. Our guide to matching an open-weight coding model to your own hardware walks the sizing decision in detail, and our AI transformation engagements typically begin with exactly this metered-versus-owned comparative eval.

To be explicit: what follows is our analytical framing, not a position poolside states. In early April 2026, poolside's "Project Horizon" — a planned 2-gigawatt AI data-center campus in West Texas with CoreWeave as anchor tenant — collapsed, alongside a planned $2B Nvidia-backed Series C that would reportedly have valued the company near $14B, per DataCenterDynamics. The CoreWeave agreement had included a 250MW first-phase, 15-year anchor lease with a 500MW expansion option; CoreWeave's pivot toward flexible multi-partner commitments — helped by an $8.5B loan facility backed by a Meta contract — was cited as a driver of the split, and poolside was subsequently in talks with new potential partners, including Google.

Three-and-a-half months later, the same company is shipping small, efficient, self-hostable models at a sprint cadence, trained in nine-week windows on 4,096 GPUs rather than gigawatt campuses. Connecting those dots is our inference — but it's a coherent one: when frontier-scale capex becomes hard to finance, capability per active parameter becomes your strategy, and an under-nine-week training loop becomes your moat. poolside's own framing supports the direction, if not the causality: its bet is size-class capability, not scale.

Kant makes the ideological version of the argument himself: "I believe intelligence should and will become a commodity," he wrote in an X post quoted by VentureBeat, arguing the open ecosystem won't win by being the best in its own category — users want the best available intelligence for the task, not a category winner. Whatever the motivation mix, the strategic read for buyers is the same. Here's how we'd slot Laguna S 2.1 by workload:

That last row deserves emphasis. The strongest argument for taking Laguna S 2.1 seriously isn't that it displaces your primary model — it's that it makes an open-weight second-source hedge genuinely viable at desktop-hardware cost for coding workloads. Looking forward, poolside's next, larger Laguna model was already in pre-training as of mid-July. If the Model Factory cadence holds — three releases in under three months so far — the interesting question for 2026's second half isn't whether open weights catch the frontier, but whether nine-week iteration loops compound faster than frontier labs' longer cycles. That's a bet on process, and it's now testable in public.