Laguna XS 2.1 as a Local Cursor and Cline Backend in 2026: Free Weights on a 24GB GPU — and What 'Beats Claude Haiku' Actually Means

By AICoderScope Team · 11 min read
lagunapoolsidelocal-llmollamacursorclinebyoksetup-guideai

TL;DR: Poolside released Laguna XS 2.1 on July 2, 2026 — a 33B MoE coding model with 3B active parameters, 256K context, and an OpenMDW-1.1 license that’s commercially clean. The default Ollama quant is 20GB and fits a 24GB GPU. It beats Claude Haiku 4.5 on SWE-bench Pro (47.6% vs 39%) but trails it on SWE-bench Verified (70.9% vs 73.3%).

Laguna XS 2.1 (local)Laguna XS 2.1 (OpenRouter free)Claude Haiku 4.5 (API)
Best forPrivacy-first agentic coding on a 24GB cardTrying the model before downloading 20GBFastest cheap cloud backend that stays ahead on Verified
Price / Cost$0/token after the GPU you may already own$0, capped at 20 req/min, 200 req/day$1 in / $5 out per million tokens
The catchKV cache eats the 4GB of headroom fastYour prompts can be used for trainingYour code transits Anthropic’s cloud, and agent sessions add up

Honest take: If you have a 24GB GPU, Laguna XS 2.1 is the best free coding model you can run on it today — it replaces cloud Haiku for long agentic sessions where the harder-benchmark win actually matters. If you don’t own the hardware, don’t buy it for this: Haiku 4.5 still wins single-shot fix quality, and the OpenRouter free tier covers evaluation.

What Poolside shipped on July 2

Laguna XS 2.1 landed on July 2, 2026 as a free download on Hugging Face and OpenRouter, announced in Poolside’s release post. The spec sheet, cross-checked against the model card, the Ollama library entry, and NVIDIA’s build.nvidia.com model card:

  • Architecture: Mixture-of-Experts, 33B total parameters, 3B activated per token
  • Context: 256K tokens (262,144), up to 32K output on hosted endpoints
  • License: OpenMDW-1.1 — the Linux Foundation’s permissive model-weights license
  • Quantizations: q4_K_M (20GB, the Ollama default), q8_0, and a native nvfp4 build for Blackwell cards
  • Inference support: vLLM, SGLang, TensorRT-LLM, Hugging Face transformers, Ollama, llama.cpp

Two things make this release different from the usual open-weights drop. First, the license: OpenMDW-1.1 is the same framework NVIDIA adopted for its Cosmos, Isaac GR00T, and Nemotron families. It is permissive by default — use, modify, redistribute, deploy commercially — with the only substantive condition being preservation of the license text and origin notices. Using XS 2.1 as your Cursor or Cline backend for paid client work is unambiguously permitted, which was never quite settled under the custom community licenses some competitors ship.

Second, the deadline attached to it. Poolside retired the predecessor, Laguna XS.2, from its own API and OpenRouter on July 9, 2026 — one week after the 2.1 launch, per TechTimes’ coverage. XS.2 survives only as a Baseten dedicated deployment for teams on private infrastructure. If anything in your config still says laguna-xs.2, it stopped working three weeks ago.

The benchmark claim, taken apart

The headline circulating on Hacker News and r/ChatGPTCoding is “free 33B model beats Claude Haiku.” That’s true on exactly one benchmark and false on another, and the split matters for how you should use it.

BenchmarkLaguna XS 2.1Laguna XS.2Claude Haiku 4.5
SWE-bench Verified70.9%69.9%73.3%
SWE-bench Multilingual63.1%57.7%not published
SWE-bench Pro47.6%—39%
Terminal-Bench 2.037.5%—not published

Sources: Poolside’s release post and model card for the Laguna numbers; Anthropic’s Haiku 4.5 announcement for the 73.3% Verified score; VentureBeat’s DeepSWE leaderboard analysis for Haiku’s 39% on SWE-bench Pro.

