Poolside Laguna S 2.1: 118B Open-Weight Code Model, 8B Active

Poolside Laguna S 2.1 is a 118-billion-parameter Mixture-of-Experts (MoE) model engineered from the ground up for agentic coding and long-horizon software engineering tasks — and as of late July 2026 it is one of the most-discussed open-weight code models on Hugging Face. With only 8B parameters activated per token, a full one-million-token context window, and a permissive commercial license, it punches well above its compute weight against models that are three to fifteen times its active size.

For developers who want a serious coding model they can self-host, fine-tune, or integrate into an agentic pipeline, the poolside Laguna release signals a meaningful shift: frontier-grade software engineering capability is now available as open weights, not locked behind a single proprietary API. Below is everything you need to know about the architecture, benchmarks, deployment options, hosted access, and where the model sits in poolside's growing Laguna family.

---

What Is Poolside and the Laguna Model Family?

Poolside is an AI company whose stated focus is building models specifically optimised for software development — an increasingly competitive niche that distinguishes itself from general-purpose assistants by treating coding as a first-class objective rather than one capability among many. The company's primary web presence and model-access hub is poolside.ai. The Laguna series is its open-weight model line, all sharing a common architectural "family recipe": a token-choice router with softplus gating, grouped-query attention, and interleaved full and sliding-window attention layers. A shared tokenizer with a vocabulary of 100,352 tokens runs across all variants.

The Laguna family currently spans three tiers, each targeting a different hardware and latency profile. Note the context windows differ across tiers — a detail worth checking against each model card before you build around it:

Model	Total Parameters	Activated per Token	Context Window	Primary Use Case
Laguna XS 2.1	33B	~3B	262,144 tokens (256K)	Edge / low-latency inference
Laguna S 2.1	118B	~8B	1,048,576 tokens (1M)	Balanced agentic coding
Laguna M.1	225B	~23B	262,144 tokens (256K)	Maximum coding capability

The poolside Laguna M.1 at 225B-A23B is the family's largest model; the poolside Laguna XS 2.1 at 33B-A3B is the lightweight entry point. Laguna S 2.1 sits squarely in the middle — capable enough for demanding agentic workloads, yet practical enough to run on four high-end GPUs, and notably the only tier that ships the full one-million-token context (both XS 2.1 and M.1 top out at 262,144 tokens). Poolside also publishes a base (pre-instruction-tuned) checkpoint for Laguna M.1 at poolside/Laguna-M.1-base — a raw pre-trained text-completion model with no post-training, reasoning, or tool-calling behaviour — making fine-tuning experiments on the larger architecture accessible to researchers.

Is Poolside Laguna M.1 Free?

A common question across community forums and poolside Laguna Reddit threads is whether a free tier exists for any Laguna model, particularly poolside Laguna M.1. The answer as of late July 2026 is nuanced. The models are both freely downloadable open weights and available through third-party hosted gateways — including free tiers:

• Open weights: All variants can be downloaded and self-hosted at no cost under the OpenMDW-1.1 license.
• Hosted API access: poolside.ai links out to OpenRouter and Vercel AI Gateway as managed access points. On OpenRouter, Laguna S 2.1, Laguna XS 2.1 and Laguna M.1 each appear in both paid and free ($0/M input and output) tiers — the origin of the poolside Laguna M.1 (free) and poolside Laguna S 2.1 (free) listings people reference.

Two important caveats: OpenRouter notes that requests to the free tiers may be used to train and improve poolside's models, and its listing flags Laguna M.1 (and its free variant) as "going away July 28, 2026," so anyone standing up a pipeline on M.1 should plan for that deprecation. On OpenRouter the free Laguna S 2.1 endpoint is served at 262K context, while the paid Laguna S 2.1 endpoint exposes the full ~1.05M context.

---

Architecture Deep Dive: The Engineering Behind the Efficiency

The poolside Laguna model design reflects several deliberate choices that make a 118B-parameter model behave more like an 8B one at inference time. Understanding these choices is essential if you are planning to host the model or evaluating whether it fits your infrastructure budget.

