Poolside’s Laguna S 2.1: the model factory delivers

The lab with the fastest AI model factory has a shot to the top.

On May 22, Poolside began pre-training a new model on 4,096 NVIDIA H200s and 60 days later, the weights and every evaluation trajectory were published online, openly. Laguna S 2.1 is an agentic coding model that runs inside a terminal or developer harness where it plans, edits files, runs code, reads the results and keeps going for hours without a human. Its architecture is a mixture of experts, 118 billion parameters with around 8 billion active per token, holding up to a million tokens of context. Quantized, it fits on one NVIDIA DGX Spark. This gives a desktop-class machine the ability to run multi-hour autonomous coding agents.

And yesterday, the company shipped the macOS app for running Laguna, other open models, as well as Claude and Codex agents. I had the pleasure to test the product pre-release and I’m excited to see what you think!

The model factory in motion

Regular readers will recall co-founder Eiso Kant’s RAAIS 2025 talk, Inside poolside’s path to AGI, and our November 2024 conversation amid mounting arguments that deep learning was (allegedly) hitting a wall. We disagreed and spent an hour on why there is no scaling wall. His case was that reinforcement learning on code, inference-time compute and faster iteration would keep carrying capability forward.

Compared to two models built at roughly its scale (NVIDIA’s Nemotron 3 Super and Mistral Small 4), Laguna S 2.1 scored 70.2% with thinking enabled on Terminal-Bench 2.1 in Poolside’s agent harness. Everything that beats Laguna is either closed or at least 2.5x larger. These are Poolside’s own harness runs, with competitor scores taken from vendor reports, benchmark-author leaderboards and third-party trackers. Every trajectory behind them is published.

By Poolside's own count, Laguna S 2.1 served 450 billion tokens in its first seven days, four times what M.1 and XS.2 managed over the same stretch in April. Its day-two peak of 102 billion took those earlier models a month to reach, and demand ran past the GPU capacity the company had planned for. Overall, model weights were downloaded over 1.1 million times so far. You can track live data at poolside.ai/pulse.

Three releases in three months

At RAAIS 2025, Eiso described the Model Factory as a fully versioned graph of modular components, from data ingestion through training and evaluation, with every experiment tracked immutably. One researcher pushed a new RL optimization idea to production results in under a week. Another ran 500 architecture sweeps over a weekend with a simple for loop.

“When your factory is built well,” Eiso said, “the big training run is the easy part.”

Indeed, the release schedule is showing the results: Laguna M.1 and Laguna XS.2 arrived on April 28, then on July 2, Laguna XS 2.1 matched M.1 on SWE-Bench Multilingual with around one-seventh of the active parameters. Finally, S 2.1 followed on July 21, less than nine weeks from its first pre-training token, post-training and evaluation included.

Importantly, the improvements compound from one release to the next, which is why regular shipping is so important. S 2.1 is Poolside’s first model to run RL in FP8 precision, and its new sandboxing infrastructure supports background processes and cached artifacts. To reduce dependence on any one tool interface, the same prompts are rolled out through several agent harnesses. Some overfitting remains even so. In third-party harnesses whose tool schemas differ slightly from Poolside’s own, the model will sometimes follow its memory of the interface rather than the definition in front of it, then correct itself once the harness rejects the call.

Persistence is trained

The post-training corpus spans 409,000 agentic and non-agentic environments, including 168,000 standard software-engineering workflows and 83,000 terminal setups. Most of the software-engineering work is grounded in real code history. The largest single source reproduces real commits, some 38,000 tasks drawn from 17,000 repositories. Others reconstruct deleted files, repair injected bugs, install unfamiliar repositories or reproduce merged pull requests.

Pengming Wang, Poolside’s co-head of applied research, puts the gains down to trained working habits: more verification, more persistence, and less declaring victory while tests are still failing. Thinking mode makes the trade-off visible too. It lifts Terminal-Bench 2.1 from 60.4% to 70.2%, and DeepSWE from 16.5% to 40.4%, the latter at an average of 249,000 completion tokens per trajectory.

