TL;DR: Poolside’s Laguna S 2.1 (118B MoE, July 21) posts frontier-class agentic coding scores — 78.5% SWE-bench Multilingual — but its Q4_K_M GGUF alone is ~71.7GB, so no single consumer GPU holds it. Laguna XS 2.1 (33B MoE, July 2) scores 63.1%, ships as a 20GB Ollama tag, and runs fast on one 24GB card. Most home labs should run XS and stop there.

	Laguna XS 2.1 on a 24GB card	Laguna S 2.1, expert offload	Laguna S 2.1, full memory
Best for	Daily local coding agent on one GPU	Trying the 118B on hardware you already own	Running S 2.1 at real agent speed
Hardware	Used RTX 3090 (~$1,050) or RTX 4090	12–24GB GPU + 64GB+ system RAM	96GB VRAM, or 128GB unified memory
What you get	20GB Q4_K_M, 256K context, one ollama run	~23 tok/s measured on an RTX 3060 12GB	Q4 weights fully resident, 1M context ceiling
The catch	63.1% SWE-bench Multilingual, not 78.5%	Prefill and long-context speed suffer most	That’s $4,000+ of hardware for one model

Honest take: Run XS 2.1. It is the best coding model per gigabyte of VRAM you can pull with one Ollama command today, and S 2.1’s extra 15 benchmark points mostly measure a harness you won’t be using — if you need frontier-level agentic coding, the API tier is cheaper than 96GB of hardware.

Poolside shipped two open-weight coding models three weeks apart this July, both under the OpenMDW-1.1 license — the same permissive weights-plus-data license NVIDIA used for Nemotron 3. The headlines belong to the big one: Laguna S 2.1, a 118-billion-parameter Mixture-of-Experts model that Poolside says beats open models several times its size on agentic coding. The download stats will belong to the small one. Here is the hardware math for both, with the vendor claims separated from what’s been independently measured.

What Poolside actually shipped

Laguna XS 2.1 landed July 2, 2026. It’s a 33B-total MoE that activates ~3B parameters per token, built from 40 layers and 256 experts, with a 262,144-token (256K) context window. Per Poolside’s announcement, it improves SWE-bench Multilingual by 5.4 points over the earlier XS.2, to 63.1%, and scores 33.4% on Terminal-Bench 2.1. Weights ship in BF16, FP8, NVFP4, and INT4, with official GGUF and MLX conversions and support in vLLM, SGLang, TensorRT-LLM, Ollama, and llama.cpp.

Laguna S 2.1 followed on July 21, 2026. It’s a 118B-total MoE activating ~8B parameters per token (256 experts, top-10 routing plus a shared expert), with a context window up to 1M tokens. Poolside notes it’s their first model whose reinforcement-learning stage ran entirely in FP8. With thinking enabled, Poolside reports 78.5% on SWE-bench Multilingual — a hair above Qwen 3.7 Max’s 78.3% — plus 70.2% on Terminal-Bench 2.1 and 59.4% on SWE-bench Pro’s public set.

Two flags on those S 2.1 numbers before you budget hardware around them. First, Airstreet’s analysis and The Decoder’s coverage both note Poolside’s comparison methodology takes the maximum of vendor self-reported scores, leaderboard figures, and third-party numbers for competitors — and on DeepSWE, Poolside ran its own agent harness rather than the leaderboard-standard mini-swe-agent, which the company acknowledges makes scores less directly comparable. Second, early third-party testing found the model can overfit to Poolside’s own harness: it may drift from required formats under slightly different tool schemas, mangle JSON in nested tool arguments, and overthink on competition math. It’s a strong model. It is not 15 points better than XS 2.1 in your agent until someone shows that in your agent’s harness.

The VRAM math, model by model

XS 2.1: the 24GB sweet spot

The Ollama library’s default laguna-xs-2.1 tag is Q4_K_M at 20GB (the NVFP4 tag is 19GB; q8_0, f16, mxfp8, and mlx-bf16 tags also exist). A 20GB quant plus KV cache fits a 24GB card with room for real context — the same single-card logic we walked through for running big models on 24GB, except here nothing needs to spill.

One command gets you running:

$ ollama run laguna-xs-2.1
pulling manifest
pulling model layers... 100% ▕████████████████▏  20 GB
verifying sha256 digest
success
>>> Write a pytest fixture that spins up a temp SQLite db

