Poolside Pool CLI: A New Coding Agent to Rival Claude Code

Poolside ships their own terminal-based coding agent called pool. It is their answer to Claude Code, designed from the ground up to work with Laguna S 2.1 and its 1M token context window.

The pitch is simple: a first-party agent that knows exactly how to leverage Laguna’s strengths. No adapter layers, no compromises for multi-model compatibility, no third-party dependencies. Just a terminal tool built specifically for the model that scored 70.2% on Terminal-Bench and 40.4% on DeepSWE.

What Is pool?

Pool is a command-line coding agent. You run it in your terminal, point it at a task, and it:

• Reads and navigates your codebase
• Plans an approach (using thinking mode for complex tasks)
• Writes and edits code across multiple files
• Runs commands and tests
• Iterates based on results
• Uses Laguna S 2.1’s full 1M context when needed

If you have used Claude Code, the workflow is familiar. The difference is that pool is optimized for Laguna’s specific capabilities, particularly its MoE architecture, thinking mode, and extended context.

Getting Started

Installation

# Install via npm
npm install -g @poolside/pool

# Or via pip
pip install poolside-pool

# Verify installation
pool --version

Basic Configuration

# Connect to OpenRouter (free at 256K)
pool config set provider openrouter
pool config set model laguna-s-2.1

# Or connect to local deployment
pool config set endpoint http://localhost:8000
pool config set model laguna-s-2.1

First Use

# Navigate to your project
cd your-project

# Start an interactive session
pool

# Or give a specific task
pool "Add input validation to the user registration endpoint"

Core Features

Codebase-Aware Context

Pool automatically indexes your project structure and builds context from relevant files. With Laguna’s 1M token context window, it can include:

• Your entire project structure
• Full contents of relevant files (not just snippets)
• Test files that verify the code being modified
• Documentation and type definitions
• Previous conversation turns

For a typical medium-sized project (50K-200K tokens), pool can hold the entire codebase in context simultaneously. No context management gymnastics required.

Thinking Mode Integration

Pool automatically manages thinking mode based on task complexity:

• Simple tasks (rename, add docstring): non-thinking mode for speed
• Complex tasks (refactor, implement feature): thinking mode for accuracy
• You can override with --think or --no-think flags

This maps directly to the benchmark evidence: thinking mode boosts Terminal-Bench from 60.4% to 70.2% and DeepSWE from 16.5% to 40.4%. Pool leverages this automatically.

Multi-Step Execution

Pool excels at tasks that require many sequential steps. The browser engine case study (50 minutes, 181 steps) demonstrates this capability. In practice, this means pool can:

# Complex multi-file task
pool "Migrate the authentication system from session-based to JWT tokens"

# Pool will:
# 1. Read all auth-related files
# 2. Plan the migration (thinking mode)
# 3. Update middleware, routes, and models
# 4. Modify tests
# 5. Run tests and fix failures
# 6. Verify the complete migration works

Test-Driven Workflow

Pool integrates naturally with test suites:

# Fix a failing test
pool "The test in tests/auth_test.py::test_token_refresh is failing. Fix it."

# Implement a feature test-first
pool "Write tests for a rate limiter, then implement it to pass those tests"

This aligns with Laguna’s RLCEF training approach. The model learned from code execution feedback, so it naturally writes code that passes tests rather than code that merely looks correct.

Pool vs Claude Code

Similarities

Both are terminal coding agents that:

• Run in your terminal
• Read and write project files
• Execute commands and interpret results
• Iterate on solutions
• Support multi-turn conversations

Key Differences

Feature	pool	Claude Code
Underlying model	Laguna S 2.1 (8B active)	Claude models
Context window	1M tokens	200K tokens
Cost	Free (256K) / $0.10-0.20 (1M)	$2/$10 (Sonnet 5)
Self-hosting	Yes	No
Model lock-in	Poolside models only	Anthropic models only
Maturity	New (July 2026)	Established
Thinking control	Explicit toggle	Automatic

The biggest practical differences:

1. Cost: Pool with Laguna is free at 256K vs Claude Code at $2/$10. Heavy users save hundreds per month.
2. Context: 1M vs 200K tokens. Pool can hold 5x more codebase in context.
3. Self-hosting: You can run pool against a local Laguna deployment. Claude Code requires Anthropic’s API.
4. Maturity: Claude Code has been iterated on longer and has a deeper community of users and guides.

For a broader look at CLI coding agents, see our comparison of Mimo Code, Zcode, and Claude Code.

Pool vs Aider

Aider is model-agnostic. It works with any OpenAI-compatible API, which means you can use it with Laguna S 2.1 via OpenRouter or a local deployment.

So when would you choose pool over Aider with Laguna?

Choose pool when:

