---

license: apache-2.0

base_model: poolside/Laguna-XS-2.1

base_model_relation: quantized

pipeline_tag: text-generation

library_name: llama.cpp

tags:

• gguf
• llama.cpp
• sycl
• intel-arc
• moe
• laguna

---

Laguna-XS-2.1 Q4_K_M — Intel Arc (SYCL) serving package

<p align="center"><img src="laguna_b70_turbo.png" alt="Laguna 2.1 B70" width="55%"/></p>

> **This is a serving configuration and kernel build for the Intel Arc Pro

> B70 — not a new model and not a fine-tune.** The weights are poolside's

> Laguna-XS-2.1, byte-identical to the official quant. Everything in this

> repo is packaging: template, server config, and Arc-specific kernel work.

Laguna-XS-2.1 packaged for local serving on Intel Arc GPUs with llama.cpp's

SYCL backend — validated end-to-end on an Intel Arc Pro B70 at the model's

full 131,072-token context. This repo bundles the quant together with the

three things you actually need to serve it correctly on this stack: a working

chat template, a validated server configuration, and honest performance

numbers measured on real text.

• Model: poolside/Laguna-XS-2.1 — 33B-parameter MoE (256 experts, 8 active, ~3B active parameters), 40 layers, mixed SWA/global attention (3:1, window 512), YaRN-scaled to 131,072 context. Apache-2.0.
• Quant: Laguna-XS-2.1-Q4_K_M.gguf (~20.3 GB) — mirror of the official imatrix Q4_K_M from poolside/Laguna-XS-2.1-GGUF. SHA-256 in Laguna-XS-2.1-Q4_K_M.gguf.sha256. All credit for the model and the quantization goes to poolside.
• Hardware validated: Intel Arc Pro B70, oneAPI 2026.0, llama.cpp SYCL backend (tested at master dd1ea5243, Aug 2026). ~25 GiB VRAM at full 131,072 context with f16 KV cache — fits the B70 with headroom.

Quickstart (llama.cpp SYCL)

export

llama-server \
  -m Laguna-XS-2.1-Q4_K_M.gguf \
  --jinja --chat-template-file Laguna-XS-2.1.jinja \
  -ngl 99 -fa on -ctk f16 -ctv f16 \
  -c 131072 -np 1 \
  -b 4096 -ub 2048 \
  --temp 0.7 --top-k 20 --top-p 0.95 --min-p 0.05 \
  -n -1 --host 0.0.0.0 --port 8092 --metrics

Or use serve-laguna-arc.sh from this repo, which wraps the same command with

sane overrides (SERVE_PORT / SERVE_CTX / SERVE_NP / MODEL env vars).

The three gotchas

These each cost a debugging session; the config above already avoids all of

them.

1. The embedded chat template does not parse in llama.cpp. The template

inside the GGUF uses a Jinja include statement that llama.cpp's Jinja engine

rejects (Unknown statement: include). Passing `--jinja --chat-template-file

Laguna-XS-2.1.jinja` (included in this repo) is required, not cosmetic.

The bundled template also maps message.reasoning_content to

message.reasoning for OpenAI-compatible clients.

*2. -c is the total KV pool, split evenly across -np slots.* With

-c 131072 -np 4 every request silently gets only 32,768 tokens of context.

-np 1 gives each request the full trained 131,072 — VRAM use is identical

either way. Check curl :PORT/props → default_generation_settings.n_ctx

to see the per-slot value you actually got.

**3. Laguna is a thinking model, and reasoning tokens count against the

client's max_tokens.** A request with max_tokens: 400 can spend all 400

tokens inside the reasoning block and return an empty content with

finish_reason: "length". Send no max_tokens (the server default -n -1 is

unlimited) or a generous one (>1500). To skip thinking entirely, pass

"chat_template_kwargs": {"enable_thinking": false} in the request.

Measured performance (Arc Pro B70, this quant)

