📺 Watch the full tutorial on YouTube

🌊 Poolside Laguna S 2.1 Overview, Benchmarks & Tests

---

📌 Overview & Highlights

Poolside Laguna S 2.1 (poolside/Laguna-S-2.1) is a 118B total parameter Mixture-of-Experts (MoE) model featuring ~8B activated parameters per token, designed explicitly for long-horizon software engineering, agentic terminal tool-use, and single-file code synthesis.

Sitting strategically between Laguna XS 2.1 (33B-A3B) and Laguna M.1 (225B-A23B), Laguna S 2.1 leverages a token-choice router with softplus gating over 256 routed experts + 1 shared expert, grouped-query attention (GQA), and interleaved full/sliding-window attention.

🌟 Key Highlights

• 🧠 1M Token Context Window: Native 1,048,576-token context capacity for ingesting full codebases, repository slices, and extended multi-turn tool trajectories.
• 💭 Interleaved Native Reasoning (enable_thinking): Supports preserved internal thinking blocks between tool calls and execution turns for deep problem verification.
• ⚡ DFlash Speculative Decoding: Official paired draft model poolside/Laguna-S-2.1-DFlash for drastically reduced token generation latency.
• 🏗️ Hybrid SWA & Global Attention: 48 layers configured in a 1:3 global-to-sliding-window ratio (12 global, 36 SWA with window size 512) and per-head softplus output gating.
• 🔓 OpenMDW-1.1 License: Permissive open license allowing commercial and non-commercial execution, fine-tuning, and modification.

---

⚙️ Model Architecture & Technical Specifications

Parameter	Specification
Total Parameters	118 Billion
Active Parameters / Token	~8 Billion
Architecture Type	Token-Choice Mixture-of-Experts (MoE)
Routing Scheme	256 Routed Experts (Top-10 selection) + 1 Shared Expert
Total Layers	48 Layers (12 Global Attention, 36 Sliding Window Attention)
Attention Configuration	Grouped-Query Attention (GQA), 8 KV Heads, Head Dim 128
Sliding Window Size	512 Tokens
Context Window	1,048,576 Tokens (1M)
Vocabulary Size	100,352 Tokens (Laguna Family Tokenizer)
Reasoning Engine	Preserved native reasoning with enable_thinking control

---

📊 Benchmark Results

Model	Model Size	Terminal-Bench 2.1	SWE-bench Multilingual	SWE-bench Pro (Public)	DeepSWE	SWE Atlas (Repo Q&A)	Toolathlon Verified
Laguna S 2.1	118B-A8B	70.2%	78.5%	59.4%	40.4%	46.2%	49.7%
Tencent Hy3	295B-A21B	71.7%	75.8%	57.9%	—	—	—
Inkling	975B-A41B	63.8%	—	54.3%	—	—	45.5%*
Nemotron 3 Ultra	550B-A55B	56.4%	67.7%	—	—	—	34.3%*
DeepSeek-V4-Pro Max	1.6T-A49B	64.0%*	76.2%	55.4%	9.0%*	27.2%*	55.9%*
Kimi K3	2800B-A50B	88.3%	—	—	69.0%	—	—
Qwen 3.7 Max	—	74.5%*	78.3%	60.6%	—	—	—

Note

Scores marked with an asterisk (*) are reported by official third-party leaderboards (Artificial Analysis, Scale AI SWE Atlas, and Toolathlon Verified).

---

🚀 Installation & Serving Setup Guide

Laguna S 2.1 can be served locally via vLLM, SGLang, TensorRT-LLM, llama.cpp (GGUF), or accessed directly via managed cloud endpoints.

Option 1: vLLM Engine (Recommended for GPU Clusters)

# Install vLLM with Laguna support
pip install vllm --upgrade

# Launch vLLM server with tensor parallelism and thinking enabled
vllm serve \
    --model poolside/Laguna-S-2.1 \
    --tensor-parallel-size 4 \
    --tool-call-parser poolside_v1 \
    --reasoning-parser poolside_v1 \
    --enable-auto-tool-choice \
    --served-model-name laguna \
    --default-chat-template-kwargs '{"enable_thinking": true}'

Tip

Enabling DFlash Speculative Decoding: Add --speculative-config '{"model":"poolside/Laguna-S-2.1-DFlash","num_speculative_tokens":7,"method":"dflash"}' to achieve up to 3x faster generation speed.

Option 2: SGLang Server

pip install sglang --upgrade

