Poolside Laguna XS.2 on Mac: Open-Weight Coding Model, Benchmarks and RAM

Poolside Laguna XS.2 is not a general-purpose chatbot first. It is an open-weight coding model built for agentic software engineering: reading code, planning changes, using tools, running commands and working through longer development tasks. For Mac users, that makes it a candidate for local agentic coding on higher-memory machines.

One naming distinction matters for accuracy: Laguna XS.2 is listed on Hugging Face as poolside/Laguna-XS.2 and on Ollama as laguna-xs.2. Laguna XS 2.1 is now also available as a separate Poolside model on Hugging Face; it is not just a spelling variant. Do not mix its weights, tags or benchmark results with Laguna XS.2. Poolside introduced Laguna XS.2 on April 28, 2026 and later updated the model card with stronger benchmark numbers and a 262K context window. Poolside release blog, Hugging Face model card, Laguna XS-2.1 model card

Is Laguna XS.2 a good fit for your Mac?

At around 36 GB of unified memory, Laguna XS.2 is a local option for coding-agent workflows; 48 GB or 64 GB leaves more room for context, tools and other applications. Its published comparison scores trail Qwen3.6-35B-A3B, and 16 GB or 24 GB Macs are a poor fit. Ollama and MLX tags are available and the weights use Apache 2.0, but neither removes the need to check memory use and runtime behavior on the target Mac.

Key Facts

Item	Current status
Model	Poolside Laguna XS.2
Hugging Face ID	poolside/Laguna-XS.2
Model type	Mixture-of-Experts, text-to-text, coding-focused
Parameters	about 33B total, about 3B active per token
Architecture	40 layers, 256 experts plus 1 shared expert
Attention	10 global attention layers, 30 sliding-window layers
Context	Hugging Face: 262,144 tokens; Ollama tags: 128K (GGUF/standard) or 256K (MLX: mxfp8, nvfp4, mlx-bf16)
License	Apache 2.0
Local runtimes	Ollama, MLX, vLLM, SGLang, Transformers
Practical Mac entry point	around 36 GB unified memory

The technical report describes Laguna XS.2 as a 33.4B-total, 3B-active Mixture-of-Experts model for long-horizon agentic coding. The Hugging Face model card adds the deployment details, architecture summary, benchmark table and local runtime guidance. Technical report, Hugging Face model card

What Unified Memory Changes for Laguna XS.2

Apple Silicon Macs share CPU, GPU and Neural Engine access to unified memory. That can make larger local models feasible than on systems limited by a small discrete-GPU memory pool. Models around the 30B range still require high-memory configurations.

Laguna XS.2 sits in that zone. Ollama lists laguna-xs.2:latest and laguna-xs.2:q4_K_M at around 23 GB each, laguna-xs.2:nvfp4 (MLX) at around 19 GB, laguna-xs.2:mxfp8 (MLX) at around 39 GB, laguna-xs.2:q8_0 at around 37 GB, and laguna-xs.2:bf16 and laguna-xs.2:mlx-bf16 at around 67 GB each. Package size is not the same thing as peak RAM use, because context, KV cache, runtime overhead and other apps add pressure. Ollama Laguna XS.2

For Mac buyers and upgraders, the practical guidance is simple:

Mac memory	Recommendation
16 GB	Too small for Laguna XS.2
24 GB	Possible only as a constrained experiment, not recommended
32 GB	Borderline with small quantized tags and short context
36 GB	Official local-ready entry point
48 GB	More room for local tests and context
64 GB+	Much better for longer context and developer tools

Benchmark results compared with Qwen3.6

The current Hugging Face model card reports these official comparison values:

Benchmark	Laguna XS.2	Qwen3.6-35B-A3B	Claude Haiku 4.5	Takeaway
SWE-bench Verified	69.9%	73.4%	73.3%	very strong, but not leading
SWE-bench Multilingual	57.7%	67.2%	-	Qwen3.6 is clearly ahead
SWE-bench Pro	46.3%	49.5%	39.5%	strong for a local open-weight model
Terminal-Bench 2.0	35.7%	51.5%	29.8%	ahead of Haiku 4.5, far behind Qwen3.6

The methodology matters. Poolside reports that Laguna XS.2 was benchmarked with the Laude Institute’s Harbor Framework and Poolside’s agent harness, using up to 500 steps, temperature=0.7 and top_k=20. SWE-bench Verified was averaged over four runs, SWE-bench Multilingual over seven runs, SWE-bench Pro over three runs and Terminal-Bench 2.0 over five runs. Terminal-Bench 2.0 used a larger 48 GB RAM and 32 CPU sandbox. Hugging Face model card

