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

- Published: 2026-07-21 · Updated: 2026-07-21 · jurniti
- Canonical: https://www.jurniti.com/blog/pool-hosting

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](/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](https://poolside.ai)'s coding agent. Install once:

```bash
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](/pricing) 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](/pricing) 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:

```bash
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.

## 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](/templates) and fork it for the next job — your settings and AGENTS.md, never your credentials.

## jurniti vs a laptop vs a DIY VPS

| | jurniti | Your laptop | DIY VPS |
|---|---|---|---|
| Always on | Yes | No — it sleeps | Yes |
| Isolation for an agent that runs tools | Firecracker microVM (KVM) | Your whole machine | Shared kernel |
| Provider keys | Yours, never leave the VM | Yours | Yours |
| MCP / tool blast radius | One disposable microVM | Your whole machine | Your whole server |
| Setup | Automatic · ~3 min to live | Local install | Manual |
| Refund | 30-day money-back | n/a | None |

## 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](/blog/goose-ai-agent-hosting), [Claude Code](/blog/claude-code-hosting), and [OpenCode](/blog/opencode-hosting), or compare plans on the [pricing page](/pricing).

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