# Laguna S 2.1: an 8B-active model that won't give up
> Satyajit Ghana — Head of Engineering @ Inkers Technology
> canonical: https://ai.thesatyajit.com/articles/laguna-s-2-1
> date: 2026-07-21
> tags: llm, agents, coding, open-weights, explainer
[Laguna S 2.1](https://poolside.ai/blog/introducing-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](/articles/dgx-spark-batching). 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](/articles/laguna-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.
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:
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:
```text
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 elements
```
**Optimizing 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](/articles/laguna-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](/articles/laguna-model-factory) that makes shipping it every few weeks look routine.
---
*Source: [Introducing Laguna S 2.1](https://poolside.ai/blog/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.*