python -m sglang.launch_server \
  --model-path poolside/Laguna-S-2.1 \
  --tp-size 4 \
  --reasoning-parser poolside_v1 \
  --tool-call-parser poolside_v1 \
  --trust-remote-code

Option 3: llama.cpp GGUF Quantized Execution

For local CPU/GPU offloading, download quantized GGUF variants from poolside/Laguna-S-2.1-GGUF.

# Clone the Poolside llama.cpp fork with Laguna support
git clone --branch laguna https://github.com/poolsideai/llama.cpp
cd llama.cpp && cmake -B build && cmake --build build -j

# Start llama-server
./build/bin/llama-server -m laguna-s-2.1-Q4_K_M.gguf --jinja --port 8000

# Optional: Accelerated with DFlash speculative decoding
./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

Option 4: Cloud API Providers (OpenRouter / Vercel AI Gateway)

import openai

client = openai.OpenAI(
    base_url="https://openrouter.ai/api/v1",
    api_key="YOUR_OPENROUTER_API_KEY",
)

response = client.chat.completions.create(
    model="poolside/laguna-s-2.1",
    messages=[{"role": "user", "content": "Hello Laguna S 2.1!"}],
    extra_body={"chat_template_kwargs": {"enable_thinking": True}}
)
print(response.choices[0].message.content)

---

📁 Repository Structure & Downloadable Test Attachments

Laguna 2.1/
├── README.md              # Main documentation, setup guide & benchmark specification
├── petstore.json          # Attachment for Test 1 (OpenAPI 3.0 specification file)
└── llm_engine.py          # Attachment for Test 3 (vLLM Engine source file for codebase debugging)

📎 Downloaded Test Attachments Included in this Folder

1. petstore.json (~17.1 KB)
   • Source: Official Swagger OpenAPI 3.0 Petstore Specification
   • Target Test: Test 1: The "PetStore API" Single-File Dashboard
2. llm_engine.py (~17.6 KB)
   • Source: vLLM Core Execution Engine Source Code (vllm/v1/engine/llm_engine.py)
   • Target Test: Test 3: The "1M Context Repo Debugger"

---

🛠️ Quickstart & Execution Steps

1. Setup Environment: Select your target serving infrastructure (local vLLM / SGLang / llama.cpp instance or OpenRouter / Vercel AI Gateway endpoint).
2. Verify Attachments: Ensure petstore.json and llm_engine.py are present in your workspace directory (already provided in this folder).
3. Configure Reasoning: Verify that enable_thinking: true is passed in your request body or server defaults to preserve interleaved thinking trajectories.
4. Execute Benchmark Prompts: Paste the prompts from the Benchmark Tests section into your client interface, attaching petstore.json for Test 1 and llm_engine.py for Test 3.
5. Evaluate Outputs: Review Laguna S 2.1's internal thinking traces, system log parsing accuracy, Python execution correctness, and synthesized UI aesthetics against each test's verification target.

---

💡 5 Core Use Cases

1. ⚡ Single-File Web Application Synthesis: Generating zero-dependency, self-contained HTML/CSS/JS frontend applications and interactive API explorers directly from OpenAPI/Swagger schemas.
2. 🔬 Autonomous Algorithm & State-Machine Design: Crafting complex zero-dependency algorithms (such as Raft consensus or custom LRU cache engines) using pure Python standard libraries.
3. 🔍 Ultra-Long Context Codebase Debugging: Ingesting up to 1,000,000 tokens of source code to locate deep race conditions, memory leaks, and concurrency bottlenecks across complex repositories.
4. 🚀 High-Throughput Async Systems Refactoring: Transforming legacy synchronous blocking Python code into high-throughput, async-native infrastructure.
5. 🛡️ Agentic Terminal & SRE Diagnostics: Serving as an autonomous system reliability agent (SRE) capable of diagnosing process trees, parsing system logs (/var/log), computing health metrics, and safe CLI remediation.

---

🔮 5 Future Features

1. 🤖 Automated Trajectory Verification Suite: Integration with Toolathlon and SWE-bench test runners for end-to-end automated trajectory scoring.
2. ⚡ Native DFlash Speculative Harness: Pre-configured benchmark utilities designed specifically to measure latency gains when running DFlash draft models.
3. 📊 Interactive Reasoning Visualizer: Web interface to inspect and compare Laguna S 2.1's step-by-step thinking blocks against synthesized code output.
4. 🛠️ Multi-Modal Schema Translation: Expanding Test 1 to generate dynamic frontend dashboards from Figma designs and ERD diagrams alongside OpenAPI specs.
5. 🌐 Live Containerized Terminal-Bench Sandbox: Dockerized local execution harness allowing Laguna S 2.1's terminal agents to run live remediation commands securely.

