Model reference · open weights

Laguna-XS-2.1

LLMs poolside Text gen 3 builds Open, with conditions 232k dl/mo

Laguna-XS-2.1 is an open-weight language model from poolside. Laguna-XS-2.1-GGUF (GGUF) weighs 20.3 GB; the smallest configuration that runs it is 2× RTX 3060 12 GB.

For self-hosting, compare this build's requirements below with the GPU you plan to rent.

  • Laguna-XS-2.1 is a 33B parameter Mixture-of-Experts model developed by poolside for agentic coding and long-horizon tasks.
  • It features 3B activated parameters per token, a 262,144-token context window, and native reasoning support.
  • The model is distributed under the OpenMDW-1.1 license and is available in GGUF format for local deployment.

Summary of the poolside/Laguna-XS-2.1-GGUF model card, 2026-10-01

What it is

Released bypoolside
Released2026-06-29
VRAM20.3 GB for the weights

What it runs on

Memory and cards for Laguna-XS-2.1-GGUF (GGUF)

20.3 GBweights, file size
651 MBruntime overhead, at least

How much memory each request adds isn't estimated yet for this architecture. The weights need at least the cards below, plus room for the context.

CardWeights alone
RTX 3060 12 GB … RTX 4060 Ti 16 GB
2 smaller cards
does not fit
RTX 3090 24 GBtight
RTX 4090 24 GBtight
RTX 5090 32 GBfits
L40S 48 GBfits
A100 80 GBfits
H100 80 GBfits
RTX PRO 6000 Blackwell 96 GBfits
DGX Spark (GB10) 128 GB unifiedfits
H200 141 GBfits
B200 180 GBfits
2× RTX 3060 12 GB
split by layers (llama.cpp)
tight
2× RTX 4060 Ti 16 GB
split by layers (llama.cpp)
fits
2× RTX 4090 24 GB
split by layers (llama.cpp)
fits
2× RTX 3090 24 GB
split by layers (llama.cpp)
fits

Builds

Sizes, precisions & builds

BuildParamsPrecisionWeightsSmallest setup
Laguna-XS-2.1-GGUF (above) ↗
2 builds: Q4_K_M 20.3 GB … BF16 66.9 GB
GGUF 20.3 GB2× RTX 3060 12 GB
Laguna-XS-2.1-NVFP4 ↗ 33.4BNVFP4 21.6 GBRTX 4090 24 GB
Laguna-XS-2.1 ↗ 33.4BBF16 66.9 GBH100 80 GB

From the model card

What poolside says about Laguna-XS-2.1

Read the model card

Laguna XS 2.1 is a 33B total parameter Mixture-of-Experts model with 3B activated parameters per token designed for agentic coding and long-horizon work on a local machine. This model is an upgraded version of our Laguna XS.2 model with a +5.4% jump on SWE-bench Multilingual as well as stronger performance on terminal-style tasks.

[!NOTE] This repository contains official GGUF conversions from our standard format release built for llama.cpp (and compatible with vLLM and SGLang). To use with Ollama, pull directly with ollama pull laguna-xs-2.1.

llama.cpp support is not yet upstreamed. See below.

Highlights

  • Mixed SWA and global attention layout: Laguna XS 2.1 uses sigmoid gating with per-layer rotary scales, enabling mixed SWA (Sliding Window Attention) and global attention layers in a 3:1 ratio (across 40 total layers)
  • KV cache in FP8: KV cache quantized to FP8, reducing memory per token
  • Native reasoning support: Interleaved thinking between tool calls with support for enabling and disabling thinking per-request
  • Local-ready: At 33B total parameters and 3B activated, Laguna XS 2.1 is compact enough to run on a Mac with 36 GB of RAM. Available on Ollama and llama.cpp. High-quality FP8, NVFP4 and INT4 quantized variants available (see the collection)
  • OpenMDW-1.1 license: Use and modify the model and associated materials freely for commercial and non-commercial purposes (learn more about OpenMDW)

Model overview

  • Training: pre-training, post-training and reinforcement learning stages
  • Number of parameters: 33B total with 3B activated per token
  • Optimizer: Muon
  • Layers: 40 layers (10 layers with global attention, 30 layers with sliding window attention)
  • Experts: 256 experts with 1 shared expert
  • Sliding Window: 512 tokens
  • Modality: text-to-text
  • Context window: 262,144 tokens
  • Reasoning support: interleaved thinking with preserved thinking

Files

FileQuantSize
Laguna-XS-2.1-BF16.ggufBF16 (full precision)66.9 GB
Laguna-XS-2.1-Q4_K_M.ggufQ4_K_M20.3 GB

Q4_K_M is the recommended default for local use. Use BF16 if you want a reference full-precision baseline or intend to produce your own quantizations.

llama.cpp

[!NOTE] Laguna XS 2.1 support is not yet in upstream llama.cpp. Until it lands, build llama.cpp from the PR that adds Laguna XS 2.1 support (ggml-org/llama.cpp#25165).

# Build llama.cpp from the PR branch
git clone https://github.com/ggml-org/llama.cpp && cd llama.cpp
git fetch origin pull/25165/head:laguna && git checkout laguna
cmake -B build && cmake --build build -j

# Download a GGUF
huggingface-cli download poolside/Laguna-XS-2.1-GGUF \
  Laguna-XS-2.1-Q4_K_M.gguf --local-dir ~/models/Laguna-XS-2.1-GGUF

Serve an OpenAI-compatible endpoint with llama-server:

./build/bin/llama-server \
  -m ~/models/Laguna-XS-2.1-GGUF/Laguna-XS-2.1-Q4_K_M.gguf \
  --jinja \
  -ngl 99 \
  -c 32768 \
  --port 8000
  • --jinja applies the model's built-in chat template (reasoning and tool-calling).
  • -ngl 99 offloads all layers to the GPU (CUDA). Drop or lower it for CPU-only.
  • -c sets the context length; the model supports up to 262,144 tokens, but a bounded value (e.g. 32768) keeps KV-cache memory reasonable on local machines.

[!NOTE] macOS (Metal) users: the same recipe works on Apple Silicon via the Metal backend. Enable flash attention (-fa on) for lower memory use and better throughput.

License

This model is licensed under the OpenMDW-1.1 License.

Intended and Responsible Use

Laguna XS 2.1 is designed for software engineering and agentic coding use cases, and you are responsible for confirming that it is appropriate for your intended application. Laguna XS 2.1 is subject to the OpenMDW-1.1 License, and should be used consistently with Poolside's Acceptable Use Policy. We advise against circumventing Laguna XS 2.1 safety guardrails without implementing substantially equivalent mitigations appropriate for your use case.

Please report security vulnerabilities or safety concerns to security@poolside.ai.

Quoted from the model card on Hugging Face. The full card is behind the Hugging Face link above.

How it works

How language models work

Your prompttext / messagesTransformerattention over tokensNext-token loopgenerate + streamResponsetext · tool callsA language model reads your tokens and predicts the next one, again and again, streaming the reply back.
© 2026 AxForge · EU-hosted AI infrastructure Pricing Docs Trust Privacy Terms