# boxd

> Instant remote computers. Cloud computers, instantly. Persistent, forkable Linux VMs with sub-millisecond resume. SSH in, fork state, share a URL. No SDK required.

boxd gives developers and AI agents their own persistent Linux machines accessible via SSH. No SDK required — if it can open an SSH connection, it can use boxd.

## Quick start

```
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
- Full LLM context: https://boxd.sh/llms-full.txt

## Use cases

- https://boxd.sh/use-cases/dev-environments — A dev environment per engineer. Forked from one template. Onboard in a day, no setup drift, preview URLs for every PR.
- https://boxd.sh/use-cases/agent-sandboxes — The fastest, most isolated agent sandboxes. KVM virtualization, EU-hosted, sub-30ms cold boot.
- https://boxd.sh/use-cases/background-agents — Let agents ship code while your team sleeps. Fork a machine, run the agent, sleep when done.

## Blog & manifesto

- https://boxd.sh/blog/the-agent-lives-inside-the-machine — Why every boxd decision — fork, hibernation, persistence, SSH — flows from one architectural bet.
- https://boxd.sh/blog/persistence-beats-ephemeral — Why persistent state is the foundation of everything boxd does — and what falls out for free.
- https://boxd.sh/blog/where-to-run-agent-harness-production — Anthropic and LangChain define what an agent harness is. This piece answers the question they don't: where does the harness actually live in production?
- https://boxd.sh/blog/mcp-server-hosting-complete-guide — Where do production MCP servers actually live? The four hosting patterns, what changes when MCP goes to production, and the five properties a remote MCP server host needs.
- https://boxd.sh/blog/anthropic-computer-use-on-a-remote-vm — Computer use needs a desktop. The hard part isn't the API — it's where the desktop lives. What the workload actually needs from its host, and why most cloud primitives don't ship with a display.
- https://boxd.sh/blog/self-hosted-agent-execution-for-engineering-teams — Where does the agent actually execute? The compliance and engineering dimensions, what the substrate has to provide, and the EU sovereignty angle, honestly.
- https://boxd.sh/blog/cloud-dev-environment-complete-guide — Why CDE is back in the conversation, the four shapes the category comes in this year, and what changed when AI agents joined the workload.
- https://boxd.sh/blog/boxd-vs-exe-dev — Two products in the same lane: persistent Linux VMs over SSH, batteries included. An honest comparison of the design choices that fall out of the shared thesis.
- https://boxd.sh/blog/boxd-vs-sprites — Sprites and boxd agree on the architecture: persistent microVMs are the right primitive for AI agents. Where the two implementations diverge, honestly.
- https://boxd.sh/blog/a-single-rust-binary — boxd is one Rust binary. No Postgres, no Redis, no Kubernetes. Why simplicity is the design.
- https://boxd.sh/blog/architecture/how-boxd-works — An honest architectural tour: KVM microVMs, Raft consensus, SSH-first routing, and per-VM cgroups.
- https://boxd.sh/blog/boxd-101 — A short tour of boxd: SSH in, install things, fork the machine, share a URL. The basics in 5 minutes.

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

## Specs

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

## Pricing

- Individual: EUR 20/month. 10 VMs at 2 vCPU · 8 GB RAM each, 100 GB disk. 7-day free trial.
- Team: usage-based — pay for compute your team actually runs. Contact us.
- Enterprise: BYOC or self-host on your own hardware. EU data residency, SSO, audit logs.

## Architecture

Custom Rust VMM built on KVM. No Firecracker, no Docker, no external dependencies. Raft consensus for coordination. European hosting by default.

## Contact

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