Mixture-of-Experts with Softplus Gating

Rather than activating all 118B parameters for every token, Laguna S 2.1 uses a token-choice router with softplus gating over 256 routed experts plus one shared expert. For each token, the router selects the top-10 routed experts and the single always-on shared expert, meaning only approximately 8B parameters execute per forward pass. This sparse MoE design follows the tradition of models like Mixtral but with a substantially larger expert pool — 256 routed experts versus Mixtral's 8 — enabling finer-grained specialisation. That property is particularly well-suited to the diverse sub-tasks involved in agentic coding: understanding existing code, writing and running tests, issuing tool calls, and reasoning through error traces.

Interleaved Full and Sliding-Window Attention

The model's 48 transformer layers are arranged in a 1:3 global-to-sliding-window ratio: 12 full (global) attention layers interleaved with 36 sliding-window attention (SWA) layers, where each SWA layer attends to a local window of 512 tokens. Global attention layers preserve long-range dependencies across the full context; SWA layers keep per-token compute manageable at scale. Per-head softplus output gating and per-layer-type rotary positional scales are applied throughout. Grouped-query attention with 8 KV heads (head dimension: 128) reduces the KV-cache footprint compared to standard multi-head attention at the same model width — a meaningful memory saving at the 1M-token context lengths this model targets.

One-Million-Token Context Window

