Uncensored Laguna API

Most "cheap model" pages ask you to accept a small, tired foundation in exchange for a low number. This one does not. Laguna S 2.1 is a current-generation sparse Mixture-of-Experts release, trained on 4,096 H200s and shipped in under nine weeks, and it sits at the same $0.50 / $2.00 floor as every other entry-tier model we serve. The trade is narrow and easy to reason about: you give up server-enforced structured output and keep everything else.

01What is Laguna S 2.1?

Laguna S 2.1 is an open-weights model released by Poolside on July 21, 2026 under the permissive OpenMDW-1.1 license — the mid-size member of the Laguna family, between Laguna XS 2.1 (33B/3B active) and Laguna M.1 (225B/23B active).

The published architecture is a token-choice router with softplus gating over 256 routed experts plus one shared expert, ten selected per token, across 48 layers — twelve global-attention, thirty-six sliding-window at a 512-token window, an interleaving that keeps the attention cost of very long inputs near-linear instead of quadratic. Attention is grouped-query with 8 key-value heads at head dimension 128.

Two consequences matter to an API consumer. The sparse activation is why a 118B model can sit at the floor price — only ~8B parameters work per token, so compute per token is closer to a small dense model than the parameter count suggests. And the sliding-window interleaving is why the long window is genuinely usable rather than nominal. Poolside's release supports 1,048,576 tokens; we serve 262,144, matching every other model on the gateway.

02The one caveat: no structured output

What still works. Tool calling is fully supported, and tool-call arguments still arrive as a JSON object exactly as on any other model here. If your application's "structured output" is really tool arguments — true of most agent frameworks, MCP servers and database front-ends — Laguna S 2.1 serves you fine. Streaming works on all three dialects; reasoning_effort works.

What does not. You cannot hand the endpoint a JSON Schema and be guaranteed the assistant's text reply validates against it, and response_format: {"type": "json_object"} buys you nothing. Prompting for JSON usually produces JSON — this is a competent model — but "usually" is not a contract. Poolside itself documents incorrect JSON escaping in deeply nested tool calls as a known limitation, a reminder that the guarantee, where it exists elsewhere in our lineup, comes from the serving layer rather than the model's good intentions.

Which sibling to use instead

If your workload needs guaranteed JSON, do not fight this model — switch the model id. Four siblings sit at the identical $0.50 / $2.00 price with full json_schema and response_format support:

Model id	json_schema	Vision	Why you'd pick it
MiMo-V2.5-Pro-W8A16	Yes	No	The direct swap — 8-bit weights, highest-fidelity tier, same price
MiMo-V2.5-W8A16	Yes	Yes	Same, plus image input
Hy3-W8A16	Yes	No	Another 8-bit text model at the floor price
DeepSeek-V4-Flash-0731	Yes	No	W4A16-AutoRound-REAP like Laguna, schema support intact

The natural default is MiMo-V2.5-Pro (W8A16): text-only, floor-priced, quantized at the gentlest tier we run — details on the MiMo-V2.5 model card. Because all twelve models share endpoints, context window and output ceiling, switching is a one-line change to the model field.

03What does W4A16-AUTOROUND-REAP mean?

The suffix on the model id is not decoration — it says exactly how the weights were compressed before they were loaded onto our GPU cluster. Three parts.

W4A16 — 4-bit weights, 16-bit activations

Weights are stored at 4 bits; activations — the values flowing between layers at inference time — stay at 16. Cutting weights to a quarter of their BF16 footprint is what makes a 118B model fit and stay fast, while keeping activations wide protects the numerically sensitive part of the forward pass. Compress what is large and static, leave what is small and dynamic alone.

AutoRound — learned rounding, not nearest rounding

The naive way to quantize is round-to-nearest: snap each weight to the closest 4-bit value, accept the error. AutoRound, Intel's open post-training quantization toolkit, does better — its SignRound method uses signed gradient descent to jointly optimize rounding decisions and clipping ranges over a couple of hundred steps, deciding per weight whether rounding up or down does less damage to the layer's actual output. It borrows the idea from quantization-aware training without the cost of retraining, and it is why a W4A16 build can be a serious model rather than a lossy curiosity.

REAP — pruning experts instead of merging them

REAP is Router-weighted Expert Activation Pruning, published by Cerebras Research. In an MoE model not all experts pull their weight: the router sends few tokens to some, and some contribute little magnitude when they do fire. REAP scores each expert on both signals — router gate values and expert activation norms — and removes the low-saliency ones in one shot, before quantization. Crucially it prunes rather than merges: merging folds several experts into one, destroying the router's fine-grained, input-dependent control and introducing an error floor no tuning removes (the authors call it functional subspace collapse), while pruning leaves the survivors and the router's control over them intact. Cerebras reports removing up to 50% of experts from trillion-parameter models while largely maintaining baseline quality — on a 480B coder model at 50% pruning, 97.6% of baseline non-agentic coding ability and 96.7% on agentic SWE-Bench. Those are Cerebras figures for their own models, not measurements of our build, but they are why we run this stack on a foundation whose primary strength is code.

Together the suffix reads as a sentence: prune the experts that were barely used, learn the 4-bit rounding rather than guessing it, keep activations at full width.

04What is this model actually good at?

