Laguna XS 2.1

Laguna XS 2.1

Quick answer: Laguna XS 2.1 is Poolside's lightest and fastest agentic coding model — a 33B-total / 3B-active sparse MoE with a 256K context window, trained in-house on 15T tokens. It scores 70.9% on SWE-bench Verified and is small enough to run locally on a Mac with 36 GB RAM. Available free on OpenRouter and Ollama under the commercial-friendly OpenMDW-1.1 license.

At a Glance

Where Laguna XS 2.1 leads

• Local-first design: 33B total / 3B active — runs on a single DGX Spark or a Mac with 36 GB RAM; Q4_K_M GGUF is only 75 GB.
• Strong SWE-bench Verified at 70.9% — competitive with much larger models in its weight class.
• Commercial-friendly license: OpenMDW-1.1 allows free commercial and non-commercial use with modification rights.
• Native reasoning with preserved thinking between tool calls; per-request enable/disable via enable_thinking.
• Broad ecosystem support on day one: vLLM, SGLang, TRT-LLM, llama.cpp, Ollama, Transformers, Atomic Chat.
• Free on OpenRouter during the beta period.

Where it lags

• Terminal-Bench 2.0 score of 37.5% trails larger agentic models substantially.
• Text only — no vision, audio, or multimodal input.
• Sliding-window attention (512-token window on 30 of 40 layers) may degrade on very long-range dependencies even within the 256K context.
• No user-configurable thinking-effort dial — thinking is binary (on or off), not graduated.

Best for: On-device and self-hosted agentic coding workflows where low inference cost and hardware portability matter more than absolute frontier performance.

What Laguna XS 2.1 Is

Laguna XS 2.1 is the small tier of Poolside's Laguna model family, released July 2, 2026 on Hugging Face. It is a second-generation architecture, built on lessons from training Laguna M.1, and represents Poolside's first open-weight release. The model was pre-trained in-house on 15 trillion tokens, then post-trained and fine-tuned with reinforcement learning inside Poolside's proprietary pool agent harness across 409,000+ agentic and non-agentic training environments.

The architecture is a token-choice Mixture-of-Experts transformer with 40 layers: 10 global attention layers and 30 sliding-window attention layers (512-token window), all using sigmoid gating with per-layer rotary scales. There are 256 routed experts plus 1 shared expert per MoE layer, keeping activated compute at ~3B parameters per token despite 33B total weights. The KV cache is quantized to FP8, reducing memory footprint per cached token. A trained speculative decoding draft model (DFlash) is available for lower-latency serving.

Laguna XS 2.1 improves over its predecessor Laguna XS.2 by +1.0 point on SWE-bench Verified (70.9% vs. 69.9%) and +5.4 points on SWE-bench Multilingual (63.1% vs. 57.7%). Poolside notes that the gains primarily came from scale, training improvements, and more diverse post-training data — the pre-training corpus is the same as XS.2. The model is available in BF16 on Hugging Face, with FP8, NVFP4, and INT4 quantised variants provided separately.

Specifications

Pricing

Laguna XS 2.1 weights are freely downloadable from Hugging Face under OpenMDW-1.1, which permits commercial use. API access via OpenRouter is free for a limited period during beta; dedicated API pricing for production deployments is available through platform.poolside.ai.

Context Window

Laguna XS 2.1 has a 256K-token context window (262,144 tokens) — roughly ≈ 393 A4 pages of text in a single request, with a 32K max output. The architecture uses interleaved full global attention (10 layers) and sliding-window attention with a 512-token window (30 layers), which keeps inference efficient while maintaining reasonable long-range coherence.

Public Benchmark Scores

All Laguna XS 2.1 benchmarking used the Laude Institute's Harbor Framework with Poolside's agent harness, max 500 steps, sandboxed execution, thinking enabled, 256K context. Scores are mean pass@1 averaged over multiple attempts per task. Source: Poolside and NVIDIA published materials. Not Benchgen measurements.

Laguna XS 2.1 vs Alternatives

At 33B/3B, Laguna XS 2.1 is the clear choice for local or constrained-budget deployments where the DGX Spark or equivalent single-node hardware is the constraint — it achieves SWE-bench Verified parity with models 10× its active size, at near-zero inference cost.

How Laguna XS 2.1 Performs on Real Agent Tasks

The 70.9% SWE-bench Verified score is notable for a model with only 3B active parameters: it matches or beats models with 4–10× more active compute on standard coding agent benchmarks. The training methodology — RL inside Poolside's own agent harness across thousands of real environments — produces a model tuned for the "way of working" that matters for unattended agents: verification, persistence, and not declaring victory prematurely. Poolside published full trajectories from its Laguna M.1/XS.2 evaluation at trajectories.poolside.ai, a transparency standard rare among labs of any size.

What the headline numbers don't capture is harness sensitivity. Laguna XS 2.1 is explicitly optimised for Poolside's own pool harness; teams running it under a different agent scaffold (different tool schemas, prompt formats, or step limits) should expect some performance degradation relative to published numbers. The Terminal-Bench 2.0 score of 37.5% suggests the model is not yet at frontier level for long-horizon terminal work specifically — the larger Laguna S 2.1 (70.2% on TB 2.1) is the better pick for that workload.

Use Laguna XS 2.1 via Transformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

model_id = "poolside/Laguna-XS-2.1"

tokenizer = AutoTokenizer.from_pretrained(model_id)
model = AutoModelForCausalLM.from_pretrained(
    model_id,
    dtype=torch.bfloat16,
    device_map="auto",
)

messages = [{"role": "user", "content": "Write a Python retry wrapper with exponential backoff."}]

inputs = tokenizer.apply_chat_template(
    messages,
    add_generation_prompt=True,
    return_tensors="pt",
    enable_thinking=True,  # set False to skip chain-of-thought
).to(model.device)

outputs = model.generate(inputs, max_new_tokens=1024, do_sample=True, temperature=1.0, top_k=20)
print(tokenizer.decode(outputs[0][inputs.shape[-1]:], skip_special_tokens=True))

Or run locally with Ollama in a single command:

ollama run laguna-xs-2.1

Related Models & Benchmarks

• Compare Poolside family: Laguna S 2.1
• Benchmarks: SWE-bench Verified · SWE-bench Pro · Terminal Bench

Frequently Asked Questions

Specs and scores sourced from Poolside's HuggingFace model card and NVIDIA Build model card. Last updated 2026-07-23.