Laguna S 2.1 from Poolside is the first Western open-weight coding model that lets you build real, multi-step applications without paying per-token API fees or renting GPUs. It has 118 billion total parameters but activates only 8 billion per token through a Mixture-of-Experts design, which means it runs fast, costs almost nothing to serve, and yet scores 70.2% on Terminal-Bench 2.1 — a benchmark that tests multi-step terminal coding tasks, not single-line generation (Poolside launch blog). You can use it free on OpenRouter today or run it locally on a single workstation.
This guide shows you how to go from zero to a working application built with Laguna S 2.1 — choosing your access path, installing the right tool, writing effective agentic prompts, and shipping something real this week. If you want the deeper model background first, our Poolside Laguna S 2.1 open-weight model guide covers the architecture and benchmarks in detail; here we focus on building.
Last verified: 2026-07-30
- Laguna S 2.1: 118B total / 8B active MoE, 1M context, OpenMDW-1.1 license
- Free on OpenRouter (256K context), $0.10/$0.20 per 1M tokens for full 1M context
- Runs locally via vLLM, SGLang, Ollama, or llama.cpp (~67–75 GB at 4-bit)
- Pool CLI is Poolside's first-party terminal coding agent (free, open-source)
- Pricing and model availability change often — last checked July 30, 2026
What Makes Laguna S 2.1 Different From Other Coding Models?
Most open-weight coding models under 100 billion parameters struggle with multi-step tasks — they generate a plausible first draft but lose coherence around step three or four. Laguna S 2.1 breaks that pattern because Poolside trained it specifically for agentic, long-horizon work: the model runs code, inspects the output, fixes failures, and iterates until the task is done, rather than stopping at a plausible-looking answer.
The key is the 118B/8B Mixture-of-Experts split. Of 256 routed experts plus one shared expert, only 10 experts fire per token (Hugging Face model card). That keeps inference cost proportional to 8B, not 118B — which is why you can run it on a single NVIDIA DGX Spark at 50–77 tokens per second (explainx.ai analysis) or serve it through OpenRouter at a fraction of what equivalent dense models cost.
For context on where Laguna fits in the coding-model landscape, our Gemini 3.6 Flash vs Laguna S 2.1 comparison breaks down the tradeoffs between these two models released the same day.
Which Access Path Should You Choose?
| Access Path | Cost | Context | Setup Time | Best For |
|---|---|---|---|---|
| OpenRouter free tier | $0 | 256K tokens | 5 minutes | Trying it out, prototyping |
| OpenRouter paid (1M) | $0.10/$0.20 per 1M | 1M tokens | 5 minutes | Large codebase agentic work |
| Local via Ollama | $0 (own hardware) | 256K | 30 minutes | Privacy, unlimited use, offline |
| Local via vLLM/SGLang | $0 (own hardware) | Up to 1M | 1–2 hours | Production serving, team use |
| Pool CLI + OpenRouter | $0 | 256K | 10 minutes | Full agentic coding workflow |
Recommendation: Start with the OpenRouter free tier and Pool CLI for the fastest path to building something. If you need more context or want to self-host, move to vLLM or Ollama once you have a working prototype.
How to Set Up Laguna S 2.1 in 10 Minutes
Step 1: Get an OpenRouter API Key
- Create a free account at OpenRouter.
- Navigate to Keys and generate a new API key.
- The model ID for the free tier is
poolside/laguna-s-2.1:free(OpenRouter model page). - The free tier gives you 256K context at 200 requests per day — enough for prototyping and building.
Step 2: Install Pool CLI
Pool is Poolside's own terminal-based coding agent — their answer to Claude Code, built specifically to leverage Laguna's 1M context window and thinking mode (Pool CLI guide). It is free and open-source on GitHub.
# Install pool CLI
pip install poolside-pool
# Point it at OpenRouter's free Laguna endpoint
export OPENROUTER_API_KEY="your-key-here"
pool --model poolside/laguna-s-2.1:free --base-url https://openrouter.ai/api/v1
Alternatively, you can use any OpenAI-compatible client (Python openai library, Aider, Cline, or OpenCode) pointed at the same endpoint. Pool is simply the most optimized for Laguna's specific features.
Step 3: Try It Out in Your Terminal
# From your project directory
pool "Create a Python script that reads a CSV file,
counts duplicate rows, and outputs a clean version
with duplicates removed. Include error handling."
If everything is configured correctly, you will see Laguna read your project structure, plan an approach, write the code, and run it — all within a single session. The free 256K context is more than enough for a focused single-project build.
How to Write Prompts That Build Real Applications
The biggest mistake people make with coding models is writing vague prompts. Laguna S 2.1 is designed for long-horizon agentic tasks — meaning it excels when you give it a complete, specific specification and let it work through the implementation step by step.
The Three-Part Prompt Framework
Every effective build prompt with Laguna S 2.1 should contain:
- Goal: What the finished application does, in one sentence.
- Requirements: Specific features, technologies, and constraints — be concrete.
- Success criteria: How you know it works — tests, acceptance checks, or observable behavior.
Here is the difference in practice:
Bad prompt (too vague): "Build a landing page."
Good prompt (specific, action-oriented):
Build a single-page landing page with HTML, CSS, and vanilla JavaScript. It must include: (1) a hero section with a headline and a "Get Started" button above the fold, (2) a three-row feature grid comparing the free and paid plans, (3) a testimonial block with a placeholder quote and avatar, (4) a signup form that posts to a placeholder endpoint. Use a modern dark theme with an accent color. The page must be fully responsive and load in under 2 seconds. Verify the HTML validates and the form submits without errors.
The second prompt gives Laguna enough context to produce a working file in a single pass — the first will produce generic boilerplate you will have to rebuild.
What to Build: Seven Practical Projects
Each of the following projects is something you can build in a single session with Laguna S 2.1. These are not toy examples — they produce working, usable output:
1. Landing page generator — Give Laguna a one-paragraph description of your business and ask for a complete responsive landing page with a hero, feature grid, testimonials, and a contact form. The 1M context window means it can hold your brand guidelines in the same prompt.
2. Lead-follow-up automation — Ask Laguna to build a Python script that watches a webhook for new form submissions, sends a templatted welcome email within 60 seconds, tags the lead by source, and appends it to a simple dashboard. Use the schedule and requests libraries.
3. Onboarding portal — Build a static HTML onboarding flow with a welcome video, a checklist of first-day tasks, and a progress bar that fills as each item is completed. Laguna can produce the full HTML, CSS, and JavaScript in one pass.
4. Content repurposing tool — Give Laguna a transcript or article and ask it to extract three key quotes, write a short summary, and generate five social media captions. Build this as a Python CLI tool that reads a text file and outputs a formatted JSON response.
5. Searchable call archive — Build a lightweight SQLite-backed archive with a web search interface. Laguna can scaffold the Flask app, database schema, and search endpoint in one session.
6. Prompt library — Build a searchable collection of reusable AI prompts organized by tool and category. Laguna can produce the data model, the CRUD endpoints, and a simple web interface.
7. Referral tracker — Build a referral tracking system with unique links, click counting, a leaderboard, and a reward threshold flag. This is a full-stack app — Laguna handles the backend, routing, and a basic admin dashboard.
For each project, use the three-part prompt framework above. Start with thinking mode on (--think in pool CLI) for the architecture and initial build, then switch to non-thinking mode for iterative edits and small fixes.
When Should You Use Thinking Mode?
Laguna S 2.1 has a built-in reasoning toggle — thinking mode — that dramatically affects performance on complex tasks. The benchmark impact is significant:
| Benchmark | No Thinking | Thinking (Max) | Improvement |
|---|---|---|---|
| Terminal-Bench 2.1 | 60.4% | 70.2% | +16% relative |
| SWE-Bench Multi | ~71% | 78.5% | +11% relative |
| DeepSWE | 16.5% | 40.4% | +145% relative |
Source: Poolside benchmark data, as published on the Hugging Face model card and corroborated by third-party analyses (wan27.org).
The practical guidance is simple:
- Thinking ON for: multi-file features, architecture decisions, debugging complex issues, and anything over ~3 steps.
- Thinking OFF for: single-function generation, autocomplete, renaming, documentation, and quick edits.
In pool CLI, toggle thinking with --think or --no-think flags. The cost of thinking mode is roughly 1.6× more output tokens — so for a rapid iteration loop, start without thinking and escalate only if the model stalls.
How to Run Laguna S 2.1 Locally
If you need privacy, unlimited usage, or offline access, self-hosting is straightforward. The model fits in roughly 67–75 GB of memory at 4-bit quantization (AgentPedia deployment guide) — runnable on a single workstation with sufficient VRAM.
Option A: Ollama (Simplest)
# Pull and run the 4-bit quantized model
ollama run laguna-s-2.1
Ollama handles quantization and memory management automatically. This is the easiest path for local development. For a similar local coding agent setup with a different model, see our Ollama local coding agent guide.
Option B: vLLM (Production Serving)
# Install vLLM
pip install vllm
# Serve the model (requires vLLM 0.25.0+)
vllm serve poolside/Laguna-S-2.1 \
--trust-remote-code \
--host 127.0.0.1 \
--port 8000
vLLM gives you an OpenAI-compatible API endpoint, which means pool CLI, Aider, and any OpenAI-compatible client can connect. This is the right choice for a team or production environment. For a broader cost-optimization perspective, our LLM cost optimization guide covers model-agnostic serving architectures.
Option C: llama.cpp (Lightweight + DFlash)
Poolside maintains a llama.cpp fork with full Laguna support including DFlash speculative decoding, which can boost inference speed further:
git clone --branch laguna https://github.com/poolsideai/llama.cpp
cd llama.cpp && cmake -B build && cmake --build build -j
./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 7 \
-fa on --jinja --port 8000
Source: Official Hugging Face model card serving instructions.
How Does Laguna S 2.1 Compare to Other Coding Models?
| Model | Total / Active Params | Terminal-Bench 2.1 | SWE-Bench Multi | Context | Price (per 1M io) | Open Weights |
|---|---|---|---|---|---|---|
| Laguna S 2.1 | 118B / 8B | 70.2% | 78.5% | 1M | $0.10 / $0.20 | Yes (OpenMDW-1.1) |
| Kimi K3 | 2.8T total | 88.3% | — | 1M | $3.00 / $15.00 | Yes |
| DeepSeek V4 Pro Max | 1.6T / 49B | 64.0% | 76.2% | 163K | — | Yes |
| Inkling | 975B / 41B | 63.8% | — | 1M | — | Yes (Apache 2.0) |
| Tencent Hy3 | 295B / 21B | 71.7% | 75.8% | — | — | — |
Sources: Poolside benchmark table (marktechpost.com), OpenRouter pricing (openrouter.ai).
Laguna S 2.1 does not win every benchmark — Kimi K3 and Claude Fable 5 score higher on Terminal-Bench. But at 14× to 24× fewer active parameters and $0 on the free tier, it wins the price-performance ratio decisively. For builders who want control, cost predictability, and the ability to self-host, it is currently without peer in its weight class.
What This Means for You
If you are a developer, builder, or small business owner who has been waiting for an open-weight coding model that is actually practical for building real applications — Laguna S 2.1 is that model. The combination of 8B active parameters, 1M context, and a permissive license means you can build, iterate, and deploy without per-token anxiety.
Your action plan: Pick one of the seven projects above. Set up the free OpenRouter endpoint and pool CLI (10 minutes). Write a three-part prompt (goal + requirements + success criteria). Ship something this week. One good prompt with Laguna S 2.1 goes further than most people expect.
FAQ
Q: Is Laguna S 2.1 really free to use?
A: Yes. The free tier on OpenRouter (poolside/laguna-s-2.1:free) provides 256K context at 200 requests per day at no cost. The paid tier offers full 1M context at $0.10 per million input tokens and $0.20 per million output tokens. Self-hosting with Ollama or vLLM is permanently free regardless of usage volume — you only pay for electricity and hardware.
Q: What hardware do I need to run Laguna S 2.1 locally? A: At 4-bit quantization (GGUF Q4_K_M), the model fits in approximately 67–75 GB of memory. This runs on a single NVIDIA DGX Spark or a workstation with dual 4090 GPUs or a single A6000. The lighter Laguna XS 2.1 (33B total, 3B active) runs on a Mac with 36 GB of RAM if the full model is too large.
Q: Can Laguna S 2.1 build a full application in one session? A: Yes, for single-file or small multi-file applications. Poolside's own case studies include building a working HTML/CSS rendering engine from scratch in a 181-step, 50-minute session (benchgen.com). For larger applications, break the work into focused sessions and use thinking mode for architecture decisions.
Q: How does Laguna S 2.1 compare to Claude Code? A: Claude Code (Claude Fable 5) scores higher on Terminal-Bench (88.0% vs 70.2%) but costs $2/$10 per million tokens and offers 200K context. Pool CLI offers 5× more context (1M vs 200K) at dramatically lower cost (free vs premium). Claude Code has better documentation and a larger community; pool is newer but optimized specifically for Laguna's thinking mode and MoE architecture.
Q: What is thinking mode and when do I use it? A: Thinking mode enables Laguna's internal reasoning before generating output. It boosts Terminal-Bench scores from 60.4% to 70.2% and DeepSWE from 16.5% to 40.4%. Use thinking mode for complex multi-step tasks, architecture decisions, and debugging. Turn it off for simple edits and autocomplete — it increases output tokens by ~60% but has minimal benefit on straightforward tasks.
Q: What license does Laguna S 2.1 use? A: OpenMDW-1.1, which permits both commercial and non-commercial use and modification. Weights are available in BF16, FP8, INT4, and NVFP4 formats, plus official GGUF conversions, all published on Hugging Face.
Discussion
0 comments