Poolside released Laguna XS.2 and M.1 — open models for agentic programming

Poolside has released the first models from the Laguna family — XS.2 and M.1 — and is betting not on ordinary AI for autocomplete, but on code agents that can pursue tasks for a long time and sequentially without constant context loss. The idea is that the model should not just write a code snippet, but read a repository, make changes, run tests, analyze errors, and bring the change to a working state in a single working cycle.

What Poolside Presented

The release included two models and an agentic environment on which the company trains its own systems. The flagship Laguna M.1 is a large MoE model with 225 billion parameters and 23 billion active parameters per token.

Laguna XS.2 is noticeably more compact: 33 billion total parameters and 3 billion active. For the market, this is an important signal: Poolside is releasing not just a server-side model for heavy loads, but also a lightweight version for local use.

XS.2 became the company's first open-weight model. Poolside distributes it under the Apache 2.

0 license and specifically emphasizes that the model can run on Mac with 36 GB of RAM through Ollama. Along with the models, the company opened a research preview of the terminal agent pool and an ACP client with a server. This is the same environment that Poolside uses internally for RL training and testing how the agent solves real engineering tasks step by step.

Benchmark Results

The main argument of the release is the results on applied development tests. Laguna M.1 scored 72.

5% on SWE-bench Verified, 67.3% on SWE-bench Multilingual, 46.9% on SWE-bench Pro, and 40.

7% on Terminal-Bench 2.0. XS.

2 comes in slightly lower, but looks very strong in its weight class: 68.2%, 62.4%, 44.

5%, and 30.1% respectively. For a compact open-weight model, this is already a level that many local coding agents will look to.

These numbers are important not just in themselves. SWE-bench Verified and Pro check whether the model can fix real bugs in existing repositories, while Terminal-Bench is closer to agent behavior in the terminal, where you need to work with files and commands. Poolside directly calls both Laguna models models for long-horizon tasks: when you need to maintain context, plan a series of steps, and not crumble after a long chain of tool calls and intermediate checks.

• Laguna XS.2 is Poolside's first open-weight model
• XS.2 weights are available under the Apache 2.0 license
• XS.2 context window is 131,072 tokens
• XS.2 can run locally on Mac with 36 GB RAM
• Both models were trained on over 30 trillion tokens

How the Models Are Made

Both Laguna models were trained from scratch on Poolside's own infrastructure, without relying on another base model. For M.1, the company used 6,144 interconnected NVIDIA Hopper GPUs.

The family is based on Mixture of Experts: at each step, only part of the "experts" are activated, so the model can be large in total parameters but not as expensive to run as dense models of comparable scale. This is especially important for agentic scenarios where model calls are frequent. For XS.

2, Poolside separately describes a set of efficiency solutions: mixing Sliding Window Attention and global attention, KV-cache quantization to FP8, and an architecture with 256 experts. As a result, the model got a 131k token context window and support for native reasoning between tool calls. If you strip away the marketing, the meaning is simple: an agent can alternate between thinking, working with the terminal, and next steps without a hard break between these phases and with lower memory costs.

A separate emphasis in the announcement is on training agents, not just the language model itself. Poolside built an asynchronous RL system where actors spin up sandboxes, run tasks, collect trajectories, and almost continuously pass them to the trainer. The company also claims that the Muon optimizer allowed it to achieve the same training loss in roughly 15% fewer steps compared to AdamW.

This doesn't make Laguna an automatic leader across all metrics, but shows the maturity of the entire stack, not just one successful checkpoint.

What This Means

The market now has more than just "code models," but systems designed for full-fledged agentic programming. For developers, this means the emergence of another strong open-weight base that can be fine-tuned, quantized, and run locally. For the industry as a whole, the Laguna release shows a shift from the "model writes a function" scenario to a format where AI conducts a long engineering task in full — and this is exactly what the next wave of competition is being built around now.