Perhaps the single most developer-relevant specification: Laguna S 2.1 supports a context window of 1,048,576 tokens — exactly 2²⁰, roughly one million tokens. (This is the tier's defining feature: the smaller XS 2.1 and the larger M.1 both cap out at 262,144 tokens, so the 1M window is specific to S 2.1.) For agentic coding, where an agent may need to hold an entire large codebase, multiple file diffs, tool call histories, and extended reasoning chains simultaneously in context, this is not a luxury but a practical necessity. Poolside explicitly recommends enabling and preserving thinking blocks across multi-turn agentic sessions, noting that dropping prior reasoning_content from the message history can cause the model to stop reasoning in subsequent steps — a subtle failure mode with significant downstream consequences for complex tasks.

Native Thinking Mode and Interleaved Reasoning

Laguna S 2.1 supports interleaved reasoning between tool calls — the model can think out loud between individual tool invocations in an agentic loop, not just at the start of a response. This contrasts with models that front-load all chain-of-thought before tool execution, and it is better aligned with complex, multi-step debugging or refactoring workflows where intermediate observations should inform subsequent reasoning. Thinking mode is controlled via a per-request flag passed in the request body:

extra_body={"chat_template_kwargs": {"enable_thinking": False}}

or set globally at the server level via:

--default-chat-template-kwargs '{"enable_thinking": true}'

Poolside's recommendation for production agentic pipelines is to enable thinking and preserve reasoning content across turns to maintain coherent multi-step behavior.

---

Benchmark Performance: Efficiency at Scale

The numbers poolside published tell a striking story about parameter efficiency. Laguna S 2.1 (118B total, 8B active) consistently outperforms models with two to five times more activated parameters on the benchmarks most relevant to software engineering. Full evaluation trajectories are published at trajectories.poolside.ai for independent verification, and the headline figures below match the poolside/Laguna-S-2.1 model card.

Model	Size (Total–Active)	Terminal-Bench 2.1	SWE-bench Multilingual	SWE-Bench Pro	DeepSWE	Toolathlon Verified
Laguna S 2.1	118B-A8B	70.2%	78.5%	59.4%	40.4%	49.7%
Tencent Hy3	295B-A21B	71.7%	75.8%	57.9%	—	—
DeepSeek-V4-Pro Max	1.6T-A49B	64.0%*	76.2%	55.4%	9.0%*	55.9%*
Inkling	975B-A41B	63.8%	—	54.3%	—	45.5%*
Nemotron 3 Ultra	550B-A55B	56.4%	67.7%	—	—	34.3%*
Kimi K3†	2800B-A50B†	88.3%†	—	—	69%†	—

Scores marked * are as reported by third parties via Artificial Analysis, Scale AI's SWE Atlas leaderboard, or the Toolathlon leaderboard. Scores and parameter counts marked † for Kimi K3 are sourced from third-party reports and have not been independently verified by poolside. Laguna S 2.1's own figures are drawn from the poolside model card; full poolside evaluation trajectories are available at trajectories.poolside.ai.

The headline results:

• vs. Tencent Hy3 (295B-A21B): Laguna S 2.1 leads on SWE-bench Multilingual (78.5% vs 75.8%) and SWE-Bench Pro (59.4% vs 57.9%) while activating less than 40% of Hy3's parameters per token.
• vs. Inkling (975B-A41B): Laguna S 2.1 surpasses the 975B model on both Terminal-Bench 2.1 and SWE-Bench Pro with roughly 5× fewer activated parameters.
• vs. DeepSeek-V4-Pro Max (1.6T-A49B): Laguna S 2.1 leads on SWE-bench Multilingual (78.5% vs 76.2%) and SWE-Bench Pro (59.4% vs 55.4%), despite the competitor activating 6× more parameters per token.
• Where Laguna S 2.1 trails: the third-party-reported Kimi K3 leads Terminal-Bench 2.1 (88.3%) and DeepSWE (69%) by a significant margin, and DeepSeek-V4-Pro Max edges it on Toolathlon Verified (55.9% vs 49.7%).

Why it matters: These results suggest that domain-specific training on software engineering tasks can outcompete sheer scale. A model an organisation can realistically run on four to eight high-end GPUs matches or outperforms several that require data-centre-scale deployments — a compelling argument for bringing capable AI coding into on-premises or private-cloud environments where data residency or IP sensitivity is a concern.

---

Deployment Options: From Local Server to Data Centre

Poolside has done unusually thorough work on the deployment side, providing first-party support across four major inference frameworks and a comprehensive set of quantised checkpoints. A model that is theoretically open but practically impossible to serve at reasonable cost remains theoretical — poolside's documentation addresses this directly. And for teams that would rather not run their own hardware at all, the OpenRouter and Vercel AI Gateway hosted endpoints provide a managed path.

Quantised Checkpoints

Multiple precision variants of Laguna S 2.1 are published on Hugging Face (poolside/Laguna-S-2.1), covering the range from research to production deployment. The model tree lists numerous quantisation checkpoints across the following formats:

• BF16 — Full precision; requires approximately 236 GB of GPU VRAM for weights alone (118B parameters × 2 bytes/parameter), before KV cache or activation memory.
• FP8 — Approximately half the VRAM of BF16 with minimal quality degradation; a common production choice.
• INT4 — Aggressive quantisation for memory-constrained deployments.
• NVFP4 — NVIDIA's 4-bit format optimised for Hopper and Blackwell GPU architectures.
• GGUF — Published separately at poolside/Laguna-S-2.1-GGUF for llama.cpp and local inference tools such as LM Studio and Ollama.

Poolside does not break out per-variant download counts on the model card — the page reports a single aggregate figure of roughly 3,056 downloads in the last month for the base repository. In practice, quantised weights are the pragmatic choice for most deployments: FP8 halves the memory footprint to roughly 118 GB for weights, while INT4 pushes it below 60 GB — theoretically within reach of a four-GPU consumer or prosumer rig with sufficient VRAM per card.

Speculative Decoding via DFlash

Poolside ships a dedicated DFlash draft model (poolside/Laguna-S-2.1-DFlash, approximately 1B parameters) trained specifically for speculative decoding against the S 2.1 target. In vLLM, enabling it requires one additional argument at serve time:

--speculative-config '{"model":"poolside/Laguna-S-2.1-DFlash","num_speculative_tokens":7,"method":"dflash"}'

Speculative decoding with a well-matched draft model can meaningfully reduce time-to-first-token and increase effective throughput in latency-sensitive pipelines. The DFlash draft model itself is available in BF16, FP8, INT4, and NVFP4 variants, matching the quantisation options of the main checkpoint. Note that the dflash speculative method requires a vLLM version that supports the method key in --speculative-config; verify your installed version before deploying.

Inference Framework Support

Poolside documents production-ready serving configurations for four frameworks:

1. vLLM — Full support including tensor parallelism, tool-call parsing via --tool-call-parser poolside_v1, reasoning parsing via --reasoning-parser poolside_v1, and speculative decoding. Uses hyphens in flag names.
2. SGLang — Both pip and Docker deployment paths are documented; exposes an OpenAI-compatible endpoint with --tool-call-parser poolside_v1.
3. TRT-LLM — Supported via trtllm-serve with --tool_parser poolside_v1 and --reasoning_parser laguna. Note: TRT-LLM uses underscores in flag names, unlike vLLM's hyphens — a copy-paste hazard worth flagging.
4. llama.cpp — Requires poolside's fork at github.com/poolsideai/llama.cpp on the laguna branch. Upstream support is under active review at pull request ggml-org/llama.cpp#25165; once merged, Laguna weights will be accessible without the fork.

The quickest path to a running local server for most developers is vLLM with the INT4 or FP8 checkpoint:

pip install vllm
vllm serve poolside/Laguna-S-2.1-FP8 \
  --tensor-parallel-size 4 \
  --tool-call-parser poolside_v1 \
  --reasoning-parser poolside_v1 \
  --enable-auto-tool-choice \
  --default-chat-template-kwargs '{"enable_thinking": true}'

This command produces an OpenAI-compatible endpoint with thinking, tool use, and the poolside_v1 parsers active out of the box — roughly the configuration poolside recommends for production agentic coding pipelines. This kind of self-hostable, reasoning-native coding agent stands in sharp contrast to closed approaches where even the vendor cannot reliably ship LLM-powered features on schedule.

---

License and Acceptable Use: What You Can Actually Do With It

Laguna S 2.1 is released under the OpenMDW-1.1 license, which poolside describes as permitting users to "use and modify the model and associated materials freely for commercial and non-commercial purposes." This is notably more permissive than many large model licenses that restrict revenue-generating applications or impose per-user traffic thresholds above which separate agreements are required.

Restrictions flow through poolside's separate Acceptable Use Policy (AUP) — a common structure in the open-weight AI space. The base license is broad, but the AUP carves out prohibited applications, typically including weapons development, harmful content generation, and circumvention of safety guardrails. Poolside explicitly states that circumventing safety guardrails is disallowed unless the operator implements "substantially equivalent mitigations" — a clause designed to accommodate legitimate red-teaming and security research without enabling wholesale misuse. Security vulnerabilities can be reported to security@poolside.ai.

For enterprise teams evaluating open-weight models against proprietary APIs, the combination of a commercially permissive license and self-hostable weights addresses two of the most common adoption blockers: data residency requirements and total cost of ownership. Note, too, that if you use a free hosted tier (for example OpenRouter's free Laguna endpoints) rather than self-hosting, your inputs and outputs may be used to train and improve poolside's models — a trade-off worth weighing for IP-sensitive workloads. This open-weights trend is increasingly central to how AI capability spreads globally, pressuring closed API providers to compete on quality rather than access.

---

Community Reception: What Developers Are Saying

Laguna S 2.1 debuted as a trending model on Hugging Face, where its model card is available at huggingface.co/poolside/Laguna-S-2.1 and reports roughly 3,056 downloads in its first month. Two recurring themes have emerged in poolside Laguna Reddit communities and Hugging Face comments:

• Trajectory transparency: Poolside's decision to publish full evaluation trajectories at trajectories.poolside.ai has been positively received. Benchmark numbers without trajectories are easy to inflate via prompt engineering; making actual agent rollouts inspectable lets the community verify how the model solves problems, not just whether it reaches the right answer. This matters especially for SWE-bench-style evaluations, where scaffolding choices can strongly influence scores.
• Access options: Because the models are both downloadable weights and available through OpenRouter and Vercel AI Gateway — including free ($0/M) hosted tiers — developers without GPU infrastructure can still evaluate the family, at the cost of allowing their traffic to be used for model improvement on the free tiers. The impending deprecation of poolside Laguna M.1 ("going away July 28, 2026" per OpenRouter) is a live topic in poolside Laguna M.1 Reddit discussions, with users weighing whether to build on M.1 or migrate to S 2.1.

The poolside Laguna XS 2.1 at 33B-A3B is the natural choice for developers who want Laguna-family architecture and behaviour on a single consumer or prosumer GPU, running a 262K-token context rather than S 2.1's full 1M.

---

Key Takeaways

• 118B total, 8B active: Laguna S 2.1's MoE design means inference cost scales with activated parameters — roughly 8B per token — making it dramatically cheaper to run than its total parameter count suggests.
• 1M-token context (S 2.1 only): Laguna S 2.1's 1,048,576-token window is purpose-built for agentic coding scenarios; the smaller XS 2.1 and larger M.1 both use a 262,144-token (256K) window.
• Competitive benchmarks at lower compute: Matches or outperforms much larger models on SWE-bench Multilingual (78.5%), SWE-Bench Pro (59.4%), and DeepSWE (40.4%), with full evaluation trajectories published for independent verification.
• Three-tier Laguna family: Laguna XS 2.1 (33B-A3B, 256K ctx), Laguna S 2.1 (118B-A8B, 1M ctx), and Laguna M.1 (225B-A23B, 256K ctx) span edge deployment to maximum coding capability, all sharing a common architecture and tokenizer.
• Both open weights and hosted access: All variants are free to download and self-host under OpenMDW-1.1, and are also served via OpenRouter and Vercel AI Gateway — including free ($0/M) tiers (with a note that free-tier traffic may train poolside's models). Laguna M.1's hosted endpoints are slated for removal on 28 July 2026.
• Production-ready quantisation: FP8, INT4, NVFP4 and GGUF checkpoints are published; a matched DFlash draft model enables speculative decoding to cut serving latency further.
• Four inference frameworks: vLLM, SGLang, TRT-LLM, and llama.cpp (via poolside's fork) all documented with OpenAI-compatible endpoints and poolside_v1 parsers for tool use and reasoning.
• OpenMDW-1.1 license: Permits free commercial use and modification, subject to poolside's Acceptable Use Policy — a developer-friendly position for enterprise self-hosting and fine-tuning.
• Interleaved thinking: Native reasoning between tool calls, controllable per request; poolside recommends preserving reasoning content across turns in agentic pipelines.

---

What Comes Next for Poolside Laguna

The most immediate near-term development is upstream llama.cpp support: poolside's fork at github.com/poolsideai/llama.cpp works today, but the pull request at ggml-org/llama.cpp#25165 would bring Laguna support into the mainline project. If merged, Laguna S 2.1 would become accessible to the much larger audience running local inference via LM Studio, Ollama, and similar consumer-hardware tools — likely expanding GGUF adoption and community testing.

A second near-term shift is on the hosted side: OpenRouter lists Laguna M.1 and its free variant as "going away July 28, 2026," so the family's flagship-tier hosted access is being retired even as the weights remain downloadable. Teams relying on M.1 through a managed gateway should plan a migration path — most likely to Laguna S 2.1, which retains both paid and free hosted endpoints.

At the capability frontier, the benchmark table indicates where gaps remain: third-party-reported Kimi K3 (2800B-A50B) leads Terminal-Bench 2.1 at 88.3% and DeepSWE at 69%, and DeepSeek-V4-Pro Max edges Laguna on Toolathlon Verified. Poolside's roadmap will likely involve closing those gaps in a future Laguna iteration — possibly a 2.2 or 3.x series. The broader pattern — domain-specialised, efficiency-focused open-weight models where training objective focus compensates for raw parameter count — is likely to intensify across the industry. And as AI agents are increasingly trusted with real security-sensitive engineering tasks, the auditability, self-hostability, and transparent benchmarking approach of models like Laguna S 2.1 will become even more commercially and ethically relevant.