Read the table twice. On SWE-bench Verified — the older, easier, most-quoted suite — Haiku 4.5 is still 2.4 points ahead. On SWE-bench Pro, the harder set built to resist contamination, Laguna XS 2.1 is 8.6 points ahead. The most defensible interpretation: Verified is saturating, and Pro rewards the long-horizon agentic behavior Poolside says it trained for. A model that wins the harder benchmark while losing the easier one is usually the model that generalizes better to your actual repository — but “usually” is doing work in that sentence, and if your workflow is short single-file fixes, Haiku’s Verified edge is the number that describes your workload.

The 63.1% on SWE-bench Multilingual (up 5.4 points over XS.2) is the quiet win. If you write Go, Rust, or PHP rather than the Python that dominates Verified, that’s the score to watch — few models publish it at all.

Local setup: Ollama in three commands

Tested pattern below; version numbers matter. The default tag is the q4_K_M quant at 20GB:

$ ollama pull laguna-xs-2.1
pulling manifest
pulling ... 100% ▕████████████████▏  20 GB
verifying sha256 digest
success

$ ollama show laguna-xs-2.1
  Model
    parameters          33B
    context length      262144
    quantization        Q4_K_M

Then wire it into your tools:

Cline: Settings → API Provider → Ollama, base URL http://localhost:11434, model laguna-xs-2.1. Cline’s OpenAI-compatible provider pointed at http://localhost:11434/v1 also works if you need custom headers.

Cursor: local models go through the OpenAI base-URL override, and the wiring has real caveats — Chat and Cmd+K work, Tab completion does not, and Cursor needs to reach your endpoint. The full walkthrough is in our Cursor + Ollama setup guide; everything there applies with the model name swapped to laguna-xs-2.1.

Claude Code: Ollama’s Anthropic-compatible endpoint runs it as a Claude Code backend — the one-command setup we documented in July works unchanged.

The problem you will actually hit: context headroom

Here’s the trap we ran into wiring this up, and it’s the same one that bites every big-model-on-24GB setup. The weights are 20GB. Your RTX 4090 or RTX 3090 has 24GB. That leaves roughly 4GB for the KV cache — and a 256K-token context does not fit in 4GB, no matter what the model card says the model supports.

Ollama makes this worse silently. Since the context-length change we documented in July, Ollama scales default context by total VRAM: a 24GB card lands in the 24–48GiB band and gets 32K — but a card the driver reports as just under 24GiB drops to the 4K default, which breaks Cline outright. And the ~4GB left after the weights caps what the card can genuinely hold: running Ornith-1.0’s 21.2GB quant on the same hardware, 2–3GB of headroom bought an 8K–16K working window, and Laguna’s extra gigabyte roughly doubles that — a 16K–32K range, not the 256K on the model card. Cranking num_ctx higher doesn’t crash — the cache spills into system RAM and generation crawls. That failure looks like “the model got slow after an hour” and is actually “you asked for more cache than the card holds.”

The working setup on a 24GB card: pin the context explicitly (OLLAMA_CONTEXT_LENGTH=32768, or num_ctx in the model settings) so you’re never at the mercy of the VRAM heuristic, watch for RAM spill on your first long session and step down to 16384 if generation slows, and let Cline’s context management compact long sessions into that window. If you genuinely need six-figure context, that’s what the API tier is for — or a bigger card, and at that point read runaihome.com’s Laguna hardware guide for the VRAM math across the whole Laguna family before spending anything.

On Apple silicon, the same 20GB quant runs on a Mac with 36GB of unified memory — the model and cache share one pool, so the headroom math is more forgiving, but so is your patience: MoE decode is fast, prompt processing on long contexts is where Macs fall behind discrete GPUs.

The cost math: free has three different meanings here

“Free” appears three times in this story and means three different things.

PathWhat it costsThe fine print
Local (Ollama, 24GB GPU)$0/token, electricity onlyHardware you own or buy; 16K–32K practical context ceiling
OpenRouter :free tier$020 requests/min, 200 requests/day; prompts may be used for training
Poolside API (paid)$0.10 in / $0.20 out per M tokensCache reads $0.05/M; full 256K context, no data-training clause
Claude Haiku 4.5, for comparison$1 in / $5 out per M tokens90% off cache reads; the Verified-benchmark leader of this group

