boat.dev (by ASCII) sells persistent Ubuntu VMs for agents: SSH in, Docker inside, a virtual desktop, pre-installed agent harnesses, and per-second billing with a $20 monthly minimum. Like Jilebi, it bets that agents deserve real computers — not containers. The two products agree on the primitive and differ on pricing, sizing, and networking posture.
TL;DR
| Dimension | Jilebi | boat.dev |
|---|---|---|
| Price model | ~$0.009/vCPU-hr + ~$0.009/GB-hr running, disk-only sleep, no minimum | $20/mo minimum buys |
| Best for cost | Light/casual use (no floor) and custom sizing | Heavy use inside the $20 pool — unit rates undercut Jilebi ~3x at 4 vCPU / 8 GB |
| Performance | ~50ms boot, auto-sleep/wake; 1–16 vCPU / 1–16 GB / 30–65 GB NVMe on bare metal | Fixed sizes (2/4/8 vCPU); stop/resume/fork from disk-level snapshots |
| Ease of use | Web console + SSH + software catalog | CLI + REST API + SDKs, pre-installed harnesses (boat prompt), host for public URLs |
| Technology | Cloud Hypervisor microVMs, btrfs snapshots, no public IP by default | Persistent Ubuntu VMs, Docker inside, dedicated IPv4/IPv6 per machine, 60fps virtual desktop |
Rates from public pages at the time of writing (September 2026); verify before deciding.
Price
This is the one comparison where we will tell you upfront: boat’s unit rates are lower than ours at the reference shape.
- boat.dev: $20/month minimum, which buys 2,000,000 VM-seconds (~555 hours) of default 4 vCPU / 8 GB time — about $0.036/hr. Small (2 vCPU / 4 GB) burns at 0.5x, large (8 vCPU / 16 GB) at 2x. A default box running 24/7 is ~$26/month.
- Jilebi: ~$0.009/vCPU-hr +
$0.009/GB-hr while running, disk-only while asleep, no minimum. The same 4 vCPU / 8 GB shape costs ≈ $0.108/hr running ($78/mo at 24/7, ~$26/mo at 8 hrs/day).
Worked example — one 4 vCPU / 8 GB box, 240 running hours/month:
- boat: 240 hrs × $0.036 ≈ $8.64, but the $20 floor applies — you pay $20.
- Jilebi: 240 hrs × $0.108 ≈ $25.92 + nominal sleep-disk.
So heavy, steady use favors boat, clearly. Where Jilebi wins on price: light use (20 running hours costs ~$2 with no floor vs boat’s $20 minimum), and non-standard shapes — boat sells fixed sizes while Jilebi lets a 2 vCPU / 12 GB or 16 vCPU / 4 GB box exist at exact cost.
Performance
- boat sandboxes are persistent VMs with stop/resume and fast disk-level fork-from-snapshot, in fixed sizes up to 8 vCPU / 16 GB. Pre-installed Rust/Node/Bun toolchains and Docker-inside-VM mean builds start fast without image prep.
- Jilebi boots new machines in ~50ms, auto-sleeps idle machines and wakes them on use, and offers free-form sizing up to 16 vCPUs, 16 GB RAM, and 65 GB NVMe per machine on bare-metal hosts — headroom boat’s fixed tiers don’t cover for very large compiles.
Both are hardware-isolated VMs, so the isolation story is comparable; the performance decision is fixed-size convenience (boat) vs sizing freedom and bigger ceilings (Jilebi).
Ease of use
boat is API/CLI-first and agent-native out of the box: boat prompt hands tasks to pre-installed harnesses (Claude Code, Codex, OpenCode, and others), survives stop/resume, keeps memory, and supports computer-use via a virtual desktop (60fps, Chrome, watch-it-live). boat host 3000 exposes a port on a public HTTPS URL, token-gated by default (--public to ungate). If you are building agent factories programmatically, boat’s SDK/REST surface is the more complete starting point today.
Jilebi is console-first with human onboarding: visual machine creation, SSH keys at setup, a software catalog (nix, opencode, claude code, codex, docker), selective port exposure on *.jilebi.dev with TLS, and auto-sleep you never think about. Less harness magic pre-installed, shorter path to “a computer I own.”
Technology
| Aspect | Jilebi | boat.dev |
|---|---|---|
| Virtualization | Cloud Hypervisor microVMs on bare metal | Persistent Ubuntu VMs (hardware-isolated) |
| Storage | Per-machine NVMe + btrfs snapshots | Disk-level snapshots, fork inherits state |
| Sizes | Any mix: 1–16 vCPU, 1–16 GB RAM, 30–65 GB NVMe | Fixed tiers: small 2/4, default 4/8, large 8/16 (GB) |
| Lifecycle | ~50ms boot, auto-sleep/wake, snapshot | Create / stop / resume / fork / delete, TTLs, resize up freely |
| Networking | No public IP; proxy SSH + selective TLS exposure | Dedicated IPv4/IPv6 per machine; host gives public HTTPS URLs (token-gated default) |
| Agent tooling | Software catalog at creation | Pre-installed harnesses + boat prompt + MCP computer-use + virtual desktop |
| Interface | Console + SSH | CLI + REST API + SDKs + SSH/SCP |
The networking row is the sharpest architectural difference: boat assigns each machine its own public IP (convenient, larger attack surface to manage), while Jilebi machines have no public IP at all and only explicitly exposed ports reach the internet.
Pros and cons
Jilebi — pros
- No monthly minimum; light use costs single dollars
- Free-form sizing up to 16 vCPU / 16 GB / 65 GB NVMe — shapes boat doesn’t sell
- Private by default: no public IP, exposure is explicit per port
- ~50ms boot with auto-sleep/wake you never manage
- Bare-metal placement, no noisy neighbors
Jilebi — cons
- Higher per-unit rates at standard shapes (~3x boat at 4 vCPU / 8 GB)
- No pre-installed agent harnesses, virtual desktop, or computer-use stack
- Smaller API/SDK surface for programmatic fleet management today
- No dedicated public IP per machine (a con if you need one)
boat.dev — pros
- Lowest unit rates in this comparison series (~$0.036/hr for 4 vCPU / 8 GB)
- $20 buys 555 hours — excellent for heavy single-box use
- Pre-installed harnesses,
boat prompt, virtual desktop with computer-use - Fixed sizes make fleet math trivial (0.5x / 1x / 2x)
- Token-gated public URLs and resize-up make previews easy
boat.dev — cons
- $20/month floor even if you run 5 hours
- Fixed sizes only; no 16-vCPU class or asymmetric CPU/RAM mixes
- Dedicated public IPv4/IPv6 per machine widens the attack surface
- Newer product; pricing and size lineup have room to change
Which should you pick?
- Pick boat.dev if you run agents heavily each month, like fixed sizes, and want harnesses, virtual desktops, and programmatic fleet APIs today — the $20 pool is genuinely the cheapest way to keep a 4 vCPU box busy.
- Pick Jilebi if your use is light or spiky (no floor), you need custom or large machine shapes, and you prefer private-by-default networking with bare-metal isolation.
Both agree agents deserve real VMs. Try ours at jilebi.ai — and run your actual workload on both for a week; the bill will tell you the rest.