2026-07-21 · 7 min · llm · agents · coding · open-weights · explainer
Laguna S 2.1 is poolside's new agentic coding model: a 118B-parameter Mixture-of-Experts with 8B activated per token, a 1M-token context in both thinking and no-thinking modes, and open weights on day one under OpenMDW-1.1. It went from the start of training to launch in under nine weeks, and it is small enough to run on a single NVIDIA DGX Spark. The claim poolside makes is precise and, unusually, falsifiable — they released full evaluation trajectories for every trial: it is the most capable agentic coding model in its weight class, by a wide margin.
The interesting part is how they say they got there. Not by making the model smarter in the raw sense — by making it behave better: verify more, take less for granted, stop declaring victory early, keep going. It's the same family, and the same industrialized pipeline, as the models from Laguna's Model Factory — S 2.1 is the third release in three months.
Punching above its weight class
Here's the whole pitch in one plot: Terminal-Bench 2.1 score against model size, log axis. Toggle to active params and Laguna S 2.1 — at 8B active — sits above open models that activate five to seven times as many parameters, and a dozen points under a closed frontier (GPT-5.6, Claude Fable 5) whose models don't even disclose their size.
Switch to active params and the point is hard to miss: at 8B activeLaguna S 2.1 clears open models activating 5–7× as many parameters, and lands within a dozen points of a closed frontier whose models won’t even say how big they are. Raw score isn’t the frontier; score-per-parameter is the claim.
Read that honestly, the way poolside does: on Terminal-Bench 2.1 its 70.2% is well short of the 88% ceiling that Kimi K3, GPT-5.6 Sol, and Claude Fable 5 share. Their own framing is that the top of these benchmarks is saturating — "as the frontier advances, top scores cluster in the 70–90% range and models that behave very differently end up no more than a few points apart." Where it actually leads is SWE-Bench Multilingual, edging the much larger field:
Poolside is candid about the softer spots too — on DeepSWE v1.1, the least saturated of the set (frontier models spread from 54% to 73%, and some 1T-plus models score under 10%), S 2.1 lands at 40.4%, mid-pack, and it reports that in its own harness rather than the leaderboard's. The takeaway isn't "it wins" — it's "score-per-parameter," and on that axis nothing its size is close.
The second axis: behaviors, not intelligence
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. — Pengming Wang, co-head of Applied Research
The concrete lever behind that is test-time compute. Of every model poolside has trained, S 2.1 has the largest gap between its no-thinking and max-thinking modes — its internal monologue is doing real work, especially on the hard problems. Flip it:
The dashed line is the no-thinking baseline. On DeepSWE — the least saturated of these benchmarks — the internal monologue more than doublesthe score. poolside ships max thinking on by default and lets the model pick its own budget; it says it’s watched coherent reasoning run for hours and hundreds of thousands of tokens.
There's no user-facing low/medium/high dial yet — it's off or max (default), with the model choosing its own budget. Poolside says it has watched coherent, productive reasoning run for hours and hundreds of thousands of tokens, which is also why the 1M-token context matters: long agentic sessions genuinely accumulate that much working state.
Seeing it work
Benchmarks are a proxy; the trajectories are the evidence. Poolside published three unedited runs.
A browser engine from an empty folder. Asked to build an HTML/CSS rendering engine in vanilla JavaScript, Laguna S 2.1 worked one 50-minute session, 181 steps, no human intervention — building the full pipeline (HTML tokenizer → DOM → CSS parser with specificity → cascade → box-model layout → canvas-2D renderer). The resourceful part: with no vision of its own, it needed a way to check its output, so it ran headless Chromium to read the canvas back and compared screenshots numerically against a real browser.
The verbatim prompt, if you want to reproduce it:
your job is it to build a simple browser engine (just html/css) in
javascript to demonstrate the capabilities of poolsides new "Laguna S"
model. the goal is to take render html snippets in a canvas like a real
browser. to demonstrate it the engine, build a self-contained single
page app that showcases a gallery of multiple html snippets and renders
them side by side (canvas with our render engine + iframe letting the
hosting browser render it for real for comparison). support for most
common layout and styling elementsOptimizing poolside's own harness. Pointed at the agent harness that trains and serves the models,
in an automated loop S 2.1 made it 5.2% faster with ~70% lower memory allocation — finding an
O(n²) string-concatenation in token accumulation and swapping in buffers, then memoizing trajectory
materializations and pre-allocating slices. When speedups got marginal, it kept going, switching its
attention to allocations because those were still measurable. (Validated with Go's race detector and
go vet gating — real gains, not hidden race conditions.)
Re-deriving Erdős problem #397, in Perl. With no Python in the sandbox, it found Perl, did exact prime factorizations there, conjectured a family, and proved it — a closed-form infinite family of eight-index solutions to a problem open for over 50 years. It's a re-discovery (GPT-5.2 Pro solved it in January 2026), and poolside says so plainly — but the construction is structurally different (eight indices growing linearly vs the known six-index family), so it's a fresh derivation, not recall.
What actually changed in training
S 2.1 is a scale-up of the Laguna XS family, on exactly the same pre-training data as XS 2.1 — the step up was scale, training-code fixes, and small recipe tweaks, not new data. Almost everything that separates it comes from post-training, in two stages: an SFT stage (partly synthetic) that bootstraps capability, then RL reserved for tasks the model can't already solve at a high pass rate. It's also poolside's first model to run RL in FP8 precision.
The task corpus is the substance: 409k environments — 83k terminal-focused, 168k standard software-engineering — mostly grounded in real code history, the largest source reproducing ~38,000 real commits across ~17,000 repositories, plus merged-PR reconstruction, injected-bug fixing, and a new agentic step: given a repo, install every dependency and get its test suite running. And three changes to the loop map straight onto the "persistence" story:
- More generous rollout budgets — longer timeouts, more tokens per turn, more turns per task than any earlier model (likely why it keeps going).
- A new sandbox — background processes, selective network blocking to shrink the reward-hacking surface, artifact caching.
- Multi-harness rollouts — the same prompts rolled out across several agent scaffolds, so it learns behaviors that transfer instead of overfitting to one harness.
That cadence — M.1 and XS.2 in April, XS 2.1 in July, S 2.1 weeks later — is exactly what the Model Factory was built to enable: reproducible foundations, so each release inherits the last one's work automatically. Poolside is upfront about the rough edges shipped to move fast: some tool-schema slips in third-party harnesses (it leans on memory of its own tool interface), invalid JSON in tools that expect array arguments, and occasional overthinking on competition math.
The take
Laguna S 2.1 is the clearest example yet of a thesis worth taking seriously: how a model works is a separate axis from how smart it is, and it's trainable. Persistence, verification, and backtracking aren't emergent gifts of scale here — they're the product of longer rollouts, a better sandbox, and multi-harness RL, poured into an 8B-active model that then holds its own against giants. It won't top the leaderboards, and poolside doesn't pretend it does. But "frontier behavior at a size you can run on one desktop box" is a more useful thing to ship than another point of benchmark score — and it's the Model Factory that makes shipping it every few weeks look routine.
Source: Introducing Laguna S 2.1 (poolside, 21 July 2026); benchmark figures as published there (pass@1 averaged over 3–4 attempts), with full trajectories at trajectories.poolside.ai. The browser-engine screenshot is poolside's; the visualizations are mine.