• You want first-party integration with Laguna’s thinking mode and context management
• You prefer an opinionated tool that handles configuration automatically
• You want the tightest possible integration with Laguna’s capabilities
• You are fully committed to the Poolside ecosystem

Choose Aider when:

• You want to switch between models easily (use Laguna for some tasks, other models for others)
• You prefer a mature tool with extensive documentation and community
• You need model-agnostic workflows
• You use multiple LLM providers

Both are valid choices. The beauty of open weights is that you are not locked into either tool.

Advanced Usage

Custom System Prompts

# Set project-specific instructions
pool config set system-prompt "This is a Django project using PostgreSQL. Always use type hints. Write tests with pytest."

# Per-session override
pool --system "Focus on performance. Prefer generators over lists." "Optimize the data pipeline"

Context Management

# Include specific files in context
pool --include "src/auth/**" "Fix the token refresh logic"

# Exclude large generated files
pool --exclude "*.generated.ts" "Refactor the API layer"

# Show what's in context
pool context show

Local Model Integration

# Point pool at a local Ollama instance
pool config set endpoint http://localhost:11434
pool config set model laguna-s-2.1

# Or vLLM
pool config set endpoint http://localhost:8000/v1
pool config set model poolside/laguna-s-2.1

See our local deployment guide and Ollama guide for setting up local inference.

Batch Operations

# Apply changes across multiple files
pool "Add error handling to all API endpoints in src/routes/"

# Code review mode
pool review "Check this PR for security issues"

Performance Expectations

Based on Laguna S 2.1’s benchmarks and the case studies:

What pool handles well:

• Multi-file refactoring across 10+ files
• Feature implementation from description
• Bug diagnosis and fixing
• Test generation and validation
• Documentation generation from code
• Dependency upgrades with breaking changes

What pushes its limits:

• Tasks requiring more than 200+ steps (browser engine was 181 steps, near the edge)
• Highly domain-specific code without relevant context
• Tasks requiring real-time external data
• GUI/visual output verification

The 70.2% Terminal-Bench score means roughly 7 in 10 terminal-based coding tasks succeed. For the other 3, pool will attempt the task and you may need to provide guidance, clarify requirements, or iterate.

Best Practices

Start Broad, Narrow Down

# Start with a high-level task
pool "Implement user notifications"

# If the first approach is not quite right, refine
pool "The notifications should be real-time via WebSocket, not polling"

Use Thinking Mode for Architecture

# Force thinking for design decisions
pool --think "Design a caching strategy for this API. Consider Redis vs in-memory."

Let It Run Tests

Pool works best when your project has tests. After making changes, it can run your test suite and iterate on failures. This mirrors the RLCEF training approach where the model learned from execution feedback.

# Pool will run tests automatically if configured
pool config set test-command "npm test"
pool "Add pagination to the /users endpoint"
# Pool implements, runs tests, fixes any failures

Commit Checkpoints

# Enable auto-commits for safety
pool config set auto-commit true
pool "Refactor the database layer"
# Pool commits after each successful step, making it easy to revert

The Ecosystem Play

Pool is part of Poolside’s broader strategy: a vertically integrated coding AI stack.

• Model: Laguna S 2.1 (open weights, free API)
• Agent: pool CLI (terminal coding)
• Hosting: OpenRouter (free at 256K), self-hosted, or Poolside API
• Community: Open weights mean community fine-tunes and improvements

This compares to Anthropic’s stack (Claude models + Claude Code) but with the crucial difference of being open. You can swap out any component: use pool with a different model, use Laguna with Aider, or self-host everything.

For the broader AI coding tools landscape, see our best AI coding tools 2026 guide.

FAQ

Is pool free to use?

Pool itself is free and open-source. The underlying model (Laguna S 2.1) is free on OpenRouter at 256K context. So yes, the entire stack can be used at zero cost. Self-hosting makes it permanently free regardless of usage volume.

Can I use pool with models other than Laguna?

Pool is designed for Laguna models and optimized for their specific capabilities (thinking mode, MoE architecture, 1M context). It may work with other OpenAI-compatible models but without the Laguna-specific optimizations.

How does pool compare to Claude Code for daily development?

Pool is newer and less mature but offers 5x more context (1M vs 200K) at dramatically lower cost (free vs $2/$10). Claude Code has better documentation, larger community, and more refined UX. Try both and see which fits your workflow.

Can pool handle large monorepos?

With 1M token context, pool can hold significantly more code than most alternatives. A typical large TypeScript monorepo (100K-500K tokens of relevant source) fits comfortably. For truly massive repos (millions of lines), you would still need to scope which packages pool operates on.

Does pool work with my IDE?

Pool is terminal-native. It works alongside your IDE rather than inside it. You run it in a terminal window while your IDE remains open. Some IDE terminal integrations (VS Code integrated terminal, for example) provide a smooth workflow where pool edits files and your IDE shows changes in real time.