TL;DR:
poolis Poolside’s CLI coding agent (v1.0.1). Install with one curl, authenticate via browser, and you get Laguna M.1 (128K MoE) for free. The EULA lets you own your output but trains on your prompts by default. Opt out atopt-out@poolside.ai.
The Company Behind Pool
Poolside (Poolside AI) is a San Francisco-based AI lab founded in 2023 by Jason Warner (former CTO of GitHub) and Eiso Kant (software entrepreneur). The company has ~150 employees worldwide, with offices in San Francisco and Paris. They run monthly concentrated work weeks at the Paris branch.
Mission and Vision
Poolside’s stated mission: for artificial general intelligence to drive abundance for humanity. Their strategic thesis is that software engineering is the fastest path to AGI because it requires understanding the world, multi-step complex reasoning, and long-horizon planning. They’re starting with high-consequence enterprise software rather than consumer applications.
They believe in reinforcement learning from deployments — models improve based on what their agents learn in real enterprise environments, creating a feedback loop between field performance and model training.
Funding and Valuation
| Round | Date | Amount | Key Investors | Valuation |
|---|---|---|---|---|
| Seed | 2023 | $26M | Xavier Niel, others | — |
| Series A | 2023 | $100M | — | — |
| Series B | Oct 2024 | $500M | Bain Capital, eBay, Nvidia | $3B |
| Strategic | Oct 2025 | Up to $1B | Nvidia | $12B |
Total raised: over $1.6 billion. The Nvidia strategic investment is notable — it’s not just financial but also secures access to frontier-scale GPU clusters (40,000+ NVIDIA GB300 NVL72 systems via CoreWeave).
Products and Platform
Poolside builds the full stack: foundation models, agents, orchestration, and enterprise deployment infrastructure.
Models:
| Model | Params (total/active) | Type | Context | License |
|---|---|---|---|---|
| Laguna M.1 | 225B / 23B | MoE | 128K | Proprietary |
| Laguna XS.2 | 33B / 3B | MoE | 128K | Apache 2.0 (open weights) |
| Malibu 2.2 | Dense | Dense | 128K | Proprietary |
| Point | Dense | Dense | 64K | Proprietary |
Laguna M.1 benchmarks (from Poolside’s own evaluation, April 2026):
| Benchmark | Laguna M.1 | Claude Sonnet 4.6 | Qwen 3.5 |
|---|---|---|---|
| SWE-bench Verified | 72.5 | 79.6 | 76.2 |
| SWE-bench Multilingual | 67.3 | — | 69.3 |
| SWE-bench Pro | 46.9 | — | 50.9 |
| Terminal-Bench 2.0 | 40.7 | 59.1 | 52.5 |
Laguna XS.2 is notable: 3B active parameters, runs on a single GPU, Apache 2.0, available on Hugging Face. Positioned as an efficient local coding model.
Platform products:
- pool — terminal-based coding agent (this guide)
- Shimmer — cloud dev environment for iterating on web apps, APIs, and CLIs
- Poolside Console — admin dashboard for governance, auditing, metrics
- Poolside Assistant — IDE extensions (VS Code, Zed, JetBrains, Visual Studio)
- Bridge (via Fern Labs acquisition) — multi-agent orchestration for production environments
Infrastructure: Project Horizon
In October 2025, Poolside announced Project Horizon: a 2 GW AI campus in Pecos County, West Texas. Key details:
- 568 acres on the Longfellow Ranch (500,000-acre Mitchell family property)
- 8 phases of 250 MW each
- Behind-the-meter power from natural gas (aero-derivative turbines with SCR emissions control)
- Air-cooled (avoids water consumption issues)
- Dual long-haul fiber routes
- CoreWeave partnership: 40,000+ GB300 NVL72 GPUs starting Dec 2025; 15-year anchor lease for first 250 MW phase
- Hybrid modular build — factory-built components delivered fully integrated
- Each phase operates independently, allowing incremental capacity activation
This gives Poolside vertical integration over compute and energy — they control the full stack from power generation to model training.
The Model Factory
Poolside’s internal training infrastructure, called the Model Factory, is their system for building, training, and evaluating foundation models at scale. It automates the full lifecycle: data gathering, training (distributed across GPU clusters), inference, evaluation, and post-training. They’ve published a series of technical blog posts detailing each component:
- Titan — distributed training framework
- Carrier and Beacon — inference and evaluation infrastructure
- Code execution environment — sandboxed environment for testing generated code
- C2C Activation Offloading — technique for running MoE models efficiently on NVIDIA Grace Blackwell
Acquisitions and Partnerships
Fern Labs (acquired Nov 2025): London-based forward-deployed research engineering company. Founded by ex-Palantir engineers (Ash Edwards, Alex Goddijn, Taylor Young). Built Bridge, a multi-agent orchestration layer for high-stakes production environments. Poolside now embeds research engineers directly with enterprise clients.
Redpanda (strategic partnership, Oct 2025): Gives Poolside agents access to 300+ enterprise data sources through Redpanda’s streaming data platform. Combined with Oxla (acquired by Redpanda), agents get a query engine for live data access inside enterprise firewalls.
AWS (Dec 2024): Strategic partnership to deploy Poolside models on Amazon Bedrock and EC2. Enables BYOC (bring-your-own-cloud) deployments.
Defense contracts: Poolside has signed contracts with RTX Corporation and other defense industrial base companies. Also targeting Israeli defense companies.
What This Means for Free Tier Users
Poolside’s primary business is enterprise — government, defense, Global 2000. The free tier for pool and the API is likely a developer adoption play: get developers familiar with the models, build usage patterns, and convert to paid enterprise contracts. Key implications:
- Laguna M.1 (their best model) is free “for a limited time” via API and OpenRouter
- Laguna XS.2 is Apache 2.0 — permanently free, self-hostable
- The free tier may disappear or become restricted as the product matures
- Enterprise features (Console, Sandboxes, Managed Agents) are behind paid plans
- Their real differentiation is deployment inside your security boundary (on-prem, VPC, air-gapped) — not the free CLI
What is Pool
pool is Poolside’s terminal-native coding agent. It runs in four modes:
| Mode | How | Use case |
|---|---|---|
| Interactive TUI | pool in your project dir | Day-to-day coding |
| ACP server | pool acp | Editor integration (VS Code, Zed, JetBrains) |
| ACP client | pool --agent-server <cmd> | Drive other agents (Claude, Codex, Gemini) |
| Non-interactive | pool exec -p "..." | CI pipelines, scripts |
Poolside’s models:
| Model | Context | Type | Modes |
|---|---|---|---|
| Laguna M.1 | 128K | MoE | Agentic, Chat |
| Laguna XS.2 | 128K | MoE | Agentic, Chat |
| Malibu 2.2 | 128K | Dense | Agentic, Chat |
| Point | 64K | Dense | Completion |
Installation
Linux and macOS:
curl -fsSL https://downloads.poolside.ai/pool/install.sh | shWindows (preview):
irm https://downloads.poolside.ai/pool/install.ps1 | iexVerify:
pool --version# 1.0.1Authentication
Run pool in any project directory. On first launch it opens a browser window to authenticate. Your API token gets stored at:
~/.config/poolside/credentials.jsonFor CI/automation, set the environment variable instead:
export POOLSIDE_API_KEY="your-token-here"pool checks this env var before reading the credentials file.
Quick Start
cd your-projectpoolInteractive features:
| Shortcut | Action |
|---|---|
/ | Slash commands |
@ | Fuzzy file/directory search |
! | Shell mode |
Shift+Tab | Cycle through approval modes |
Double Esc | Rewind to previous message |
? or /help | All commands and shortcuts |
Approval Modes
| Mode | ID | Behavior |
|---|---|---|
| Always ask | default | Prompts on first use of each tool type |
| Accept edits | accept-edits | Auto-approves file reads and writes |
| Allow all | allow-all | Approves everything automatically |
| Plan | plan | Plans without modifying files |
Switch with Shift+Tab or /mode <id>.
ACP Server Mode (Editor Integration)
pool acp runs as an Agent Client Protocol server. This is how editors connect to it.
Zed
pool acp setup --editor zedThis writes to ~/.config/zed/settings.json:
{ "agent_servers": { "Poolside": { "command": "pool", "args": ["acp"], "type": "custom" } }}JetBrains
pool acp setup --editor jetbrainsWrites to ~/.jetbrains/acp.json.
Generic
Point any ACP-compatible editor at pool acp:
{ "command": "pool", "args": ["acp", "--reasoning", "high"]}ACP server features include session persistence (session/list, session/load), slash commands advertised to the client, and configurable mode/model options.
ACP Client Mode (Driving Other Agents)
By default pool connects to Poolside’s built-in agent. You can point it at any other ACP server:
# Claude Agentnpm install -g @agentclientprotocol/claude-agent-acppool --agent-server claude-agent-acp
# Codexnpm install -g @zed-industries/codex-acppool --agent-server codex-acp
# Gemininpm install -g @google/gemini-clipool --agent-server "gemini --acp"Set a non-Poolside default in ~/.config/poolside/pool.json:
{ "agent_servers": { "default": { "command": "claude-agent-acp" } }}Flags after -- are forwarded to the upstream ACP server:
pool -- --reasoning highNon-Interactive Mode
# Inline promptpool exec -p "scan cmd/cli code for vulnerabilities" -o json --unsafe-auto-allow
# From filepool exec -f prompt.txt -o json
# Enqueue prompts on start (v1.0.1+)pool -q "fix all lint errors" "write tests for auth module"MCP Server Integration
# Stdio-basedpool mcp add filesystem -- node filesystem-server.js
# HTTP remotepool mcp add --transport http notion https://mcp.notion.com/mcp
# SSE remotepool mcp add --transport sse linear https://mcp.linear.app/sse
# With env varspool mcp add --env API_KEY=your-key myserver -- npx -y myserver-mcp
# With auth headerspool mcp add --transport http --header "Authorization: Bearer $TOKEN" svc https://example.com/mcpManage:
pool mcp listpool mcp get <name>pool mcp remove <name>Servers are stored in ~/.config/poolside/settings.yaml under mcp_servers. Per-project servers go in .poolside/settings.yaml.
Permissions
Three scopes, most specific wins:
| File | Scope |
|---|---|
.poolside/settings.local.yaml | Per-project, gitignored |
.poolside/settings.yaml | Per-project, checked in |
~/.config/poolside/settings.yaml | Personal defaults |
Tool permissions:
tools: shell: allow: - "git log *" - "rg *" deny: - "rm *" - "git push *"Path permissions:
paths: allow: - path: ~/Documents/** - path: ~/workspace/docs/** write: true deny: - path: ~/.ssh/** - path: ~/.envRules: paths are read-only by default (add write: true), deny overrides allow, * wildcards supported but not ** for tool rules. Subshells and piped commands always require manual approval.
Spec Support
- AGENTS.md: Automatically reads project AGENTS.md files for context
- Skills: Loads from
.agent/skills/(v1.0.1+) for reusable workflows - MCP: Connect external tools and data sources
- ACP: Server/client for editor integration
Configuration Files
~/.config/poolside/ settings.yaml # CLI settings, MCP servers, permissions credentials.json # API token pool.json # Agent server defaultsRun pool config to print all paths. Run pool config settings to open settings.yaml in your editor.
EULA: What You Need to Know
Poolside’s EULA (last updated April 27, 2026) governs all use. Key points:
What You CAN Do
- Own your output. Section 3.2: you keep rights to both Customer Input and Customer Output. Poolside does not claim ownership of generated code.
- Use output commercially. The EULA does not prohibit commercial use of generated code in your projects.
- Opt out of training. Email
opt-out@poolside.aiwith your name, email, and contact method. Poolside must stop using your content for model training.
What You CANNOT Do
- Resell or sublicense the API as a standalone service (Section 2.2.8)
- Service bureau use — no commercial time-sharing or wrapping Poolside as your own paid API (Section 2.2.9)
- Train competing models — no using outputs to fine-tune or build AI that competes with Poolside (Section 2.2.3)
- Model extraction — no probing to reverse-engineer weights, architecture, or training data (Section 2.2.4)
- Process sensitive data — no biometric, PHI, financial, government ID data without written permission (Section 2.2.13)
- Regulated decision-making — no credit scoring, hiring, healthcare, autonomous vehicles, critical infrastructure (Section 2.2.15)
Training on Your Data
By default, Poolside can and will use your prompts and outputs to train their models (Section 4). This is opt-out, not opt-in. Even after opting out, they can still use content if:
- You provide feedback (ratings, comments) on your sessions
- Your content is flagged for safety review
Feedback Trap
If you use the /feedback command or rate outputs, you grant Poolside a worldwide, perpetual, irrevocable, royalty-free license to use that feedback including the associated input/output (Section 6.2). This is broad — it covers the actual conversation content, not just the rating itself.
Liability
Maximum liability: the greater of fees paid in 12 months or $100 (Section 10). No consequential damages except gross negligence. You indemnify Poolside for anything arising from your use (Section 9).
The Arbitration Clause
Disputes go to binding arbitration in San Francisco, administered by JAMS. You waive class action rights. Poolside pays arbitration fees for claims under $75,000. You can opt out within 30 days of first accepting the agreement by mailing written notice to their San Francisco address (Section 12.2).
Practical Takeaways
| Concern | Verdict |
|---|---|
| Use generated code in commercial projects | Yes, you own it |
| Send proprietary code to Poolside | Risky — they can train on it by default |
| Wrap Poolside as your own SaaS API | No, Section 2.2.8-2.2.9 |
| Use for open-source contributions | Yes, with opt-out recommended |
| CI/CD automation | Yes, pool exec supports this |
| Feed rated conversations to Poolside | Grants them perpetual license to that content |
Recommendation: Opt out of training before using pool on any non-trivial codebase. Email opt-out@poolside.ai. Avoid the /feedback command on sessions containing proprietary code — the feedback grant is broad and irrevocable.
References
- pool GitHub repository — https://github.com/poolsideai/pool
- Poolside EULA — https://poolside.ai/legal/eula (April 27, 2026)
- Poolside Documentation — https://docs.poolside.ai
- Supported Models — https://docs.poolside.ai/get-started/supported-models
- Agent Client Protocol spec — https://github.com/AcpProtocol/acp
- Poolside Products — https://poolside.ai/products
- Poolside Wikipedia — https://en.wikipedia.org/wiki/Poolside_AI
- Introducing Laguna XS.2 and Laguna M.1 — https://poolside.ai/blog/introducing-laguna-xs2-m1 (April 28, 2026)
- Announcing Project Horizon — https://poolside.ai/blog/announcing-project-horizon (October 15, 2025)
- Fern Labs acquisition — https://poolside.ai/blog/fern-labs-acquisition (November 18, 2025)
- Redpanda partnership — https://poolside.ai/blog/partnering-with-redpanda (October 28, 2025)
- Nvidia to invest up to $1B in Poolside — Bloomberg (October 2025)
- Poolside raises $500M from Bain Capital — Fortune (October 2024)
- Poolside AI targets Israel’s defense sector — Globes (December 2025)