---

🧪 The 3 Poolside Laguna S 2.1 Benchmark Tests

---

Test 1: The "PetStore API" Single-File Dashboard

• Category: Single-File HTML UI Generation (Attachment-Based 📎)
• Objective: Evaluate Laguna S 2.1's capability to ingest an OpenAPI 3.0 schema and build a modern, interactive single-file dashboard with live mock API simulation.
• Attachment File: petstore.json (Included in this repo)

📝 Prompt to Paste into Laguna S 2.1:

(Attach petstore.json from the repository, then paste the following text)

"You are an expert frontend engineer. Attached is an open-source OpenAPI 3.0 specification file (petstore.json). 

Please write a single, completely standalone index.html file that implements a fully interactive API Explorer & Management Dashboard based on this specification. 

Requirements:
1. Include Tailwind CSS via CDN and use Vanilla JS/Alpine.js for interactive state.
2. Build a modern dark-mode sidebar layout with navigation for each endpoint (Pets, Orders, Store Status).
3. Include live mock data generation so users can click 'Execute Request' and see simulated REST API JSON responses with status codes (200, 400, 404).
4. Provide interactive filtering, real-time search across pets, and client-side form validation for creating new pet records.
5. Provide modern visual aesthetics (glassmorphism UI elements, status pill badges, animated response timers).

Return ONLY valid single-file HTML code wrapped in a markdown code block."

---

Test 2: The "Overthinking" Raft Consensus Engine

• Category: Interleaved Reasoning & Pure Python Algorithm
• Objective: Force Laguna S 2.1's native reasoning module (enable_thinking: true) to perform step-by-step verification of term state transitions, election timer logic, and state invariants before synthesizing a pure Python distributed simulation.

📝 Prompt to Paste into Laguna S 2.1:

"Act as a distributed systems architect. Build a single-file, pure-Python (zero external libraries) simulation of the Raft Consensus Algorithm for high-availability cluster state replication.

Requirements:
1. Implement a 5-node cluster using standard library asyncio queues to simulate network RPC messages (RequestVote and AppendEntries).
2. Simulate random network latency, packet loss (15% drop rate), and node heartbeat timeouts.
3. Demonstrate a dynamic Leader Failure scenario: forcibly stop Node 0 (current Leader), trigger a dynamic re-election among remaining nodes, elect a new Leader, write state entries, and rejoin Node 0 as a Follower.
4. Add state-invariant assertions verifying that no two leaders can be elected in the same term.

I want you to exercise your native internal reasoning (`enable_thinking`) to explicitly outline your term state transitions, election timer logic, and safety verification proofs before outputting the executable Python script."

---

Test 3: The "1M Context Repo Debugger"

• Category: Deep Codebase Debugging & Repo Q&A (Attachment-Based 📎)
• Objective: Benchmark Laguna S 2.1's 1M context window and SWE-Atlas codebase comprehension by inspecting core execution logic, identifying concurrency bottlenecks, and generating a non-breaking monkey patch.
• Attachment File: llm_engine.py (Included in this repo)

📝 Prompt to Paste into Laguna S 2.1:

(Attach llm_engine.py from the repository, then paste the following text)

"Attached is the full open-source Python engine file from the vLLM project repository (llm_engine.py). 

Perform a deep architectural review and long-horizon context analysis on this code:
1. Map out the full lifecycle of a request from initial arrival in `add_request()` to final completion step in `step()`.
2. Identify potential memory accumulation or lock-contention race conditions that could occur under high concurrency when dynamic request preemptions happen.
3. Write a single-file Python reproduction script using standard asyncio/unittest that mocks the scheduler state to reproduce a potential race condition scenario.
4. Output a precise Python patch (Monkey-patch or refactored subclass) fixing the concurrency bug without altering public API method signatures."

---

---

📜 License

This repository and Poolside Laguna S 2.1 specifications are distributed under the OpenMDW-1.1 License. For complete license terms, refer to the OpenMDW Specification.

---

Crafted with ❤️ for benchmarking Poolside Laguna S 2.1

---

🏷️ Keywords & Tags

Poolside Laguna S 2.1 Laguna 2.1 1M Context vLLM SGLang llama.cpp GGUF MoE Model Speculative Decoding DFlash OpenMDW SWE-bench Terminal-Bench AI Software Engineering Local LLM Poolside AI Local AI