Then confirm the whole thing is resident on the GPU — if ollama ps shows anything other than 100% GPU, you’re on an 8–16GB card and it’s spilling to system RAM:

$ ollama ps
NAME                    SIZE     PROCESSOR    UNTIL
laguna-xs-2.1:latest    22 GB    100% GPU     4 minutes from now

Because only ~3B parameters activate per token, decode speed looks like a small model even though capability doesn’t. The most detailed public benchmark so far is Lucebox’s RTX 3090 run: 296 tok/s peak at short context, holding 152 tok/s at the full 256K, with prefill at ~3,500 tok/s — on a used card that averages about $1,050 on eBay this summer (active asking prices run $1,200–$1,299 per ResalePrices). That run used an optimized llama.cpp stack including Poolside’s DFlash draft models for speculative decoding, so treat it as a ceiling, not a default — a stock ollama run will land lower. Even at half those numbers, XS 2.1 on a 3090 is decisively faster than you can read, and fast enough that agentic multi-step loops don’t feel like waiting. (If you want the background on why draft models buy MoE this much, we covered it in the speculative decoding setup guide.)

On paper XS 2.1 also runs on 16GB cards via the NVFP4/INT4 checkpoints or a smaller GGUF, but you give up context headroom — and 256K context is half the reason this model is interesting for agent work.

S 2.1: no consumer card holds it, but offload is surprisingly livable

The Q4_K_M GGUF of Laguna S 2.1 is ~71.7GB on disk, and WillItRunAI’s compatibility sheet puts practical VRAM need around 74GB once KV cache is on top. Guides recommending comfortable full-GPU setups land at 96GB of VRAM or 128GB of unified memory. Nothing with a single consumer power connector does that: the biggest consumer card, the RTX 5090, has 32GB.

The saving grace is the same MoE property that makes every 2026 frontier-at-home story possible: expert tensors are sparse, so pushing them to system RAM costs far less speed than offloading a dense model’s layers. Three verified reference points:

Setup	VRAM used	Measured speed	Source
RTX 3060 12GB + experts in RAM	10.1 GB	~23 tok/s	VRAMCalculator community bench
24GB card + 64GB RAM, --n-cpu-moe 40	under 24 GB	”most of the speed” per Unsloth’s guidance	HF discussion
Single RTX 5090 32GB + offload	32 GB ceiling	community recipe, no controlled numbers yet	GitHub gist

The llama.cpp incantation for the middle row looks like this:

$ llama-server -m Laguna-S-2.1-Q4_K_M.gguf --n-cpu-moe 40 -ngl 99 -c 32768

-ngl 99 keeps attention and shared layers on the GPU; --n-cpu-moe 40 sends the routed experts of all 40 layers to system RAM. If you hit cudaMalloc failed: out of memory during load on a 24GB card, that flag — not a smaller quant — is the first fix: dropping from Q4_K_M to Q3 costs accuracy permanently, while expert offload costs speed you may barely notice at ~8B active parameters. The real tax shows up in prefill and long-context work, where activations cross the PCIe bus constantly; a 23 tok/s decode on an RTX 3060 is genuinely usable for chat-style coding, but feeding it a 200K-token repo dump will test your patience.

And that’s the config where 64GB of system RAM becomes the cheapest upgrade in your build — the same conclusion as our system RAM guide, now with a 118B reason.

The unified-memory path

128GB unified-memory machines — Strix Halo boxes like the GMKtec EVO-X2, or a Mac with enough RAM — hold the whole Q4 without offload. Bandwidth, not capacity, then sets the speed: at 256 GB/s and ~8B active parameters you should expect the same “capacity over velocity” trade we measured when the EVO-X2 ran Qwen3-235B at ~11 tok/s. Mind the pricing before building around this: unified-memory machines took a ~75% price jump this summer, which moves the break-even math toward the used-GPU column.

XS 2.1 against the other one-card coding models

The 24GB coding-model shelf is crowded in 2026. Where Laguna XS 2.1 slots in:

• Qwen3-Coder-Next remains the agentic benchmark leader among things a 24GB card can hold, but Laguna XS 2.1’s 256K context on-card and its 3B-active speed profile make it the better long-session agent when your task is mostly editing across a big repo rather than one hard algorithmic problem.
• GPT-OSS 20B is still the raw-speed pick (225 tok/s on an RTX 4090 in our guide) and leaves more free VRAM, but it’s a generalist with a 128K window — XS 2.1 is trained specifically for the terminal-and-tools loop.
• Devstral Small 2 is dense, so at equal quality thresholds it’s slower per token on the same card; its advantage is predictable behavior in harnesses tuned for Mistral-family models.