Measured on real text (WikiText, ~23K-token prompts), not just synthetic

benchmarks — on MoE models the two differ a lot (see note below). Single

stream, -ub 2048 -b 4096, f16 KV.

| build | 23K-token real-text prefill | decode at 23K depth | decode at 122K depth | short-context decode (tg128) |

|---|---|---|---|---|

| llama.cpp master dd1ea5243, stock | ~1,490 t/s | ~61 t/s | — | ~107 t/s |

| kernel work, 2026-08-11 state | ~310 t/s | ~92 t/s | — | ~152 t/s |

| long-context stack, 2026-08-12 (tag lx-stack-1.4092-20260812) | ~1,764 t/s | ~90 t/s | ~41 t/s | ~152 t/s |

2026-08-12 update — the long-context stack

The earlier trade-off (master's fast prefill or the kernel work's fast

decode) is gone: one build now holds both columns. The prefill gap turned out

to be a dispatch-state issue in the kernel work itself — a warmup decode

permanently latched weight reordering, after which a dispatch guard routed

every wide matmul through a slow 8-column path. Fixing that (plus a wider

flash-attention split-K for deep-context decode and an XMX fused

dequant-GEMM for small MoE expert batches) is worth **5.75x real-text

ingest and +13% decode at the full 131K window** over the 08-11 state,

with short-context decode unchanged. An earlier note here attributed the

synthetic-vs-real prefill gap to MoE routing skew — that explanation was

falsified by direct experiment (receipted in the kernel-work repo); the

cause was the dispatch state above. Synthetic benchmarks remain a poor

proxy for real-text serving on this model; trust the real-text column.

The stack is three env-gated kernel changes on a llama.cpp fork branch

(receipts, source, and binaries: newjordan/lagunaB70):

export GGML_SYCL_LX_REORDER_MULTICOL_MKL=1   # wide batches -> fp16/oneMKL
export GGML_SYCL_LX_FATTN_PARALLEL_BLOCKS=16 # FA decode split-K width
export GGML_SYCL_LX_EXPERT_TILE_GEMM=1       # XMX fused dequant-GEMM, small-N experts

Quality gating: bit-parity with the previous build when the knobs are off;

knobs-on output measures closer to canonical fp16 math than the previous

build did (KLD-to-canonical 0.045 vs 0.056, top-1 92.8% vs 91.7%), slightly

better wikitext PPL, per-dispatch kernel verification against an fp32

reference, and a 1,536-token NaN watch at full 131K context. These numbers

are B70-specific; on stock llama.cpp none of the knobs exist and this

repo's stock instructions above apply unchanged.

Recommended sampling (validated here): `--temp 0.7 --top-k 20 --top-p 0.95

--min-p 0.05`. The GGUF's embedded defaults are temp 0.7 / top-p 0.9; both

work well.

Files

| file | what |

|---|---|

| Laguna-XS-2.1-Q4_K_M.gguf | official poolside imatrix Q4_K_M quant (mirror) |

| Laguna-XS-2.1-Q4_K_M.gguf.sha256 | checksum of the above |

| Laguna-XS-2.1.jinja | chat template that actually parses in llama.cpp |

| serve-laguna-arc.sh | validated llama-server launcher for Arc GPUs |

For other quant sizes (Q5_K_M, Q8_0, …) use the official repo:

poolside/Laguna-XS-2.1-GGUF.

Credits & license

• Model and official quantization: poolside

(Laguna-XS-2.1,

Laguna-XS-2.1-GGUF) — all

credit for the model itself belongs to them.

• Runtime: llama.cpp (ggml-org) and

its SYCL backend; Intel oneAPI / XMX.

• Serving configuration, Arc B70 kernel work, and measurements: Frosty40

(newjordan/lagunaB70).

License: Apache-2.0, inherited from

poolside/Laguna-XS-2.1.

Measurement artifacts and scripts: MIT.