Boxes.dev vs Capy
Boxes.dev gives Claude Code and Codex a prepared development environment where they can run and test your full app, with running programs preserved through sleep. Capy runs its own agent and a Claude Code mode on cloud machines or your computers.
The short answer
Boxes.dev gives Claude Code and Codex your app's dependencies, services, and local data in a devbox you can use yourself. Parallel tasks can each have their own environment, and running programs resume after sleep. Choose boxes.dev to work with the agents you already use, test their changes in your full app, and continue from your desktop, terminal, or phone. Capy offers its own agent across many models, a Claude Code mode, and execution on cloud or paired computers.
Choose Boxes.dev if
- You want agents to build and test against your app's real services and local data.
- You want parallel tasks to have separate environments, with dev servers and databases that resume after sleep.
- You want native Claude Code and Codex, with the same conversations in the app and terminal.
- You want to inspect work yourself in a shared browser, over SSH, or from native iOS and Android apps.
Choose Capy if
- You want agents to work on your own laptop, server, or other paired computer.
- You want Captains to coordinate crews and collect decisions into a digest.
- You want Capy's own agent across a broad range of model providers.
At a glance
Based on Capy's published documentation, reviewed November 2, 2026, with pricing rechecked November 3.
| Boxes.dev | Capy | |
|---|---|---|
| Agents | Native Claude Code and Codex, with the same conversations in the app and terminal, using your own subscription or API key | Capy's own agent across model providers, plus Claude Code through the Claude Agent SDK |
| Cloud environment | A copy of your prepared development environment, with dependencies, files, and local data, so each task can run and test independently | A Linux VM prepared from repository setup scripts, with optional filesystem snapshots |
| Sleep | Dev servers, databases, and terminals resume where they left off; sleeping devboxes use no box-hours | Files survive, but processes stop; startup commands run again on wake |
| Where work runs | Cloud devboxes keep working when your laptop sleeps; you can return to the same work from desktop, terminal, or phone | Cloud machines or worktrees and checkouts on paired computers |
| Working with agents | Claude Code and Codex can split work across devboxes, review each other's changes, and exchange messages | Subagents divide tasks; Captains coordinate groups of threads |
| Verification | You and the agent can test the running app in the same browser, inspect failures in a terminal, and review changes together | Browser, cloud desktop, terminals, diffs, and cloud iOS/Android testing on Pro and above |
| Access | Desktop, native iOS and Android apps, CLI, and SSH to the devbox where your work is running | Web, macOS/Windows/Linux desktop apps, mobile web, and Dock |
| Monthly plans | Starter $19, Pro $99, and Max $249 per paid user, each with its own box-hour allowance | Lite $20, Pro $100, and Max $200–$1,000 per organization, each with a fixed credit allowance |
Preparing an environment
On boxes.dev, you or a setup agent get your app working in a Template box, including its dependencies, databases, and test data. Each new devbox gets its own copy of that setup, so agents can build and test against the full app without repeating the preparation for every task.
A snapshot can also carry running Docker containers and system services into new devboxes. Copied agents and terminal processes stop in the new devbox. You can inspect the environment yourself through its terminal, files, shared browser, or SSH. What snapshots preserve.
Capy prepares cloud VMs from repository setup scripts and can cache the resulting filesystem in a snapshot. New threads restore it and run startup commands for services. Its VMs also support Docker and installing tools. Capy environment documentation.
Returning to work after sleep
A boxes.dev devbox sleeps like a laptop: its databases, dev servers, and terminal processes resume where they left off when it wakes. You can leave a working app ready for the next day without paying for awake time overnight. Sleeping devboxes use no box-hours, and a devbox stays until you delete it.
Capy keeps files through sleep but stops running processes, then reruns startup commands on wake. Its docs say machines asleep for 30 days are deleted, and a machine that must be rebuilt can lose unpushed work. Capy machine lifecycle.
Working away from your laptop
Boxes.dev keeps agent work on cloud devboxes, so you can close your laptop while a task continues. Each devbox has its own files, ports, and local data, allowing parallel tasks to run and test independently. You can check progress, steer the agent, or use a terminal from the native iOS and Android apps, then return to the same work on desktop.
Capy offers cloud execution or work on a paired computer using its existing tools and credentials. Dock connects headless servers. Device work has no Capy machine-time charge; model usage still needs a billing source. Capy devices, Dock.
Its device-to-cloud handoff transfers Git changes and eligible workspace files, but leaves behind ignored files, larger untracked files, and processes.
Choosing an agent
Boxes.dev runs the native Claude Code and Codex harnesses. You can work with either agent in the app or its terminal interface and continue the same conversation in both. Your own subscription or API key covers model usage. Both agents have the full devbox available to run the app and test their work.
Capy supports multiple model providers in its own harness, with subscriptions, API keys, and gateways. Claude Code runs in a separate Agent SDK mode. A Codex subscription pays for compatible OpenAI models inside Capy's agent; it does not provide the native Codex CLI workflow. Capy model connections.
Coordinating team work
On boxes.dev, you can give implementation and review to different agents, with a separate devbox for work that needs its own environment. Agents can delegate tasks, exchange progress and questions, and read earlier threads to pick up context. You can inspect their changes and test the app alongside them.
Team Templates give teammates a shared starting environment. Both products support Slack and Linear integrations, scheduled work, and API-triggered automations. External services can start boxes.dev automations by calling their API endpoints. Boxes.dev automations, Capy automations.
Boxes.dev also supports automatic GitHub pull-request follow-ups: failed checks and review feedback can bring the agent back to fix its work. Pull-request follow-ups.
Capy's Captains coordinate groups of threads and collect updates in a digest. Captains.
Comparing costs
With monthly billing, boxes.dev Starter costs $19 per paid user for 50 box-hours, Pro $99 for 250, and Max $249 for 600. Each paid user gets their own allowance. Extra compute uses the team's prepaid credits at $0.60 per box-hour. Model usage is paid through your own agent subscription or API key. Boxes.dev plans and box-hours.
Capy charges per organization: Lite costs $20 for $20 in monthly credits, Pro $100 for $105, and Max $200–$1,000 for $220–$1,100. Adding members neither adds a seat fee nor increases the included usage. Higher plans raise machine limits; mobile builds and cloud phones require Pro or above. Capy pricing.
Capy's credits pay for cloud compute and Capy-billed model usage. Connected subscriptions or keys pay for compatible model use separately; PR reviews always use Capy credits. Capy model billing.
For a cost comparison, use the same team size, machine resources, active hours, and model billing method. A boxes.dev box-hour covers 4 vCPU and 8 GiB; larger machines use more box-hours. Capy meters each machine size in dollars per hour. Both stop charging for compute while machines are asleep. Capy machine pricing.
More comparisons
Product names are trademarks of their respective owners.