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

Checked October 9, 2026: Our technical review focuses on the original Laguna XS.2 release under Apache 2.0. Poolside published a distinct successor, Laguna XS 2.1, on July 2, 2026. Both are 33B total / 3B active models, but 2.1 uses the separate OpenMDW-1.1 license. The Ollama identifiers laguna-xs.2 and laguna-xs-2.1 are different models, not alternative spellings. Poolside’s Ollama page also warns that XS 2.1 may return empty chat output on macOS/Metal. Official 2.1 release · Ollama model card.

Laguna XS.2 versus XS 2.1: the October Mac decision

XS.2 remains usable and separately licensed, but Poolside identifies XS 2.1 as its successor. This page’s original XS.2 comparison table below is historical. The publisher reports a 5.4-percentage-point SWE-bench Multilingual increase to 63.1% for XS 2.1 from 57.7% for XS.2. These are publisher-reported evaluation results, not independent local Mac benchmarks. Poolside’s 2.1 launch.

Item	Laguna XS.2 (original)	Laguna XS 2.1 (successor)
Published	April 28, 2026	July 2, 2026
Ollama model ID	laguna-xs.2	laguna-xs-2.1
Total / active params	33B / 3B	33B / 3B
Weights license	Apache 2.0	OpenMDW-1.1
Ollama Q4 package	about 23 GB	about 20 GB
Ollama MLX NVFP4 file	approx. 19 GB	approx. 20 GB
Q4 tag context (Ollama)	128K	256K
Ollama macOS/Metal chat issue	Not established for XS.2	May return empty output
Model-card context	up to 262,144 tokens	up to 262,144 tokens
SWE-bench Multilingual (Poolside)	57.7%	63.1%

Hosted XS.2 API sunset: what existing integrations need to check

On July 2, 2026, Poolside announced that it would sunset its own hosted XS.2 API after one week. That notice concerns a specific API service; it does not revoke access to the original Apache-2.0 weights for local inference. Poolside also pointed to Baseten’s Model Library for dedicated XS.2 deployments. The announcement alone does not prove that every third-party provider has stopped serving XS.2. Poolside: Laguna XS 2.1.

If you already use XS.2 in a coding agent, do not replace the model string blindly:

1. Identify your actual provider and model ID. Inspect the model catalog and endpoint of the account you use. Poolside’s sunset notice is not proof of the current status on OpenRouter, Baseten or a self-hosted deployment.
2. Retest an existing repository task. Use the same patch, tests, harness, tool permissions and context budget for the old and new models. Vendor SWE-bench scores are not a substitute for a workflow regression.
3. Check the new license and runtime. XS 2.1 uses OpenMDW-1.1 rather than Apache 2.0. Verify tool calls, preserved reasoning history and streaming in your client. On macOS/Metal, note the Ollama chat issue documented below.
4. Confirm billing and rollback. Record applicable token rates, context caps, data-handling terms and the path back to a working model. Poolside’s published USD rates are not a guaranteed quote from another provider; U.S. taxes may also apply.

Important macOS/Metal compatibility warning for XS 2.1

The official Ollama page for Laguna XS 2.1 currently warns that ollama run and /api/chat on macOS/Metal may return empty output, while the normal chat path works on Linux/CUDA. Poolside says it is investigating the cause with Ollama. Do not ascribe this issue to Laguna XS.2 without evidence.

The vendor documents /api/generate with "raw": true as a possible Mac workaround; another choice is a Linux/CUDA host. After ollama pull laguna-xs-2.1, a minimal smoke test is:

curl -sS http://localhost:11434/api/generate \
  -H 'Content-Type: application/json' \
  -d '{"model":"laguna-xs-2.1","prompt":"Write a small Python add(a,b) unit test.","raw":true,"stream":false}'

Limit: Raw generation bypasses Ollama’s usual chat-template formatting. The request is a basic text smoke test, not evidence that tool calling, multi-turn reasoning or thinking preservation works end to end. Test the correct template and agent harness separately, and recheck whether Poolside’s macOS warning has been resolved before any new benchmark. Ollama source.

United States: Fully offline local inference can keep data on the device. OpenRouter and Poolside’s hosted endpoints are cloud inference, and a U.S. IP address or English prompt does not guarantee U.S. processing or retention. Poolside lists XS 2.1 hosted rates of $0.10 input / $0.20 output / $0.05 cache read per million tokens. These are USD list prices, before any applicable state or local sales taxes or processing fees. Check the actual provider and data handling terms. Poolside announcement.

The context advertised in the model card is not necessarily the context in the selected local package. XS.2’s Ollama Q4 tag lists 128K, while the MLX tags list 256K. XS 2.1 Q4 lists 256K. Both model cards mention 262,144 tokens. A tag’s advertised context is not proof that the full KV cache fits your Mac.

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.

Laguna XS.2 specifications

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

Pin a real local model tag before changing an agent

XS.2 (laguna-xs.2) and its separate successor (laguna-xs-2.1) must be installed and tested independently. An Ollama download size is not peak Unified Memory, and :latest is a mutable alias. Record the exact tag and digest, then compare a reproducible chat request:

ollama pull laguna-xs.2:q4_K_M
ollama run laguna-xs.2:q4_K_M "Reply in one sentence."
ollama pull laguna-xs-2.1:q4_K_M
ollama run laguna-xs-2.1:q4_K_M "Reply in one sentence."
ollama list
ollama ps

If XS 2.1 returns empty text on macOS, use the separately documented raw-generation smoke test above. A successful raw request still does not establish working tool calls or chat history. Keep the working XS.2 agent setup until those are verified.

The selected Q4 tag is downloaded above; the following MLX tags are separate quantizations:

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

Local Mac constraints

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.

The newer local Qwen generation is covered in the Qwen3.8-27B guide, and memory limits in the unified memory guide.

Primary sources checked: October 10, 2026. XS.2 values are a historical model-card snapshot. XS 2.1’s macOS status reflects Poolside’s current Ollama warning and may change after a runtime update.

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