Honesty first: Laguna S 2.1 is a text-only conversational model — no vision input on this model id — and Poolside built it for agentic coding and long-horizon work, not for prose. Post-training ran over 409,000 environments, including 83,000 terminal and 168,000 software-engineering tasks, with reinforcement learning in FP8. Poolside's reported results for the unquantized release:

Benchmark	Thinking	No-thinking	What it measures
SWE-Bench Multilingual	78.5%	—	Real bug fixes across many languages
Terminal-Bench 2.1	70.2%	60.4%	Multi-step shell and tooling work
SWE-Bench Pro	59.4%	—	Harder, contamination-resistant repo tasks
Toolathlon Verified	49.7%	—	Tool-use breadth across many APIs
SWE Atlas	46.2%	—	Long-horizon repository navigation
DeepSWE v1.1	40.4%	16.5%	Agentic software engineering

The gap between the two columns is the most actionable number here: on DeepSWE the score more than doubles when reasoning is enabled, and on Terminal-Bench it gains nearly ten points.

Poolside-reported figures for the unquantized Laguna S 2.1 release, July 2026. They are not measurements of our W4A16-AutoRound-REAP build, and we publish no benchmark numbers of our own for it. Use reasoning_effort to control the thinking budget on our API.

For conversational and creative work the honest position is this: the qualities behind long agentic runs — holding a lot of state coherently, staying on task, not drifting — are the same ones behind long-form character work, and in practice it holds voice well across a very long window. No published benchmark says so, and we will not invent one. Test it on your own prompts; at $0.50 per million input tokens that is nearly free.

05What does the floor price actually buy?

$0.50 in / $2.00 out per million tokens is the entry tier on the Shannon AI Gateway, shared with MiniMax-M3, DeepSeek-V4-Flash, MiMo-V2.5, MiMo-V2.5-Pro and Hy3. Concretely:

Workload	Input	Output	Cost
One chat turn with 100K of history	100,000	2,000	$0.054
A 5,000-word chapter from a long brief	30,000	7,000	$0.029
1,000 short conversational turns	4,000,000	500,000	$3.00
A full 262K-token context read	262,144	16,384	$0.164

The last row is the one to internalize: filling the entire context window and generating the maximum 16,384-token response costs about sixteen cents. Feeding a whole manuscript, session transcript, or document set into one call stops being a budget decision and becomes a latency decision. The same arithmetic drives the other floor-price use case — volume: batch classification, bulk rewriting, synthetic dialogue, first-pass drafting a stronger model later refines. See the pricing page and the research index.

06What "uncensored" means here

It means what it says: no refusal layer and no content filtering on output. No classifier sits between the model and your response deciding whether you were allowed to ask; the model answers in the register you asked for and does not lecture you about the premise first.

For creative work that is the difference between a usable tool and an unusable one. Fiction contains menacing antagonists, characters who lie convincingly, violence with consequences, morally compromised narrators — a model that breaks character to append a disclaimer has failed the task, not succeeded at safety. The same holds for security research, red-team documentation, medical and legal drafting, and translation where the source is blunt: categories where a refusal is simply a wrong answer. What it does not mean is that judgment stops being yours — you remain responsible for what you generate, under our Responsible Use Policy and applicable law.

07How to call the uncensored Laguna API

Three dialects, one model: /v1/chat/completions (OpenAI), /v1/messages (Anthropic), /v1/responses. Streaming works on all three, so an existing integration moves over by changing a base URL and a model id — no SDK swap, no rewrite of your message handling.

POST https://api.shannon-ai.com/v1/chat/completions

{
  "model": "Laguna-S-2.1-W4A16-AUTOROUND-REAP",
  "messages": [
    { "role": "system", "content": "You are a hardboiled narrator. Stay in voice." },
    { "role": "user",   "content": "Open chapter nine." }
  ],
  "stream": true,
  "max_tokens": 4096,
  "reasoning_effort": "low"
}

A few practical notes:

• Do not send response_format or json_schema to this model id — if your client library sets one by default, unset it or move to a sibling that supports it.
• Tools go in the usual tools array — tool calling is fully supported; only free-text schema enforcement is not.
• Budget your reasoning. reasoning_effort is honored — low or off keeps conversational latency down and output tokens cheap; raise it for multi-step tool work, where the benchmark gap above shows what it buys.
• Output ceiling is 16,384 tokens per request. For book-length generation, chapter it and stream.
• Text only. No image input on this model id — use MiMo-V2.5, Kimi-K2.6, Kimi-K3, MiniMax-M3 or inkling for vision.

Full parameter reference, authentication, error semantics and a live playground: API documentation.

08When to choose it, and when not to

Choose it when your output is prose, dialogue or code read by a human; you need tool calling but not schema-constrained text; cost per token dominates over long context; or you want a second opinion from a lineage other than the DeepSeek, Kimi and MiMo families that fill the rest of the lineup.

Choose something else when you need guaranteed JSON (MiMo-V2.5-Pro), image understanding (Kimi-K2.6 or MiMo-V2.5), or the frontier end of difficulty where the price gap is irrelevant next to getting the answer right (DeepSeek-V4-Pro, Kimi-K3).

09Frequently asked questions

---

Sources: Poolside — Laguna S 2.1 model card · Introducing Laguna S 2.1 · REAP the Experts (Cerebras Research) · Intel AutoRound. Architecture and benchmark figures are publisher-reported for the unquantized release, not measurements of the build we serve. Shannon AI is operated by Shannon Lab LLC, New Mexico, USA.