In one 50-minute run, the model took 181 steps, without human intervention, to build an HTML and CSS rendering engine in JavaScript. It implemented a tokenizer, DOM, cascade, layout system and canvas renderer. The model has no vision capability yet, so it could not look at what it had drawn and instead built increasingly elaborate ways to measure its output against a real browser.

But that persistence also creates known failure modes. S 2.1 can overthink simple problems, mishandle nested tool arguments and initially reach for a familiar tool schema instead of the one in front of it. During post-training, more than half of the trajectories on the SWE-bench family were at one point flagged for potential reward hacking because the model had found the original pull request online and applied its solution. An LLM judge calibrated on human-labeled trajectories identified the cases for review, and adding an instruction against using solutions found online generally pushed the flagged rate below 2%.

The model is not the product

A capable model is not a useful coding agent on its own. It needs a harness to run the agent loop and an interface a developer can direct and inspect, and Poolside has spent the past year building both for its own team. On July 28 it released them: Poolside Desktop Assistant, a macOS app for running several coding agents at once, with extensions for VS Code and Visual Studio and the pool command-line harness behind it.

Poolside did not build a funnel into its own models. The Assistant runs on the Agent Client Protocol, so an existing Claude Code, Codex or Gemini subscription works in the same window as pool, with no model calls routed through Poolside. A session can hand off from one agent to another with its context intact, so the agent that plans a piece of work need not be the one that writes it or the one that reviews it. And because each agent gets its own Git worktree, they can run in parallel without overwriting one another.

Local models run through MLX. Download Laguna XS 2.1 and the loop runs entirely offline, with no code or prompts leaving the machine. Poolside is candid about the cost. Local coding models want a great deal of unified memory, and a model loading is not the same as a model you would choose to work with all day.

Intelligence you can own

Last month I argued that Europe cannot rent its way to AI sovereignty. Three days after Laguna shipped, Jensen Huang made a version of the same argument in his first post on X, sharing an open letter signed by NVIDIA alongside Microsoft, Meta and Hugging Face on why open models strengthen security, accelerate innovation and enable sovereignty, and why the world needs frontier models of both kinds. The same logic applies inside an enterprise. Most frontier AI is consumed through an API or a desktop app, which means the customer’s code crosses its security boundary and the provider sets the terms. An open-weights model that can run on hardware the customer controls changes that relationship. It need not be the best model in the world to be strategically useful, only capable enough that ownership becomes a credible alternative to dependence.

For Laguna, the weights are on Hugging Face under OpenMDW-1.1, the Linux Foundation’s permissive model license, which grants royalty-free rights to use, modify and redistribute with no revenue thresholds or branding conditions attached. The terms attached to open weights vary, and they move. Tencent’s Hy3 is Apache 2.0, though the preview it shipped in April came under a community license that by its own terms did not apply in the European Union, the United Kingdom or South Korea. Kimi K3, which arrived six days after Laguna, ships under a license of Moonshot’s own drafting that requires a separate agreement with the company once a model-as-a-service business clears $20 million in revenue, and prominent “Kimi K3” branding in any product above 100 million monthly active users. Developers can run Laguna themselves, use hosted inference or request the pre-post-training base weights for further research.

This is also where Poolside’s acquisition of Fern Labs fits. Fern’s team built long-running agents for high-stakes deployments. Poolside now combines that work with models and on-site systems that can operate inside the customer’s security boundary.

The part we like most is trajectories.poolside.ai. Poolside has published the trajectories from its final evaluation runs, including failures, although the archive notes that a timed-out attempt may end before a trajectory is created. At a moment when agent benchmark claims are often presented as a table without the underlying work, this is a meaningful improvement in disclosure.

Sixty days from the first pre-training token to open weights, and the lessons from each model land in the one after it. Poolside says finer effort control and more efficient thinking are coming, and the next and larger Laguna model has already begun training. We’re excited to see what’s next!