JURNITI°
Login
All guides
pool logo
pool

Self-Host Poolside pool on a Server, 24/7

Run Poolside's pool coding agent on its own Firecracker microVM. Laguna-native, ACP-ready, BYOK. 30-day money-back.

Poolside trained its Laguna models inside an agent harness. That harness is pool — a terminal TUI, an ACP server for editors, an ACP client for other agents, and a headless pool exec for CI. Hosting "just any coding agent" with Laguna is fine; hosting pool is what the models were optimized for. Here's the clean setup: run pool on its own always-on Firecracker microVM. Give it root there, wire MCP and AGENTS.md, and a bad tool call stays contained to a box you can rebuild — booting in about 124ms.

What pool is

pool is Poolside's coding agent. Install once:

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

Then run pool in any project. Interactive mode has slash commands, @ file fuzzy search, shell mode with !, and mode cycling (Always ask / Accept edits / Allow all / Plan). Spec support is first-class: AGENTS.md, Skills, MCP, and ACP.

It also speaks agent protocols outside the TUI:

  • pool acp — ACP server for Zed, JetBrains, Xcode, and any ACP client
  • pool --agent-server … — drive Claude Agent, Codex, or remote ACP over HTTP
  • pool exec — one-shot non-interactive runs for scripts and CI

Auth is flexible: pool login (including OpenRouter) or POOLSIDE_API_KEY for automation. Config and credentials live under ~/.config/poolside/ (settings.yaml + credentials.json).

Why a real microVM for pool

pool acts. It runs tools, edits the workspace, and can connect to remote MCP servers with headers and env that hold secrets. On a laptop, that blast radius is your whole home directory. A shared container still shares the host kernel.

jurniti gives pool its own Firecracker microVM — its own kernel, a KVM hardware boundary, one tenant per box. Give pool room to work inside its own VM and a runaway command, a misbehaving MCP server, or a prompt-injection stays on that box. Reprovision and you're clean in seconds.

You keep your model relationship. jurniti's BYOK is architectural: pool login or export POOLSIDE_API_KEY=…, and the key lives only in your VM. Traffic leaves straight for Poolside inference or OpenRouter; jurniti is never in the path, and no token is marked up.

Most pool work runs comfortably on Starter (1 vCPU / 2 GiB). And it's reversible: a 30-day money-back guarantee, workspace kept 7 days after cancellation.

Run pool in 3 steps

By hand this is a VPS, the install script, EULA accept, PATH, login, MCP config, and a unit file you maintain forever. jurniti runs the box; you keep the agent.

1. Pick a plan and pay

Starter is enough for pool. Check out, and the provision chain runs automatically the moment payment confirms.

2. Your microVM boots with pool ready

A fresh Ubuntu microVM boots with the pool binary pre-installed and on your PATH. You get an in-browser terminal — nothing to SSH into. Authenticate and go:

pool login                 # Poolside account or OpenRouter
# or: export POOLSIDE_API_KEY=...
pool                       # interactive TUI in the current project

3. Put it to work

Hand pool a task, add MCP servers with pool mcp add, drop an AGENTS.md, and let it run. Settings and project wiring live on the persistent home, so they survive every restart.

Give pool its own microVM

What people run pool for

  • Laguna-native agentic coding. Use the harness the models were RL-trained in, not a generic shell wrapper.
  • ACP in the cloud. Point an editor ACP client at a remote microVM, or run pool acp as the server.
  • Headless CI jobs. pool exec -p "…" -o json on an always-on box without parking a laptop.
  • MCP-heavy workflows. settings.yaml MCP servers and permissions, scrubbed cleanly when you publish a template.

Snapshot a configured agent into a template and fork it for the next job — your settings and AGENTS.md, never your credentials.

jurniti vs a laptop vs a DIY VPS

jurnitiYour laptopDIY VPS
Always onYesNo — it sleepsYes
Isolation for an agent that runs toolsFirecracker microVM (KVM)Your whole machineShared kernel
Provider keysYours, never leave the VMYoursYours
MCP / tool blast radiusOne disposable microVMYour whole machineYour whole server
SetupAutomatic · ~3 min to liveLocal installManual
Refund30-day money-backn/aNone

Pricing

Starter is $25/mo ($250/year, two months free) and runs pool for most work. Pro is $49/mo and Max $99/mo for heavier repos or more concurrent tool use. Every plan includes the 30-day money-back guarantee, and your model spend is separate and never marked up.

Running a different agent? See the guides for Goose, Claude Code, and OpenCode, or compare plans on the pricing page.

Frequently asked questions

What is pool?
pool is Poolside's coding agent. It runs in your terminal as an interactive TUI, as an ACP server inside editors (Zed, JetBrains, Xcode), as an ACP client driving other agents, or non-interactively with `pool exec`. Laguna models were trained with reinforcement learning inside this harness — they perform best in pool, though any ACP client works.
Can I run pool on a server?
Yes. pool is terminal-first and designed to act on a real machine — edit files, run tools, drive MCP servers. An always-on microVM lets it work without tying up your laptop. jurniti boots pool pre-installed on a dedicated Firecracker box with an in-browser terminal and a persistent home.
Do I need my own API key for pool?
Yes. jurniti is bring-your-own-key. Run `pool login` (Poolside account or OpenRouter) or set `POOLSIDE_API_KEY`. Credentials live only in your VM under ~/.config/poolside/credentials.json. Traffic goes straight to the provider; jurniti never sees your tokens or marks up usage.
Why does pool belong on a microVM instead of my laptop?
Because pool can run shell tools, fetch the web, and talk to MCP servers. On your laptop a wrong move or a poisoned tool has the run of your files. On jurniti, pool gets root inside its own Firecracker microVM with its own kernel and a KVM boundary, so the blast radius is one disposable box you can rebuild in seconds.
How much does it cost to host pool?
Plans start at $25/mo ($250/year — two months free), and every plan has a 30-day money-back guarantee. pool runs comfortably on Starter (1 vCPU / 2 GiB) for most work. Your model spend (Poolside Laguna API, OpenRouter, etc.) is separate and never marked up.
Is this an official Poolside product?
No. jurniti is independent managed hosting for the pool agent. We install the upstream binary at bake time from downloads.poolside.ai — no fork — so you run the real pool and pick your own models, MCP servers, and version.