How to Run Laguna XS 2.1 on Ollama: Local Setup Guide (2026)

What Laguna XS 2.1 Is and Which Tag to Run

Laguna XS 2.1 is Poolside's second update to its XS line, released July 2, 2026, and built for agentic coding and long-horizon work you can run entirely on your own hardware. It is a mixture-of-experts model: 33 billion total parameters spread across 256 experts plus one shared expert, but only about 3 billion parameters activate for any given token. Ollama still has to hold the full 33 billion parameters, at whichever quantization tag you pick, in memory before inference starts, so the RAM and VRAM requirements reflect the full model, not the smaller active portion.

The attention design underneath is worth understanding before you choose a tag. Of the model's 40 transformer layers, only 10 use full global attention across the entire context. The remaining 30 use a 512-token sliding window instead, and the key-value cache is quantized to FP8 by default. Together, those choices let Laguna XS 2.1 hold a 262,144-token (256K) context window without the memory growth a dense model of the same size and context would cause. Poolside trained the model with the Muon optimizer and licenses it under OpenMDW-1.1, a permissive license distinct from a standard MIT or Apache 2.0 grant, so check the exact terms before shipping a commercial product built on it.

On Ollama's library, the `laguna-xs-2.1` tag holds three real quantizations:

The plain `laguna-xs-2.1` tag and the explicit `q4_K_M` tag point at the identical 20GB download. Poolside says this release is a direct upgrade over its predecessor, Laguna XS.2, which shares the same 33B/3B architecture but caps out at a 131,072-token (128K) context window. Laguna XS 2.1 doubles that to 256K and adds a 5.4 percentage point jump on SWE-bench Multilingual, among other gains covered in the benchmarks section below.

Install Ollama and Run Your First Laguna XS 2.1 Prompt

Getting Laguna XS 2.1 running takes about ten minutes on a normal connection, most of it spent downloading the 20GB default tag.

Step 1: Install Ollama

# Linux and macOS, one-command installer
curl -fsSL https://ollama.com/install.sh | sh

On Windows, download the installer from ollama.com/download, or use winget:

winget install Ollama.Ollama

Confirm Ollama is on its latest release, since Laguna XS 2.1 was added recently:

ollama --version

Step 2: Pull and Run laguna-xs-2.1

The plain tag pulls the 20GB q4_K_M build, a reasonable starting point for a single 24GB GPU:

ollama run laguna-xs-2.1

Expected output on first run:

pulling manifest
pulling 4f9a2c18... 100% ▕████████████████▏ 20 GB
pulling tokenizer...   100% ▕████████████████▏ 3.8 MB
success
>>> Send a message (/? for help)

Step 3: Send a Test Prompt

>>> Write a Python function that finds the longest palindromic substring, then explain its time complexity.

Laguna XS 2.1 streams its response once the model finishes loading. The first load takes longer than repeat calls, since Ollama caches the loaded weights afterward.

Step 4: Pull a Larger Tag

If you have the VRAM to spare and want output closer to full precision, pull `q8_0` or `bf16` instead:

# 36GB, needs 40GB+ combined RAM/VRAM
ollama pull laguna-xs-2.1:q8_0

# 67GB, needs 72GB+ combined RAM/VRAM
ollama pull laguna-xs-2.1:bf16

Use Laguna XS 2.1 for Agentic Coding Tasks

Poolside built Laguna XS 2.1 specifically for agentic coding: multi-step tasks where a model edits files, runs commands, and iterates on its own output rather than answering a single prompt. Its published benchmark numbers reflect that design goal directly.

Poolside ran these evaluations using the Laude Institute's Harbor framework combined with its own open-source agent harness, `pool`, capped at 500 steps per task with sandboxed execution. Poolside's own comparison chart also benchmarks against North Mini Code, MAI-Code-1-Flash, gpt-oss-120b, and GPT-5.4 Nano, though the four models above are the ones Poolside quotes exact figures for across the full table. Qwen3.6-35B-A3B leads on three of the four listed benchmarks, most clearly on Terminal-Bench 2.0 (51.5% versus 37.5%), and it is worth being direct about that instead of only showing the numbers where Laguna wins. Where Laguna XS 2.1 does lead is against its own predecessor across every metric, and against Claude Haiku 4.5 on SWE-bench Pro and Terminal-Bench 2.0, both of which measure longer, more autonomous task sequences rather than single-file bug fixes.

Connect an Agent Framework via the OpenAI-Compatible Endpoint

Ollama exposes Laguna XS 2.1 through the same OpenAI-compatible API used by Hermes Agent and OpenClaw, at `http://localhost:11434/v1`:

from openai import OpenAI

client = OpenAI(base_url="http://localhost:11434/v1", api_key="ollama")

response = client.chat.completions.create(
    model="laguna-xs-2.1",
    messages=[{"role": "user", "content": "Refactor this function to remove the nested loop, then add type hints."}],
)
print(response.choices[0].message.content)

Point any agent framework's model configuration at `laguna-xs-2.1`, `laguna-xs-2.1:q8_0`, or `laguna-xs-2.1:bf16` and it runs with no other changes needed.

Faster Inference with DFlash Speculator Models

Alongside each XS 2.1 checkpoint, Poolside separately released draft models under the DFlash name, built specifically for speculative decoding. In its release announcement, Poolside states these roughly double achieved tokens per second on engines that support loading a matching draft model. As of this writing, Ollama's official `laguna-xs-2.1` tags do not document DFlash draft-model loading, so the speedup applies to inference engines like vLLM that support pairing a separate speculator checkpoint, not to a default `ollama run` session.

Configure Context Length and Check llama.cpp Compatibility

Laguna XS 2.1's 262,144-token context window is more than most local coding sessions need, and lowering it with a Modelfile reduces KV cache memory even with FP8 quantization already applied.

Create a Custom Modelfile

FROM laguna-xs-2.1
PARAMETER num_ctx 65536
SYSTEM "You are a coding assistant. Make one change at a time and explain your reasoning before editing."

Build and run it:

ollama create my-laguna -f Modelfile
ollama run my-laguna

llama.cpp Compatibility Status

If you use raw llama.cpp directly instead of Ollama, mainline support for Laguna XS 2.1 is not merged yet. Poolside's model card states support "requires building llama.cpp from the upstream PR that adds Laguna XS 2.1 support until it lands," and the company's announcement describes llama.cpp support as "coming soon."

This does not affect Ollama users. Ollama ships its own bundled inference engine, and the tags on ollama.com/library/laguna-xs-2.1 already work today with a plain `ollama pull` or `ollama run`, independent of when the upstream llama.cpp pull request merges.

Run Laguna XS 2.1 with Open WebUI

For a chat interface instead of the terminal, Open WebUI detects every locally pulled Ollama model automatically, including all `laguna-xs-2.1` tags, with no extra configuration needed.

Troubleshooting

Frequently Asked Questions