Laguna S 2.1 Thinking Mode: From 60% to 70% Terminal-Bench With One Toggle

Laguna S 2.1 ships with two operational modes: thinking and non-thinking. The performance difference between them is not subtle. It is one of the largest thinking-mode gains in any current model:

• Terminal-Bench: 60.4% to 70.2% (+9.8 points, +16.2% relative)
• DeepSWE: 16.5% to 40.4% (+23.9 points, +145% relative)

That DeepSWE number means thinking mode makes the model nearly 2.5x more effective on the hardest agentic coding tasks. Understanding when and how to use each mode directly impacts how much value you get from the model.

What Thinking Mode Actually Does

In non-thinking mode, Laguna S 2.1 generates responses directly. It reads your prompt and produces output in a single forward pass per token, with no internal deliberation visible in the generation.

In thinking mode, the model first generates an internal reasoning chain before producing its final response. This reasoning chain:

• Plans the approach to multi-step problems
• Considers alternative solutions
• Identifies potential failure points
• Structures the execution strategy

The thinking happens within the model’s 1M context window. The reasoning tokens consume context but produce dramatically better outcomes on complex tasks.

The Benchmark Evidence

Terminal-Bench: Planning Matters

Mode	Terminal-Bench 2.1
Non-thinking	60.4%
Thinking	70.2%
Improvement	+9.8 points (+16.2% relative)

Terminal-Bench tasks involve navigating files, writing code, running commands, and iterating across multiple steps. Thinking mode helps because it forces the model to plan its approach before acting. Instead of immediately editing the first file it sees, it reasons about which files are relevant, what the task requires, and what order of operations makes sense.

This is the same benefit you get when a human developer takes 30 seconds to think before typing. The planning overhead pays for itself in fewer wrong turns.

DeepSWE: Thinking Is Transformational

Mode	DeepSWE
Non-thinking	16.5%
Thinking	40.4%
Improvement	+23.9 points (+145% relative)

The DeepSWE improvement is extraordinary. This benchmark tests deep, multi-step problem solving that requires architectural decisions and sustained coherent execution. Without thinking, Laguna essentially cannot solve these problems (16.5% is near-random for many task categories). With thinking, it becomes genuinely capable.

This tells us something important: for complex tasks, the reasoning step is not a nice-to-have. It is the difference between a functional model and a non-functional one.

When to Use Thinking Mode

Always Use Thinking For:

• Multi-file refactoring: Tasks that touch multiple files need planning
• Bug diagnosis in unfamiliar code: Understanding call flows and side effects requires reasoning
• Architecture decisions: Choosing between approaches benefits from explicit deliberation
• Complex feature implementation: Anything over 50 lines of connected logic
• Tasks where the first attempt matters: When wrong answers are expensive to undo
• Working with the pool CLI on complex tasks

Use Non-Thinking For:

• Single-function generation: “Write a binary search” does not need planning
• Code completion: Inline suggestions where speed matters
• Simple explanations: “What does this function do?”
• Formatting and linting tasks: Mechanical transformations
• High-throughput batch processing: When you need maximum tokens per second
• Quick iterations where you will review anyway

The Speed Trade-off

Thinking mode generates more tokens (the reasoning chain plus the response). This means:

• Higher latency to first response token
• More total tokens generated (and consumed from context)
• Higher cost if paying per token at the 1M context tier

For the free tier on OpenRouter (256K context), thinking tokens consume context budget. For local deployments, they consume inference time. The trade-off is always: better results vs. faster results.

How to Enable Thinking Mode

Via OpenRouter API

{
  "model": "poolside/laguna-s-2.1",
  "messages": [
    {"role": "user", "content": "Refactor this module to use dependency injection"}
  ],
  "provider": {
    "require_parameters": true
  },
  "thinking": true
}

Via pool CLI

# Thinking enabled by default for complex tasks
pool --think "Implement a caching layer for the API"

# Disable thinking for simple tasks
pool --no-think "Add a docstring to this function"

Via Ollama

# Set thinking in the system prompt or model parameters
ollama run laguna-s-2.1 --system "Think step by step before responding"

Via vLLM

When serving with vLLM, thinking mode is controlled via the API request:

from openai import OpenAI

client = OpenAI(base_url="http://localhost:8000/v1", api_key="dummy")

response = client.chat.completions.create(
    model="poolside/laguna-s-2.1",
    messages=[{"role": "user", "content": "Your complex task here"}],
    extra_body={"thinking": True}
)

