Poolside Laguna S 2.1: A 118B Open-Weight Coding Model With 1M Context
Poolside has released Laguna S 2.1 , its most capable publicly available coding model to date.
Poolside Laguna S 2.1: A 118B Open-Weight Coding Model With 1M Context
Introduction
Poolside has released Laguna S 2.1, its most capable publicly available coding model to date.
The model is built for agentic software engineering and long-horizon work. It has 118 billion total parameters, activates roughly 8 billion parameters per token, and supports a context window of up to 1,048,576 tokens in both thinking and no-thinking modes.
Poolside has published the model weights under the OpenMDW-1.1 license. The company also provides several official checkpoint and quantization formats through Hugging Face, while OpenCode has made a free hosted version available for a limited period.
These details make Laguna S 2.1 an unusual release. It aims to deliver strong coding-agent performance without requiring every token to pass through the full 118-billion-parameter network, and it can be deployed privately by teams with sufficiently capable hardware.
At the same time, several claims surrounding the launch need context. The benchmark scores are primarily reported by Poolside, the full 1M-token capacity may not be exposed by every hosted provider, and “small enough for one DGX Spark” does not mean the model will run comfortably on an ordinary developer laptop.
What Is Laguna S 2.1?
Laguna S 2.1 is a text-to-text foundation model trained specifically for software engineering, terminal work, tool use, and coding-agent workflows.
It sits between two other Poolside models:
| Model | Total Parameters | Active Parameters per Token | Context Window | Positioning |
|---|---|---|---|---|
| Laguna XS 2.1 | 33B | 3B | 256K | Faster local and short-horizon coding |
| Laguna S 2.1 | 118B | About 8B | 1M | Stronger long-horizon agentic coding |
| Laguna M.1 | 225B | 23B | 256K | Larger model for complex agent tasks |
Poolside says Laguna S 2.1 moved from the beginning of training to release in less than nine weeks. It was trained on the same pre-training data family as Laguna XS 2.1, with scaling, training-code fixes, recipe changes, and new post-training work accounting for the improvement.
The company describes S 2.1 as its strongest current model for day-to-day feature work, multi-file changes, terminal tasks, and longer coding sessions.
Core Model Specifications
The official model card lists the following architecture:
| Specification | Laguna S 2.1 |
|---|---|
| Architecture | Mixture of Experts |
| Total parameters | 118B |
| Activated parameters | Approximately 8B per token |
| Layers | 48 |
| Global-attention layers | 12 |
| Sliding-window layers | 36 |
| Sliding-window size | 512 tokens |
| Routed experts | 256 |
| Experts selected | Top 10 |
| Shared experts | 1 |
| Context window | 1,048,576 tokens |
| Modality | Text input and text output |
| Reasoning | Interleaved thinking, controllable per request |
| Vocabulary | 100,352 tokens |
The model uses grouped-query attention and a mixture of global and sliding-window attention. Poolside also supplies a trained DFlash draft model for speculative decoding, which can reduce serving latency when the inference stack supports it.
How the Mixture-of-Experts Design Works
Laguna S 2.1 contains 118 billion parameters, but it does not activate all of them for every token.
Its router selects a subset of experts for each token, with approximately 8 billion parameters participating in the active computation. This is the main reason Poolside can describe the model as relatively efficient compared with dense models of similar total size.
A simplified comparison looks like this:
| Dense Model | Mixture-of-Experts Model |
|---|---|
| Most parameters participate in every token | Only selected experts participate |
| Compute rises closely with total size | Compute can remain far below total size |
| Simpler routing behavior | More complex routing and serving |
| Memory still depends on full model weights | Memory also depends on full weights and chosen precision |
The efficiency advantage should not be confused with a small memory footprint.
Even if only 8 billion parameters are active for a token, the system still needs access to the complete expert weights. The official GGUF files illustrate the practical scale:
| Official GGUF File | Approximate Size |
|---|---|
| F16 | 235 GB |
| Q8_0 | 128 GB |
| Q4_K_M | 75 GB |
| DFlash BF16 draft model | 2.2 GB |
A four-bit quantized version is considerably more manageable than the full-precision model, but 75 GB still requires a workstation with very high unified or accelerator memory, plus additional capacity for the context cache and runtime.
A Context Window of Up to One Million Tokens
The base model supports a maximum context length of 1,048,576 tokens.
For coding agents, a large context window can be useful when a task involves:
- A large repository.
- Many related source files.
- Long terminal histories.
- Build and test logs.
- API documentation.
- Architecture notes.
- Previous agent decisions.
- Multiple tool outputs.
- Long-running refactoring work.
A one-million-token limit does not mean every request should fill the entire window.
Long contexts increase memory use, prefill time, and serving cost. They can also introduce irrelevant information that makes the model’s job harder. A good coding-agent harness still needs file selection, retrieval, summarization, caching, and context management.
Hosted platforms may also expose a smaller limit than the underlying model supports. OpenCode’s launch announcement promoted 1M context, but users should check the current model entry and provider policy before designing a workflow around the maximum. Free or preview endpoints can change their context limits and availability.
Thinking and No-Thinking Modes
Laguna S 2.1 supports both reasoning-enabled and no-thinking operation.
In supported inference APIs, reasoning can be controlled per request through the enable_thinking option.
The two modes are suited to different jobs:
Thinking Mode
Thinking mode is intended for work that benefits from planning and intermediate reasoning, such as:
- Debugging complex failures.
- Coordinating changes across several files.
- Designing a migration.
- Investigating an unfamiliar repository.
- Running a sequence of terminal tools.
- Solving tasks with several possible approaches.
No-Thinking Mode
No-thinking mode can be more appropriate for:
- Small edits.
- Straightforward code generation.
- Formatting.
- Simple transformations.
- Low-latency completions.
- High-volume routine work.
Reasoning mode is not automatically better for every task. It generally consumes more tokens and can take longer. Teams should evaluate both modes on their own repositories and measure task completion rather than relying only on subjective output quality.
Poolside’s Reported Benchmark Results
Poolside reports the following results for Laguna S 2.1:
| Benchmark | Reported Score |
|---|---|
| Terminal-Bench 2.1 | 70.2% |
| SWE-Bench Multilingual | 78.5% |
| SWE-Bench Pro, public dataset | 59.4% |
| DeepSWE | 40.4% |
| SWE Atlas, Codebase Q&A | 46.2% |
| Toolathlon Verified | 49.7% |
Poolside says most scores are calculated as pass@1 and averaged over multiple attempts. Its public trajectory archive exposes runs from Terminal-Bench 2.1, which gives developers more visibility into how the agent approached individual tasks.
The results suggest that Laguna S 2.1 is competitive with several models that disclose much larger total parameter counts.
However, benchmark tables should be read carefully.
Benchmark Results Are Not Universal Product Rankings
Results can vary according to:
- Agent harness.
- System prompt.
- Tool definitions.
- Timeout.
- Number of attempts.
- Sampling settings.
- Test version.
- Repository setup.
- Inference precision.
- Context configuration.
- Whether a score comes from the model developer or an independent evaluator.
Poolside’s model page states that its comparison table may use the highest available figure from a vendor report, benchmark leaderboard, or third-party leaderboard for competing models. That method is useful for broad comparison, but it is not the same as running every model under one identical evaluation configuration.
The safest conclusion is that Laguna S 2.1 appears strong for its active-parameter class. A team choosing a production coding model should still test it on its own issues, repositories, toolchain, and review standards.
Open Weights Under the OpenMDW-1.1 License
Poolside has released Laguna S 2.1 under OpenMDW-1.1, a model-materials license maintained through the OpenMDW project.
The license grants broad rights to use, modify, and redistribute the model materials without a license fee, subject to its terms. A redistribution must retain the license and relevant copyright or origin notices.
It also states that output generated with the model is not restricted by the license.
For practical use, developers should distinguish several terms:
- Open weights: The trained model parameters are available to download.
- Open-source software: Source code is available under a software license that meets accepted open-source criteria.
- Open model: A broader term that may involve weights, architecture, documentation, training data, and training code.
Laguna S 2.1 is clearly an open-weight release. Poolside and OpenCode use stronger “open source” language in launch materials, but organizations should review the actual OpenMDW-1.1 text, Poolside’s responsible-use guidance, third-party dependencies, and their own legal requirements before redistribution or commercial deployment.
The license also provides the model materials without warranty. Users remain responsible for testing accuracy, security, suitability, and compliance.
Laguna S 2.1 Is Free on OpenCode for a Limited Time
OpenCode announced that Laguna S 2.1 is available through OpenCode Zen at no model-usage charge during a promotional period.
This provides a low-friction way to test the model without downloading a 75–235 GB checkpoint or operating local inference hardware.
OpenCode’s documentation makes two details important:
- The free availability is temporary.
- Inputs and outputs from the free Laguna S 2.1 service may be collected and used to improve the model.
Users should therefore avoid sending:
- Proprietary source code.
- Customer data.
- Credentials.
- Private keys.
- Confidential architecture documents.
- Security-sensitive logs.
- Regulated or personal information.
A free preview is useful for public repositories, synthetic projects, and low-risk evaluation. Private company code should be tested only after reviewing the platform’s current data policy, retention terms, workspace controls, and available paid or self-hosted options.
How to Try Laguna S 2.1
Option 1: Use the Free OpenCode Model
OpenCode can be installed with its official installer:
curl -fsSL https://opencode.ai/install | bash
After installation, connect OpenCode Zen and select the currently listed Laguna S 2.1 free model.
The exact model name, context limit, usage cap, and availability may change during the preview. Check the OpenCode Zen documentation and model selector before starting a long task.
Option 2: Run the Base Model With Docker Model Runner
The official Hugging Face model card provides this command:
docker model run hf.co/poolside/Laguna-S-2.1
The required download size and memory depend on the format selected by the runtime. Review the model files before pulling them onto a workstation or server.
Option 3: Serve the Official GGUF Quantization With llama.cpp
Poolside provides an official GGUF repository and a Laguna-compatible llama.cpp branch.
git clone --branch laguna https://github.com/poolsideai/llama.cpp
cd llama.cpp
cmake -B build
cmake --build build -j
./build/bin/llama-server \
-hf poolside/Laguna-S-2.1-GGUF:Q4_K_M \
--jinja \
--port 8000
The Q4_K_M file is approximately 75 GB. The system also needs memory for runtime overhead and the KV cache, particularly when using long contexts.
Option 4: Add DFlash Speculative Decoding
The official instructions include an optional DFlash draft model:
./build/bin/llama-server \
-m laguna-s-2.1-Q4_K_M.gguf \
-md laguna-s-2.1-DFlash-BF16.gguf \
--spec-type draft-dflash \
--spec-draft-n-max 15 \
-fa on \
--jinja \
--port 8000
Speculative decoding can improve generation speed, but the result depends on the hardware, prompt shape, context length, build configuration, and draft-model acceptance rate.
Can It Really Run on a Single NVIDIA DGX Spark?
Poolside states that Laguna S 2.1 is small enough to run on a single NVIDIA DGX Spark.
This is plausible for a suitable quantized checkpoint because DGX Spark is designed around a large unified-memory configuration. It does not imply that every model format, context size, or serving mode will fit at once.
Users should ask four separate questions:
- Can the weights be loaded?
- What context length fits after runtime overhead?
- What token speed is achieved?
- How many simultaneous agent sessions can the system serve?
A model that technically loads may still be too slow for interactive coding at an extreme context length. Independent measurements are needed for throughput, time to first token, power use, and concurrent workloads.
Community Reports of Local Deployment
The original AIBase report cited community tests using an Apple M3 Max system with 128 GB of unified memory and a Poolside llama.cpp fork.
The 75 GB Q4_K_M checkpoint makes this class of deployment technically credible, but the experience will vary considerably according to:
- Memory pressure.
- Context size.
- Quantization.
- Prompt length.
- CPU and GPU offload.
- Thermal limits.
- Speculative decoding.
- Other applications using unified memory.
A community report should not be treated as a guaranteed hardware recommendation. Developers should use the official file sizes and leave sufficient memory headroom before downloading the model.
Why Laguna S 2.1 Matters for Agentic Coding
Laguna S 2.1 reflects several broader changes in coding models.
Smaller Active Compute Is Becoming More Important
A very large total parameter count can provide capacity, while sparse activation helps keep per-token compute manageable.
This makes MoE designs attractive for coding agents that may run for many minutes or hours.
Long Context Is Moving Into Open-Weight Models
A one-million-token window was once associated mainly with hosted proprietary models. Its appearance in an open-weight coding release gives teams more control over long-repository experimentation and private deployment.
The Agent Harness Matters
Poolside trains Laguna models inside its own agent harness and says they perform best in that environment or another Agent Client Protocol-compatible client.
Coding benchmarks measure a model-plus-agent system, not just raw next-token prediction. Tool use, context selection, retry logic, terminal access, and patch application can materially affect performance.
Open Weights Expand Deployment Choices
Organizations can inspect the files, choose their own runtime, quantize the model, deploy it on private infrastructure, and connect it to an internal coding agent.
That flexibility is valuable for privacy-sensitive source code and environments with restricted network access.
Limitations to Consider Before Production Use
Text-Only Modality
The official model card describes Laguna S 2.1 as text-to-text. It is not presented as a native image, audio, or video model.
High Memory Requirements
The active parameter count is small relative to the full model, but the complete weights remain large. Ordinary laptops will not be suitable for the official high-quality formats.
Long Context Can Be Expensive
A 1M-token maximum is not the same as efficient 1M-token daily use. Prefill latency and KV-cache memory can become substantial.
Benchmarks Need Internal Validation
A strong public coding score does not guarantee good performance on a company’s language mix, build system, coding standards, or private frameworks.
Free Hosted Access Has Data Implications
OpenCode’s free-period documentation says collected inputs and outputs may be used for model improvement. Confidential code should not be submitted without an approved policy.
Agentic Coding Can Modify Real Systems
Any coding agent may delete files, execute commands, change dependencies, or introduce security flaws when given broad permissions.
Use:
- Version control.
- Isolated workspaces.
- Least-privilege credentials.
- Human review.
- Test environments.
- Backups.
- Command approvals.
Who Should Evaluate Laguna S 2.1?
Laguna S 2.1 is most relevant to:
- Teams building autonomous coding agents.
- Developers evaluating alternatives to proprietary coding APIs.
- Organizations that need private model deployment.
- Researchers studying long-horizon software engineering.
- Infrastructure teams with large-memory workstations or servers.
- Tool builders using OpenAI-compatible or ACP-based agent clients.
It may be less suitable for:
- Lightweight laptop-only workflows.
- Simple autocomplete.
- Mobile deployment.
- Teams without the infrastructure to operate a 75 GB or larger model.
- High-risk production automation without strong sandboxing.
- Workloads requiring native multimodal input.
Frequently Asked Questions
What is Poolside Laguna S 2.1?
Laguna S 2.1 is a 118B-parameter Mixture-of-Experts model designed for agentic coding and long-horizon software-engineering tasks. It activates approximately 8B parameters per token and supports up to a 1,048,576-token context window.
Is Laguna S 2.1 fully open source?
Its weights are publicly available under the OpenMDW-1.1 license, so “open-weight” is the clearest description. Users should review the license, model documentation, acceptable-use guidance, and any third-party components before redistribution or commercial deployment.
Is Laguna S 2.1 free on OpenCode?
OpenCode currently lists a free Laguna S 2.1 option for a limited period. Availability, context limits, rate limits, and data-use terms can change, so check the current OpenCode Zen documentation before relying on it.
Does the free OpenCode version have a 1M-token context window?
OpenCode’s announcement promotes 1M context, matching the base model’s maximum. Hosted endpoints can enforce different limits, so verify the active model configuration in OpenCode before sending an extremely long context.
Can Laguna S 2.1 run on a Mac?
Community reports indicate that a quantized build can run on a high-memory Apple Silicon system, including a 128 GB M3 Max configuration. Performance and usable context will depend on the quantization, runtime, available memory, and system load.
Can Laguna S 2.1 run on one DGX Spark?
Poolside says an appropriate version can run on a single NVIDIA DGX Spark. The achievable context, token speed, and concurrency depend on the checkpoint format and serving setup.
What are Laguna S 2.1’s benchmark scores?
Poolside reports 70.2% on Terminal-Bench 2.1, 78.5% on SWE-Bench Multilingual, 59.4% on the public SWE-Bench Pro dataset, and 40.4% on DeepSWE. These figures should be evaluated alongside the company’s methodology and independent tests.
Does Laguna S 2.1 support reasoning control?
Yes. The official model card states that it supports interleaved thinking and allows reasoning to be enabled or disabled per request in compatible serving systems.
Related Tools
- Poolside: The company developing the Laguna family of foundation models for agentic coding.
- OpenCode: An open-source coding agent that currently includes limited-time free Laguna S 2.1 access.
- Hugging Face: The official repository for Laguna S 2.1 weights, documentation, formats, and usage guidance.
- llama.cpp: A local inference runtime with ongoing support for Laguna-family GGUF models.
- Docker Model Runner: Docker tooling for downloading and serving supported local models.
- OpenRouter: A hosted API option for accessing Poolside’s model through an OpenAI-compatible interface.
Related Links
- Official Laguna S 2.1 Release: Poolside’s launch article covering the architecture, training, and benchmark positioning.
- Laguna S 2.1 Model Card: Official specifications, benchmark table, serving guidance, reasoning controls, and license information.
- Official Laguna S 2.1 GGUF Repository: Quantized file sizes and llama.cpp serving instructions.
- Laguna S 2.1 Trajectory Archive: Public agent traces from Poolside’s Terminal-Bench 2.1 evaluation.
- OpenCode Zen Documentation: Current free-model availability, usage policies, privacy terms, and account information.
- OpenMDW-1.1 License: The license governing the released model materials.
- Poolside Model Catalog: Official comparison of Laguna S 2.1, XS 2.1, and the wider Laguna model family.
Summary
Poolside Laguna S 2.1 combines 118B total parameters, roughly 8B active parameters per token, a one-million-token context window, controllable reasoning, and official open-weight releases in several formats.
Poolside reports strong results on terminal and software-engineering benchmarks, including 70.2% on Terminal-Bench 2.1 and 40.4% on DeepSWE. These results make the model notable for its size class, although teams should reproduce performance on their own repositories and agent harnesses.
OpenCode’s limited-time free access makes the model easy to test, while the downloadable weights enable private deployment. The trade-offs are significant memory requirements, changing hosted-service policies, and the normal operational risks of autonomous coding agents.
Laguna S 2.1 is a meaningful open-weight release for long-horizon coding, but its real value will depend on agent integration, deployment efficiency, and performance on real development work—not the 1M context label alone.