If your interest is the coding tools side — which agent harness to point at a local endpoint — our sister site covers that beat in depth at aicoderscope.com.

One more consideration for the license-sensitive: OpenMDW-1.1 covers weights, and Poolside published the full quant ladder (BF16/FP8/NVFP4/INT4 plus GGUF/MLX) itself on day one. No waiting for community conversions, no license-by-vibes — a welcome contrast to the FLUX-style license fine print that keeps tripping people up in image land.

Should anyone actually run S 2.1 at home?

The case for: it’s arguably the strongest open-weight agentic coder per active parameter right now, the 1M context ceiling is real, and expert offload means “runs on my 12GB card” is technically true at ~23 tok/s.

The case against is the one we keep landing on for 100B+ MoEs, from Kimi K2.7 to MiniMax M3: the hardware that runs it well costs more than years of API access, and the hardware you already own runs it at speeds that make agentic loops — dozens of model calls per task — painful. An agent that needs 40 turns at 23 tok/s with slow prefill is a coffee break per task. XS 2.1 at 100+ tok/s on a $1,050 card is the version of this model family that actually changes your daily workflow.

So: pull laguna-xs-2.1 today; benchmark S 2.1 through the API or a RunPod rental before committing a single dollar of hardware to it. If S 2.1 clears your harness — not Poolside’s — at quality that XS can’t match, the 96GB conversation is worth having. Not before.

FAQ

What GPU do I need for Laguna XS 2.1? A 24GB card (used RTX 3090, RTX 4090) runs the default 20GB Q4_K_M Ollama tag with full 256K context headroom. 16GB cards work with the 19GB NVFP4 checkpoint or smaller GGUFs at reduced context.

Can Laguna S 2.1 run on a single consumer GPU? Not fully in VRAM — the Q4_K_M GGUF is ~71.7GB. With llama.cpp’s --n-cpu-moe expert offload and 64GB+ of system RAM it runs on cards as small as 12GB; a community benchmark measured ~23 tok/s on an RTX 3060 using 10.1GB of VRAM.

How fast is Laguna XS 2.1 on an RTX 3090? The best published run (optimized llama.cpp with DFlash draft models) hit 296 tok/s peak and 152 tok/s at full 256K context. Stock Ollama setups will be slower; expect well above reading speed regardless.

Is Laguna S 2.1 really better than Qwen 3.7 Max at coding? On Poolside’s own SWE-bench Multilingual comparison, marginally (78.5% vs 78.3%) — but their methodology takes the max of competitors’ scores from mixed sources, and third-party testing found harness-overfit quirks. Treat it as “same tier,” not “beats.”

What license are the Laguna models under? OpenMDW-1.1, a permissive open-model license that allows commercial use, fine-tuning, and redistribution.

Recommended Gear

• NVIDIA RTX 3090 (used, 24GB) — the price/performance pick for XS 2.1
• NVIDIA RTX 3060 12GB — the proven minimum for S 2.1 expert-offload experiments

Sources

• Introducing Laguna XS 2.1 — Poolside
• Introducing Laguna S 2.1 — Poolside
• Poolside Releases Laguna S 2.1 — MarkTechPost
• Poolside’s Laguna S 2.1: the model factory delivers — Air Street Press
• Poolside’s Laguna S 2.1 punches above its size — The Decoder
• laguna-xs-2.1 — Ollama Library
• Laguna XS 2.1 33B on an RTX 3090: 296 tok/s peak, 152 tok/s at 256K — Lucebox
• Laguna S 2.1 VRAM Requirements (71.7GB Q4_K_M) — WillItRunAI
• Laguna S 2.1 on an RTX 3060 12GB via CPU offload — VRAMCalculator
• GPU allocation for 24GB VRAM — unsloth/Laguna-S-2.1-GGUF discussion, Hugging Face
• How to Run Laguna S 2.1 Locally — AIMadeTools
• RTX 3090 Price Tracker US — Best Value GPU
• RTX 3090 Used GPU Fair Asking Range — ResalePrices

Last updated August 2, 2026. Prices and specs change; verify current rates before purchasing.