Poolside Pool: Setup Guide, EULA Pitfalls, and What You Actually Get for Free

· 5 min read ai software-development

TL;DR: pool is 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 at opt-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

RoundDateAmountKey InvestorsValuation
Seed2023$26MXavier Niel, others
Series A2023$100M
Series BOct 2024$500MBain Capital, eBay, Nvidia$3B
StrategicOct 2025Up to $1BNvidia$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:

ModelParams (total/active)TypeContextLicense
Laguna M.1225B / 23BMoE128KProprietary
Laguna XS.233B / 3BMoE128KApache 2.0 (open weights)
Malibu 2.2DenseDense128KProprietary
PointDenseDense64KProprietary

Laguna M.1 benchmarks (from Poolside’s own evaluation, April 2026):

BenchmarkLaguna M.1Claude Sonnet 4.6Qwen 3.5
SWE-bench Verified72.579.676.2
SWE-bench Multilingual67.369.3
SWE-bench Pro46.950.9
Terminal-Bench 2.040.759.152.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:

ModeHowUse case
Interactive TUIpool in your project dirDay-to-day coding
ACP serverpool acpEditor integration (VS Code, Zed, JetBrains)
ACP clientpool --agent-server <cmd>Drive other agents (Claude, Codex, Gemini)
Non-interactivepool exec -p "..."CI pipelines, scripts

Poolside’s models:

ModelContextTypeModes
Laguna M.1128KMoEAgentic, Chat
Laguna XS.2128KMoEAgentic, Chat
Malibu 2.2128KDenseAgentic, Chat
Point64KDenseCompletion

Installation

Linux and macOS:

Terminal window
curl -fsSL https://downloads.poolside.ai/pool/install.sh | sh

Windows (preview):

Terminal window
irm https://downloads.poolside.ai/pool/install.ps1 | iex

Verify:

Terminal window
pool --version
# 1.0.1

Authentication

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.json

For CI/automation, set the environment variable instead:

Terminal window
export POOLSIDE_API_KEY="your-token-here"

pool checks this env var before reading the credentials file.

Quick Start

Terminal window
cd your-project
pool

Interactive features:

ShortcutAction
/Slash commands
@Fuzzy file/directory search
!Shell mode
Shift+TabCycle through approval modes
Double EscRewind to previous message
? or /helpAll commands and shortcuts

Approval Modes

ModeIDBehavior
Always askdefaultPrompts on first use of each tool type
Accept editsaccept-editsAuto-approves file reads and writes
Allow allallow-allApproves everything automatically
PlanplanPlans 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

Terminal window
pool acp setup --editor zed

This writes to ~/.config/zed/settings.json:

{
"agent_servers": {
"Poolside": {
"command": "pool",
"args": ["acp"],
"type": "custom"
}
}
}

JetBrains

Terminal window
pool acp setup --editor jetbrains

Writes 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:

Terminal window
# Claude Agent
npm install -g @agentclientprotocol/claude-agent-acp
pool --agent-server claude-agent-acp
# Codex
npm install -g @zed-industries/codex-acp
pool --agent-server codex-acp
# Gemini
npm install -g @google/gemini-cli
pool --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:

Terminal window
pool -- --reasoning high

Non-Interactive Mode

Terminal window
# Inline prompt
pool exec -p "scan cmd/cli code for vulnerabilities" -o json --unsafe-auto-allow
# From file
pool 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

Terminal window
# Stdio-based
pool mcp add filesystem -- node filesystem-server.js
# HTTP remote
pool mcp add --transport http notion https://mcp.notion.com/mcp
# SSE remote
pool mcp add --transport sse linear https://mcp.linear.app/sse
# With env vars
pool mcp add --env API_KEY=your-key myserver -- npx -y myserver-mcp
# With auth headers
pool mcp add --transport http --header "Authorization: Bearer $TOKEN" svc https://example.com/mcp

Manage:

Terminal window
pool mcp list
pool 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:

FileScope
.poolside/settings.local.yamlPer-project, gitignored
.poolside/settings.yamlPer-project, checked in
~/.config/poolside/settings.yamlPersonal 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: ~/.env

Rules: 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 defaults

Run 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.ai with 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

ConcernVerdict
Use generated code in commercial projectsYes, you own it
Send proprietary code to PoolsideRisky — they can train on it by default
Wrap Poolside as your own SaaS APINo, Section 2.2.8-2.2.9
Use for open-source contributionsYes, with opt-out recommended
CI/CD automationYes, pool exec supports this
Feed rated conversations to PoolsideGrants 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

  1. pool GitHub repositoryhttps://github.com/poolsideai/pool
  2. Poolside EULAhttps://poolside.ai/legal/eula (April 27, 2026)
  3. Poolside Documentationhttps://docs.poolside.ai
  4. Supported Modelshttps://docs.poolside.ai/get-started/supported-models
  5. Agent Client Protocol spechttps://github.com/AcpProtocol/acp
  6. Poolside Productshttps://poolside.ai/products
  7. Poolside Wikipediahttps://en.wikipedia.org/wiki/Poolside_AI
  8. Introducing Laguna XS.2 and Laguna M.1https://poolside.ai/blog/introducing-laguna-xs2-m1 (April 28, 2026)
  9. Announcing Project Horizonhttps://poolside.ai/blog/announcing-project-horizon (October 15, 2025)
  10. Fern Labs acquisitionhttps://poolside.ai/blog/fern-labs-acquisition (November 18, 2025)
  11. Redpanda partnershiphttps://poolside.ai/blog/partnering-with-redpanda (October 28, 2025)
  12. Nvidia to invest up to $1B in Poolside — Bloomberg (October 2025)
  13. Poolside raises $500M from Bain Capital — Fortune (October 2024)
  14. Poolside AI targets Israel’s defense sector — Globes (December 2025)