If you see older 68.2% SWE-bench Verified numbers, you are probably looking at a previous or mirrored model-card snapshot. Ollama still shows a 128K-context table with 68.2% in some places, while the official Hugging Face model card now shows 262,144 tokens and 69.9%. The Hugging Face model card is the primary reference. Ollama Laguna XS.2, Hugging Face update commit

Architecture: Why 33B Does Not Mean Dense 33B

Laguna XS.2 is a Mixture-of-Experts model. Instead of activating every parameter for every token, the model routes tokens through selected experts. Poolside lists 256 experts plus one shared expert, with about 3B active parameters per token.

That matters for local coding. A dense 33B model can be heavy to run, especially with long context. A sparse MoE model gives the model more total capacity while keeping per-token compute closer to a much smaller active model. Laguna XS.2 also uses a mixed attention layout: 10 global attention layers and 30 sliding-window attention layers, with a 512-token sliding window. The goal is lower KV-cache pressure and more practical long-context inference.

262K context: memory and latency costs

The 262K context window expands how much code an agent can keep available, but it also increases memory use and latency. Pasting a whole project does not guarantee useful results on a local Mac. Even with sliding-window attention and FP8 KV-cache support, a local Mac can get memory-bound quickly.

Better local workflows usually look like this:

1. Let the agent search and read only relevant files.
2. Keep logs and stack traces short.
3. Avoid dumping a whole repository into the prompt.
4. Use tests and shell output as feedback.
5. Treat benchmark scores as a signal, not as a guarantee of real-project quality.

How to Run Laguna XS.2 with Ollama

The simplest local starting point is Ollama:

ollama pull laguna-xs.2
ollama run laguna-xs.2

For many Mac users, a quantized variant is the better first test:

ollama run laguna-xs.2:q4_K_M

On Apple Silicon, MLX-tagged variants are worth trying:

ollama run laguna-xs.2:nvfp4
ollama run laguna-xs.2:mxfp8

BF16 is much heavier. Ollama lists the BF16 variants at around 67 GB, which makes them unrealistic for most consumer Macs once system memory, context and developer tooling are included. Ollama Laguna XS.2

Where Laguna XS.2 Fits Best

Laguna XS.2 makes sense for:

• local coding agents on high-memory Macs
• private repositories that should not go to a cloud API
• agent workflows with shell, tests and file access
• open-weight model evaluation under Apache 2.0
• developers comparing Qwen, Devstral, Gemma and Poolside on real code

It is weaker for:

• small 8 GB, 16 GB or 24 GB Macs
• image, audio or multimodal tasks
• casual chat where coding ability does not matter
• users who need the fastest possible response on weak hardware
• setups where Qwen3.6-35B-A3B already runs well and benchmark leadership is the main goal

Apache 2.0: Open Weights With Real Freedom

The Apache 2.0 license is a major part of the appeal. It allows broad use, modification and commercial deployment compared with more restrictive model licenses. Still, open weights do not mean every part of the system is open. The training data, full internal training stack and all production systems are not automatically included. Poolside also points users to intended-use guidance and an acceptable-use policy. Hugging Face model card

For coding agents, there is also a practical safety issue: a model that can call shell tools should run in a controlled environment. Use sandboxes, review changes and avoid giving a local model unrestricted access to secrets or production systems.

Laguna XS.2 vs Laguna M.1

Laguna M.1 is Poolside’s much larger model: 225.8B total parameters and 23.4B active parameters according to the technical report. That scale makes local Mac deployment substantially harder. Laguna XS.2 is the more relevant model for a local setup because its published size and sparse architecture are easier to compare with a Mac’s Unified Memory budget. This is a practical distinction, not a claim that XS.2 is the stronger model overall. Technical report

What matters for a local Mac

Criterion	Practical reading
Local deployment	Check the model size, quantization and available Unified Memory before downloading.
Coding agents	Run shell-capable workflows with a sandbox, review changes and no access to secrets by default.
Benchmarks	Model-card and vendor results do not predict every Mac, runtime or coding harness.
License	The model card lists Apache 2.0; Poolside’s acceptable-use terms still apply.

Sources

• Poolside: Introducing Laguna XS.2 and Laguna M.1
• Poolside: Laguna XS.2 and M.1 - A Deeper Dive
• Hugging Face: poolside/Laguna-XS.2
• Ollama: laguna-xs.2
• arXiv: Laguna M.1/XS.2 Technical Report
• Hugging Face commit: 256K context and benchmark update