Thinking Mode With Coding Tools

With Aider

Aider supports thinking mode through model configuration:

# Configure Aider to use thinking mode
aider --model openrouter/poolside/laguna-s-2.1 --thinking

For complex refactoring tasks in Aider, thinking mode significantly improves first-attempt success rates. For simple edits, disable it to save context and time.

With Claude Code-style Workflows

If you use tools similar to Claude Code or the various CLI coding agents, thinking mode improves multi-step task completion. The planning phase helps the agent:

• Choose better tool sequences
• Avoid unnecessary file reads
• Plan edits across multiple files coherently
• Recover from errors more gracefully

Understanding the Reasoning Chain

When thinking mode is active, Laguna S 2.1 generates a reasoning chain that typically:

1. Restates the problem in its own terms
2. Identifies relevant context (files, functions, dependencies)
3. Considers approaches (usually 2-3 alternatives)
4. Selects an approach with justification
5. Plans execution steps in order
6. Executes the planned approach

You can observe this reasoning in API responses (the thinking tokens are usually returned separately or wrapped in special tags). Reviewing the reasoning chain is valuable for:

• Understanding why the model chose a particular approach
• Catching reasoning errors before they become code errors
• Learning how the model interprets your prompts

Optimizing Context Usage

With a 1M token context window, thinking tokens are less of a concern than with shorter-context models. But for long conversations or large codebases, efficient context management still matters.

Tips for managing thinking overhead:

• Start conversations with thinking mode for the initial complex task
• Switch to non-thinking for follow-up refinements
• Clear context periodically in long sessions
• Use the 1M context tier for tasks that truly need both thinking and large context

At the 256K free tier, thinking tokens compete with your codebase context. If you are filling 200K tokens with code, thinking mode has limited room. For these cases, either:

• Upgrade to 1M context ($0.10/$0.20 per million tokens)
• Reduce code context and rely on thinking
• Use non-thinking mode with more code context

Comparing to Other Models’ Thinking Modes

Most frontier models now offer thinking modes, but the improvement magnitude varies:

Model	Non-thinking	Thinking	Relative Gain
Laguna S 2.1 (T-Bench)	60.4%	70.2%	+16.2%
Laguna S 2.1 (DeepSWE)	16.5%	40.4%	+145%

Laguna’s DeepSWE improvement is among the largest thinking-mode gains published for any model. This suggests the base model has strong latent capability that thinking unlocks, likely due to the RLCEF training approach that teaches multi-step reasoning through code execution feedback.

For how Laguna’s thinking mode performance compares to other models overall, see our benchmark breakdown and comparison with Tencent Hy3.

Practical Workflow Recommendation

Here is how I recommend configuring thinking mode for daily development:

1. Default to thinking ON for any new task or conversation
2. Switch thinking OFF after the first response when iterating on small changes
3. Always use thinking for tasks involving 3+ files
4. Never use thinking for autocomplete or single-line generation
5. Review thinking chains when the model produces unexpected results

The pool CLI handles this automatically for many cases, defaulting to thinking for complex operations and non-thinking for quick responses. If you use Aider or other tools, configure the toggle based on task complexity.

FAQ

Does thinking mode cost more?

On the paid 1M context tier ($0.10/$0.20 per million tokens), yes, because thinking generates additional output tokens. On the free 256K tier, it consumes context budget but no money. For self-hosted deployments, it costs inference time but no API fees.

Can I see the thinking tokens?

Yes, most API configurations return thinking tokens separately from the final response. This lets you inspect the model’s reasoning, which is valuable for debugging and understanding its decision process.

Should I always use thinking mode?

No. For simple tasks (single-function generation, explanations, formatting), non-thinking mode is faster and sufficient. The 60.4% Terminal-Bench score in non-thinking mode is still competitive. Reserve thinking for tasks that genuinely benefit from planning.

How long are typical thinking chains?

It varies by task complexity. Simple tasks might generate 100-300 thinking tokens. Complex multi-file tasks can generate 1000-3000+ thinking tokens. The model adapts its reasoning depth to the task, but you can also constrain it via max_tokens parameters.

Does thinking mode work with the 1M context window?

Yes. Both thinking and non-thinking modes support the full 1M context window. Thinking tokens are generated within the context window alongside your input and the model’s response. The 1M window is large enough that thinking overhead rarely becomes a constraint.