# boxd — Instant remote computers

> Persistent, forkable VMs with sub-millisecond resume. SSH in, fork state, share a URL. No SDK required.

boxd provides persistent cloud computers that you can fork and share. Developers SSH in from anywhere. Agents run autonomously for hours. Both get persistent state, full isolation, and a public URL. The same machine works for both — because it's just a real Linux computer.

## Quick start

```bash
# Create a machine
$ ssh boxd.sh new --name=myapp
✓ Machine running at myapp.boxd.sh

# Fork it — full state, instant clone
$ ssh boxd.sh fork myapp --name=myapp-debug
✓ Forked → myapp-debug.boxd.sh <100ms

# SSH in
$ ssh boxd.sh connect myapp
✓ Connected to myapp · Ubuntu 24.04 · 2 vCPU · 8 GB
```

Or just run: `ssh boxd.sh`

## Links

- Website: https://boxd.sh
- Pricing: https://boxd.sh/pricing
- Use cases: https://boxd.sh/use-cases
- Blog: https://boxd.sh/blog
- Manifesto: https://boxd.sh/manifesto
- Self-host: https://boxd.sh/enterprise
- Contact: https://boxd.sh/contact
- Summary: https://boxd.sh/llms.txt

## Features

### Persistent state

Files, packages, databases, running processes — all survive disconnects, reboots, and time. Your agent stops at 2am, picks up at 9am.

### Instant forking

Fork a full machine — memory, disk, processes — in under 100ms. Branch to explore approaches in parallel, keep the winner.

### SSH-first interface

Every command works programmatically via `ssh boxd.sh <command> --json`. No SDK to install, no API keys to manage.

### Always on

Machines keep running after you disconnect. Long builds, background jobs, agent tasks all continue.

### Automatic HTTPS URLs

Every machine gets a public URL automatically. Certificates and DNS handled.

### KVM isolation

Every machine runs its own kernel — real hardware-level isolation, not containers. Safe for untrusted, agent-generated code.

### Pause to zero

Machines sleep when idle. You pay nothing while they're off. Resume in sub-millisecond.

### Self-hostable

Run boxd on your own infrastructure, any KVM-capable server. EU hosting by default. No vendor lock-in.

## Pre-installed tools

Ready from the first boot — no apt-get ceremony:

- Claude Code
- Docker
- Python 3
- Go
- Node.js
- headless Chrome
- ffmpeg
- git

## Specs

- OS: Ubuntu 24.04 (full, unminimized, with man pages and systemd)
- CPU: 2 vCPU per machine (Individual tier)
- Memory: 8 GB RAM per machine (Individual tier)
- Storage: 100 GB disk per machine
- Cold boot: <30ms
- Resume from sleep: instant (sub-millisecond)
- Fork time: <100ms

## Architecture

Custom Rust VMM built on KVM. Not Firecracker. Not Docker. Zero external dependencies — everything is built in. Raft consensus for distributed coordination. Self-host anywhere KVM runs.

- 1 custom VMM (Rust + KVM)
- 0 external dependencies
- 0 schedulers (Raft consensus instead)
- Self-hostable on any KVM host

## Comparison

| Feature | boxd | exe.dev | sprites.dev |
| --- | --- | --- | --- |
| Isolation | KVM (real kernel) | KVM-style Linux VM | Firecracker + inner container |
| Cold boot | <30ms | ~1s (claimed) | 1–2s |
| Resume from sleep | sub-millisecond | — | ~300ms |
| Fork from running state | 60ms (memory + disk + processes) | VM cloning (no published timing) | Checkpoint/restore (~300ms) |
| Persistent disk by default | Yes | Yes | Yes |
| Sleep-to-zero billing | Yes | No (flat $20/mo personal tier) | Yes (auto-sleep after 30s) |
| Per-VM public IPv4 | Yes | Yes | HTTPS URL via Tailscale |
| Self-host | Yes (Rust binary on KVM) | No | No (Fly.io managed only) |
| Programmatic VM API | Yes (`ssh boxd.sh ... --json`) | Not published | Yes (REST + SDKs in Go/JS/Py/Elixir) |

## For AI agents

boxd machines are designed for autonomous agent use:

- **Persistent**: agents don't lose state between runs
- **Isolated**: untrusted agent-generated code runs in its own kernel
- **Forkable**: agents can branch machines to explore approaches in parallel
- **Programmable**: SSH + --json interface needs no SDK
- **Always-on**: agent tasks continue running after disconnection
- **Pre-configured**: all common tools pre-installed, no setup scripts needed

## Pricing

### Individual — EUR 0/month (free forever)

- 10 concurrent VMs
- 2 vCPU / 8 GB RAM per VM
- 100 GB disk per VM
- Pause to zero — no charge while idle
- SSH from any device
- Fork & share machines
- Public URL per VM

### Team — EUR 25–200/month/user

Pool-based pricing. Pick your pool size; VMs share the pool.

- 2 vCPU / 8 GB RAM pool — EUR 25/month/user
- 4 vCPU / 16 GB RAM pool — EUR 50/month/user
- 8 vCPU / 32 GB RAM pool — EUR 100/month/user
- 16 vCPU / 64 GB RAM pool — EUR 200/month/user

Includes everything in Individual, plus higher VM limits, team management, SSO, priority support.

### Enterprise — Contact

Self-host on your own hardware, BYOC, EU data residency, SSO + audit logs, annual license, dedicated support.

## Contact

- Book a call: https://boxd.sh/contact
- Email: hidde@azin.run

## Built by

Azin (https://azin.run) — © 2026 boxd