Poolside releases Laguna XS.2 and M.1, models built for agentic coding

Poolside has released the first models in its Laguna family, XS.2 and M.1. Rather than building ordinary autocomplete AI, the company is betting on coding agents that can work on a task for a long time, step by step, without constantly losing context. The idea is that a model should do more than write a snippet of code: it should read a repository, make edits, run tests, analyze errors and bring a change to a working state in a single loop.

What Poolside unveiled

The release includes two models and the agent environment the company uses to train its own systems. The flagship Laguna M.1 is a large MoE model with 225 billion parameters, 23 billion of them active per token. Laguna XS.2 is considerably more compact: 33 billion total parameters and 3 billion active.

This is an important signal for the market: Poolside is shipping not only a server-side model for heavy workloads but also a lighter version for local use. XS.2 is the company's first open-weight model. Poolside distributes it under the Apache 2.0 license and specifically stresses that it can run on a Mac with 36 GB of RAM via Ollama.

Alongside the models, the company opened a research preview of the pool terminal agent and an ACP client with a server. This is the same environment Poolside uses internally for RL training and for checking how an agent solves real engineering tasks step by step.

Benchmark results

The release's main argument is its 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 for its weight class: 68.2%, 62.4%, 44.5% and 30.1%, respectively. For a compact open-weight model, this is a level that many local coding agents will now aim for.

The numbers matter beyond their face value. SWE-bench Verified and Pro test whether a model can fix real bugs in existing repositories, while Terminal-Bench is closer to how an agent behaves in a terminal, where it has to work with files and commands. Poolside explicitly calls both Laguna models suited to long-horizon tasks: cases that require holding context, planning a series of steps and not falling apart 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 has a context window of 131,072 tokens
• XS.2 can run locally on a Mac with 36 GB of RAM
• Both models were trained on more than 30 trillion tokens

How the models are built

Both Laguna models were trained from scratch on Poolside's own infrastructure, without relying on anyone else's base model. For M.1, the company used 6,144 interconnected NVIDIA Hopper GPUs. The family is built on Mixture of Experts: only a subset of the "experts" activates at each step, so a model can be large in total parameters yet not as expensive at inference as dense models of comparable scale. That matters especially for agentic scenarios, where the model is called many times.

For XS.2, Poolside separately describes a set of efficiency choices: a mix of Sliding Window Attention and global attention, FP8 quantization of the KV cache, and an architecture with 256 experts. As a result, the model has a 131k-token context window and supports native reasoning between tool calls. Stripping away the marketing, the point is simple: the agent can alternate between thinking, terminal work and next actions without a hard break between these stages, and with lower memory costs.

The announcement puts particular emphasis on training agents, not just the language model itself. Poolside built an asynchronous RL system in which actors spin up sandboxes, run tasks, collect trajectories and pass them to the trainer almost continuously. The company also claims that the Muon optimizer reached the same training loss in roughly 15% fewer steps than AdamW. This does not make Laguna an automatic leader on every metric, but it shows the maturity of the whole stack rather than a single lucky checkpoint.

What this means

The market now has more than just "code models": it has systems tailored for full agentic programming. For developers, this means one more strong open-weight base that they can fine-tune, quantize and run locally. For the industry as a whole, the Laguna release shows a shift from the "model writes a function" scenario to one where AI handles an entire long engineering task, and that is exactly what the next wave of competition is being built around.