Laguna S 2.1 Benchmarks: When Thinking Mode Is Worth It
Laguna S 2.1 is an open-weight coding model from Poolside. As a 118-billion-parameter mixture-of-experts model with about 8 billion active parameters per token, it is available at very low listed prices on NanoGPT and positioned for long software tasks where verification and follow-through matter.
NanoGPT currently lists two hosted options:
- Laguna S 2.1 keeps thinking disabled for faster, more direct responses.
- Laguna S 2.1 Thinking spends more tokens reasoning through difficult coding and tool-use tasks.
The short version:
- Use the regular version for code questions, focused edits, quick reviews, and interactive work where you expect to guide the model.
- Use Thinking for repository-scale changes, difficult debugging, terminal agents, and tasks where checking and persistence matter more than speed.
- Do not enable Thinking by habit. Poolside's own results show that it can improve hard tasks substantially, but sometimes uses several times as many tokens.
- Treat the launch benchmarks as promising first-party evidence. Poolside publishes detailed methodology and full run logs, which it calls trajectories, but independent testing is still limited because the model is new.
What is Laguna S 2.1?
Laguna S 2.1 is a mixture-of-experts model with 118 billion parameters in total and about 8 billion active for each token. In plain language, it draws on a large model while using only part of it at a time. That helps explain how it can be inexpensive while remaining competitive on demanding coding tasks.
The practical details are:
- Text input and output
- A context window of up to 1,048,576 tokens
- NanoGPT currently lists responses of up to 131,072 tokens
- Tool calling for agent workflows
- Direct and Thinking variants
- Open weights under Poolside's OpenMDW-1.1 license
The million-token context window can hold a large amount of code and documentation, but it is not a guarantee that the model will notice every relevant detail. Give it the files that matter, explain the goal, and ask it to verify its work rather than dumping an entire repository into one prompt without direction.
What Poolside's benchmarks show
In Poolside's own published harness, with Thinking enabled, Laguna S 2.1 reports the following scores. These are useful first-party results, not a neutral cross-vendor tournament.
| Benchmark | Laguna S 2.1 | What it tests in plain language |
|---|---|---|
| Terminal-Bench 2.1 | 70.2% | Completing practical tasks through a terminal |
| SWE-Bench Multilingual | 78.5% | Fixing software issues across several programming languages |
| SWE-Bench Pro | 59.4% | Solving difficult problems in existing repositories |
| DeepSWE v1.1 | 40.4% | Sustained work on longer software-engineering tasks |
| SWE Atlas | 46.2% | Answering questions about a codebase |
| Toolathlon Verified | 49.7% | Using many different tools correctly |
Those results are strong for a model of this size. In Poolside's comparison table, which combines Poolside's own run with comparison numbers from other reported sources, Laguna S 2.1 is listed above Inkling and DeepSeek V4 Pro Max on Terminal-Bench 2.1 and SWE-Bench Pro. Its 78.5% on SWE-Bench Multilingual is effectively tied with the listed Qwen 3.7 Max result of 78.3%.
Poolside's launch table does not show Laguna S 2.1 leading every coding-agent benchmark. Kimi K3, Muse Spark 1.1, and several proprietary frontier models score higher on some of the harder tests. On SWE-Bench Pro, Laguna's 59.4% trails Qwen 3.7 Max at 60.6%, Muse Spark 1.1 at 61.5%, and Claude Fable 5 at 80.3% in the same table.
That is the right way to read the release. Laguna S 2.1 is not a small model beating every frontier system. It is an open-weight model with a relatively small active footprint, delivering useful performance on multi-step coding-agent tasks at a very low hosted price.
How much does Thinking mode help?
Poolside tested the same model with thinking disabled and enabled. The results show that extra reasoning matters most when a task requires persistence rather than one good guess.
| Benchmark | Direct mode, rounded | Thinking mode, rounded | Average output tokens, Direct → Thinking |
|---|---|---|---|
| SWE-Bench Multilingual | 71% | 79% | 23K → 101K |
| Terminal-Bench 2.1 | 60% | 70% | 80K → 129K |
| SWE-Bench Pro | 53% | 59% | 24K → 141K |
| DeepSWE v1.1 | 17% | 40% | 99K → 249K |
These are rounded values read from Poolside's direct-versus-thinking chart. The output-token totals are summed across complete multi-step agent trajectories; they do not include input tokens and do not represent one ordinary chat response.
DeepSWE v1.1 shows the strongest case for Thinking mode. The score more than doubles, but the model also produces about two and a half times as many output tokens. On SWE-Bench Pro, the gain is smaller while token use rises by almost six times.
The lesson is not that Thinking is too expensive. Extra reasoning should have a clear job. Use it when the model needs to inspect, test, recover from mistakes, or keep going through a long task. For a focused question or small edit, direct mode may get you to a useful answer faster.
What it costs on NanoGPT
NanoGPT currently lists the same pay-as-you-go rates for both hosted options:
- Input: $0.10 per million tokens
- Output: $0.20 per million tokens
- Cached input, meaning reused prompt or context tokens: $0.01 per million tokens
NanoGPT currently lists both hosted options as included in its subscription. Pricing, subscription availability, response limits, and API model IDs may change.
The low unit price makes long reasoning runs unusually affordable. At the listed output rate, 249,000 output tokens would cost about five cents before input-token costs. A real agent run can cost more because each step may send an increasingly large conversation back as input, but the overall price is still low compared with many hosted frontier coding models, based on NanoGPT's listed rates.
Thinking mode does not carry a higher price per token; it costs more only when it uses more tokens. This makes the direct-versus-thinking choice easier to understand: you are deciding how much work the model should do, not buying access to a separate premium model.
When to use regular Laguna S 2.1
Direct mode is the better starting point when you want a quick answer and can steer the work yourself.
Good uses include:
- Explaining an unfamiliar function or error
- Writing a focused unit test
- Reviewing a small change
- Suggesting a straightforward refactor
- Drafting a script or configuration file
- Finding likely causes of a well-scoped bug
- Answering questions from supplied code or documentation
It also makes sense during early exploration. If you are still deciding what to build, several quick exchanges are often more useful than one long autonomous attempt.
When to use Laguna S 2.1 Thinking
Thinking mode is better when the task has several dependent steps or the model needs to verify that the result actually works.
Use it for:
- Implementing a feature across multiple files
- Debugging a failure with several plausible causes
- Working through a repository with tests and tooling
- Planning a migration or difficult refactor
- Using terminal tools over many steps
- Comparing implementation approaches and their risks
- Reviewing a larger change for correctness and regressions
Give Thinking mode a clear stopping condition. For example, ask it to run the relevant tests, report any failures it could not resolve, and avoid changing unrelated files. A long-running reasoning mode can otherwise spend time improving things you did not ask it to touch.
Three limitations to know
Poolside openly lists several launch limitations.
First, Laguna may default to tool-call formats it has seen before, even when a different schema is provided. A rejected call and correction often fixes the problem, but it can make the first attempt unreliable.
Second, complex nested tool arguments can produce malformed JSON, especially when a tool expects an array. This matters more in automated agents than in normal chat. Treat tool errors as recoverable and validate structured arguments before executing consequential actions.
Third, Thinking mode can overthink. Poolside says the model may reason for a long time without making progress, especially on competition-style mathematics. There are currently two practical choices on NanoGPT—direct or Thinking—rather than several fine-grained effort levels.
These limitations make Thinking a selective tool: it can help with difficult verification, but it can also burn tokens overthinking simple problems.
What open weights means here
The weights are available now, including BF16 and several quantized versions. Poolside's OpenMDW-1.1 license permits commercial and non-commercial use subject to its license terms and acceptable-use policy.
Open weights does not make Laguna S 2.1 a laptop-sized model. Poolside estimates that the uncompressed BF16 (16-bit) weights—roughly two bytes per parameter—require about 236GB before allowing for the memory needed to run the model. Serving the full million-token context can require substantially more memory during inference. Quantization reduces the requirement, but most users will still find hosted access simpler.
The open release is nevertheless valuable. Researchers and companies can inspect and benchmark the same underlying model and, subject to the license, deploy or adapt it instead of relying exclusively on a closed API.
How trustworthy are the benchmarks?
Poolside deserves credit for publishing the evaluation trajectories rather than only a chart. Its launch post describes the harness, attempt counts, sandbox resources, and where comparison scores came from.
The results are still not a neutral tournament. Poolside evaluated its own model in its own agent harness, while many comparison numbers use model-maker reports or third-party leaderboards. Harness design, tool definitions, step limits, and reasoning settings can all change agent benchmark scores.
The fairest conclusion is that Laguna S 2.1 has a credible first-party case for strong coding performance within its size and price class. Independent results will be more useful for deciding how it compares across different coding agents and real repositories.
The bottom line
Laguna S 2.1 is interesting because its tradeoffs are unusually practical. It is open-weight, extremely inexpensive, available with a million-token context window, and strong enough in Poolside's reported benchmarks to complete a meaningful share of difficult coding-agent tasks.
Use the regular model as the default for quick coding help and interactive work. Switch to Thinking when the task needs verification, several tool calls, or recovery from mistakes. The gains can be real, but so is the token cost—use Thinking for work that actually needs it.
Try Laguna S 2.1 or Laguna S 2.1 Thinking on NanoGPT. API users can select poolside/laguna-s-2.1 or poolside/laguna-s-2.1:thinking through NanoGPT's OpenAI-compatible API.