The OpenRouter free tier’s 200-requests-per-day cap sounds generous until you watch Cline work: every file read, edit, and tool call in an agentic session is its own request, so a single mid-sized task burns through dozens. That’s a handful of real tasks a day — fine for evaluating the model, not a daily driver. And the training clause matters if the code is a client’s rather than yours; the local path exists precisely so that clause never applies.

Against Haiku, the paid Poolside API is a tenth the input price and a twenty-fifth the output price. Even if you never run the model locally, XS 2.1 at $0.10/$0.20 sits in the same cheap-backend bracket as DeepSeek V4-Flash at $0.14/$0.28 — and the choice between those two comes down to whether SWE-bench Pro (Laguna’s strength) or raw Verified throughput (DeepSeek’s) matches your work.

Where it actually fits in a 2026 stack

We’ve now covered enough local backends to place this one honestly. Ornith-1.0 35B, the other 24GB-class ~3B-active MoE, is its closest rival, and the comparison is closer than either vendor would like: Ornith’s DeepReinforce-reported 75.6 on SWE-bench Verified beats Laguna’s 70.9, but that number was vendor-only with no independent run when we covered it, while Poolside publishes across the harder suites — Pro, Multilingual, Terminal-Bench 2.0 — where contamination is harder to hide. Laguna’s 20GB quant also leaves about a gigabyte more KV headroom than Ornith’s 21.2GB on the same card, which translates directly into a longer usable context window. Against Inkling-Small, there’s no contest in either direction — Inkling-Small is a different weight class needing a 96GB card. And against the cloud, the rule stays what it has been all year: local wins when privacy, offline work, or marginal-cost-zero volume is the requirement; cloud wins when peak quality per prompt is.

The 3B-active MoE design is what makes this release land where it does. Dense 33B models on a 24GB card are miserable — quantized to fit, slow to decode. Activating 3B parameters per token means decode speed closer to a small model while keeping big-model breadth. That’s the same trade Inkling-Small makes at 8× the scale, and it’s clearly where local coding models are converging. If you’re assembling a fully open-source stack around weights like these, aifoss.dev tracks the FOSS tooling side of that build.

FAQ

Does the OpenMDW-1.1 license allow using Laguna XS 2.1 for commercial client work? Yes. OpenMDW-1.1 is permissive: use, modification, redistribution, and commercial deployment are all granted. The only conditions are preserving the license text and origin notices if you redistribute the weights. Running it as a BYOK backend for paid work requires nothing beyond that.

Will it run on a 16GB GPU? Not the default quant — 20GB of weights doesn’t fit 16GB of VRAM, and partial CPU offload on an MoE model costs more speed than most people will accept for agentic work. A 24GB card is the realistic floor; check the runaihome.com hardware guide before buying anything.

Is Laguna XS 2.1 better than Claude Haiku 4.5? On SWE-bench Pro, yes (47.6% vs 39%). On SWE-bench Verified, no (70.9% vs 73.3%). For long agentic sessions in Cline, the Pro number is the better predictor; for quick single-file edits, Haiku still wins — and it responds faster than any local setup.

What happened to Laguna XS.2? Poolside retired it from its API and OpenRouter on July 9, 2026, one week after XS 2.1 shipped. Existing configs pointing at laguna-xs.2 on hosted endpoints are dead; the local weights you already downloaded keep working forever — that’s the point of open weights.

Can I use the 256K context locally? Only with far more than 24GB of VRAM. On a 24GB card, 16K–32K is the practical ceiling before the KV cache spills to system RAM and generation slows to a crawl. The full 256K is realistic via the Poolside API or on multi-GPU rigs.

  • RTX 4090 — 24GB VRAM, the fastest single consumer card for the 20GB default quant
  • RTX 3090 — same 24GB capacity used, the budget path to running XS 2.1 locally

Sources

Last updated August 2, 2026. Pricing and features change frequently; verify current state before purchasing.

Was this article helpful?