Laguna XS 2.1 is Poolside’s smallest and most accessible coding model. Released July 2, 2026, it has 33 billion total parameters with only 3B activated per token using a Mixture-of-Experts (MoE) architecture. It runs on a single consumer GPU, ships with open weights under an MIT-like license, and is free on OpenRouter right now.
This is the model for developers who want Poolside’s RLCEF training without API dependencies or enterprise pricing. Download the weights, run it locally with Ollama or LM Studio, and you have a coding assistant that works offline on your hardware.
Here is everything about XS 2.1: what changed from XS.2, the benchmarks, how it fits in the Laguna family, and how to run it locally.
What is Laguna XS 2.1?
XS 2.1 is the latest iteration in Poolside’s XS line of lightweight coding models. It sits at the bottom of the Laguna family:
| Model | Total params | Active params | License |
|---|---|---|---|
| Laguna XS 2.1 | 33B | 3B | MIT-like (open weights) |
| Laguna S 2.1 | 118B | ~11B | TBA |
| Laguna M.1 | 225B | 23B | Proprietary |
The XS line exists because not every coding task needs a 225B model. Most of what developers do day-to-day, writing functions, fixing bugs, generating tests, completing code, does not require massive parameter counts. XS 2.1 targets those tasks specifically.
What changed from XS.2
XS 2.1 builds on the same architecture as XS.2 (33B total, 3B active, MoE) with two key improvements:
Better terminal task performance. Terminal-Bench 2.1 score of 33.4%, which reflects stronger command-line reasoning, shell scripting, and CLI tool usage. If you use coding agents that execute terminal commands (like Poolside’s own pool agent), XS 2.1 handles those tasks more reliably than XS.2.
Higher multilingual coding score. SWE-bench Multilingual at 63.1%, up 5.4 percentage points from XS.2. This benchmark tests the model’s ability to solve real GitHub issues across multiple programming languages. The jump from 57.7% to 63.1% is significant for a model this size.
The context window stays at 262K tokens, which is enough for most codebases. If you need to analyze an entire monorepo at once, you will still need to chunk your input, but for typical development workflows, 262K handles it.
Benchmarks
| Benchmark | XS 2.1 | XS.2 |
|---|---|---|
| SWE-bench Multilingual | 63.1% | 57.7% |
| Terminal-Bench 2.1 | 33.4% | N/A |
| Context window | 262K | 262K |
The SWE-bench Multilingual number is the one that matters most for practical coding. It means XS 2.1 can solve roughly 6 out of 10 real-world GitHub issues across languages like Python, JavaScript, TypeScript, Java, Go, and Rust. That is competitive with models twice its size from just a year ago.
Terminal-Bench 2.1 is a newer benchmark that tests command-line proficiency. A 33.4% score means XS 2.1 can handle straightforward terminal tasks but still struggles with complex multi-step shell workflows. For heavy terminal work, the larger Laguna models (S 2.1 or M.1) are better choices.
RLCEF training
XS 2.1 uses the same RLCEF (Reinforcement Learning from Code Execution Feedback) training as the rest of the Laguna family. For the full technical breakdown, see our What is Poolside AI overview.
The short version: during training, the model generates code, that code gets executed in sandboxes, and the execution results (pass/fail, output correctness, error messages) become reward signals. This is different from standard supervised training on static code repositories. The model learns what code does, not just what it looks like.
For XS 2.1 specifically, RLCEF training means:
- Code is more likely to run on the first try
- Error handling is more robust (the model has seen what happens when it is missing)
- Debugging suggestions are more accurate (the model has seen the relationship between errors and code patterns)
- Generated tests actually catch real bugs
This training approach is why a 3B active parameter model can compete with much larger general-purpose models on coding tasks. The training signal is higher quality because it comes from actual execution, not human labeling.
Running XS 2.1 locally
This is the main reason to pick XS 2.1 over M.1. The open weights and 3B active parameter count mean it runs on consumer hardware.
Hardware requirements
- GPU with 8GB+ VRAM for comfortable inference (6GB is the bare minimum with quantization)
- 16GB+ system RAM recommended
- Single GPU is all you need
For a detailed breakdown of VRAM requirements across AI models, see our How Much VRAM for AI guide.
Ollama (recommended)
The easiest way to run XS 2.1 locally. If you do not have Ollama installed, see our Ollama Complete Guide.
ollama run poolside/laguna-xs-2.1That is it. Ollama handles downloading the weights, setting up the inference engine, and providing a chat interface. The model is available in the Ollama library under the poolside/laguna-xs-2.1 tag.
For programmatic access:
import requests
response = requests.post("http://localhost:11434/api/generate", json={
"model": "poolside/laguna-xs-2.1",
"prompt": "Write a Python function that implements binary search on a sorted array.",
"stream": False
})
print(response.json()["response"])LM Studio
Download LM Studio, search for “poolside/laguna-xs-2.1” in the model browser, download the GGUF version that matches your VRAM, and start chatting. LM Studio provides a GUI and an OpenAI-compatible local API server.
For a full walkthrough, see our LM Studio Complete Guide.
Other options
Any tool that supports GGUF or HuggingFace model loading can run XS 2.1:
- vLLM: For high-throughput serving
- llama.cpp: For CPU inference or low-VRAM setups
- Hugging Face Transformers: For research and fine-tuning
How to use XS 2.1 via OpenRouter
If you prefer not to run locally, XS 2.1 is free on OpenRouter:
import openai
client = openai.OpenAI(
base_url="https://openrouter.ai/api/v1",
api_key="your-openrouter-key"
)
response = client.chat.completions.create(
model="poolside/laguna-xs-2.1",
messages=[
{"role": "system", "content": "You are an expert software engineer."},
{"role": "user", "content": "Write a TypeScript function that debounces an async function with a leading edge option."}
]
)
print(response.choices[0].message.content)For more on OpenRouter setup, see our OpenRouter Complete Guide.
XS 2.1 vs other small coding models
vs. DeepSeek V4 (local)
DeepSeek V4 is a much larger model (685B total, 37B active) that can also run locally with enough hardware. XS 2.1 is a fraction of the size and runs on a single consumer GPU. DeepSeek V4 is more capable for complex tasks but requires serious hardware. XS 2.1 wins on accessibility. See our Best Open Source Coding Models 2026 for more comparisons.
vs. Codestral 22B
Mistral’s Codestral is a 22B dense model (not MoE) with strong coding performance. It runs on similar hardware to XS 2.1. The key difference is training: Codestral uses standard supervised training, while XS 2.1 uses RLCEF. For first-pass correctness on code generation, XS 2.1 may have an edge. For tasks that benefit from a dense architecture (no routing overhead), Codestral may be faster.
vs. Qwen 3.6
Qwen 3.6 is Alibaba’s latest coding-capable model. It is general-purpose, not coding-specific. For pure coding tasks, XS 2.1’s specialized training gives it an advantage. For mixed tasks that include documentation, explanation, or non-coding reasoning, Qwen 3.6 is more versatile.
vs. Laguna M.1
M.1 is Poolside’s flagship. It is significantly more capable for complex tasks (multi-file refactoring, architectural decisions, debugging subtle issues) but requires API access and cannot run locally. Use M.1 for heavy lifting, XS 2.1 for quick iterations and local workflows. Many developers use both. See our Laguna M.1 Complete Guide for details.
Best use cases
XS 2.1 excels at tasks that match its size and training:
Code completion. Typing a function signature and letting XS 2.1 fill in the body. This is where the 3B active parameters shine, fast inference, good quality, low resource usage.
Function generation. Describing what a function should do and getting working code back. RLCEF training means the generated code is more likely to work on the first try.
Bug fixes. Paste an error message and relevant code, get a fix. The model’s execution-aware training helps it understand what went wrong.
Test generation. Writing unit tests for existing functions. XS 2.1 generates tests that cover common edge cases because it has been trained on the relationship between code and test outcomes.
Quick refactors. Renaming variables, extracting functions, changing code style. Tasks that do not require understanding the entire codebase architecture.
Limitations
Small active parameter count. At 3B active parameters, XS 2.1 cannot match larger models on complex reasoning, multi-file refactoring, or architectural decisions. It is a specialist, not a generalist.
Terminal task performance. The 33.4% Terminal-Bench 2.1 score means complex shell workflows still challenge this model. For heavy terminal automation, step up to S 2.1 or M.1.
No multimodal support. XS 2.1 is text-in, text-out. It cannot process images, diagrams, or other non-text inputs.
Context window limits. While 262K tokens is generous, very large codebases still require chunking. The model does not have infinite memory.
The Laguna family: choosing the right model
| Use case | Model |
|---|---|
| Local development, quick tasks, offline work | XS 2.1 |
| Medium complexity, still open weights | S 2.1 |
| Complex refactoring, architectural decisions, production quality | M.1 |
| Enterprise, API-only, maximum capability | M.1 via Bedrock |
If you are starting with Poolside, try XS 2.1 first. It is free, runs locally, and gives you a feel for RLCEF-trained models. If you find yourself hitting its limits, move up to M.1 on OpenRouter (also free, for now). For most day-to-day coding, XS 2.1 is enough.
For a broader look at running AI models locally, see our Best AI Models for Coding Locally 2026 roundup.
FAQ
Is Laguna XS 2.1 free?
Yes. XS 2.1 is free on OpenRouter, and the weights are available on HuggingFace under an MIT-like license. You can download, run, fine-tune, and deploy it commercially without paying Poolside anything. OpenRouter access is free with standard rate limits.
Can I run Laguna XS 2.1 on my laptop?
If your laptop has a GPU with at least 6GB VRAM (8GB recommended), yes. Apple Silicon Macs with 16GB+ unified memory work well. The model runs comfortably on a single consumer GPU thanks to the 3B active parameter count. Use Ollama for the simplest setup.
How does XS 2.1 compare to XS.2?
XS 2.1 scores 63.1% on SWE-bench Multilingual (up from 57.7% on XS.2) and adds a Terminal-Bench 2.1 score of 33.4%. The architecture and parameter counts are the same (33B total, 3B active, 262K context). The improvements come from better training, not a bigger model. If you are using XS.2, upgrading to XS 2.1 is a no-brainer.
What license is Laguna XS 2.1 released under?
An MIT-like permissive license. The weights are open on HuggingFace. You can use the model for commercial purposes, fine-tune it, and redistribute it. This is the same licensing approach as XS.2 (which used Apache 2.0).
Should I use XS 2.1 or M.1?
XS 2.1 for local development, quick tasks, and offline work. M.1 for complex tasks that need more capability (multi-file refactoring, debugging subtle issues, architectural decisions). M.1 requires API access and cannot run locally. Many developers use both: XS 2.1 for fast iterations, M.1 for heavy lifting.