boxes.dev vs Factory

At a glance

As of September 2026.

A machine for each task, or worktrees on a Droid Computer

Factory runs sessions on long-lived computers and separates parallel work with Git worktrees, and boxes.dev gives each task its own machine.

A Droid Computer is a persistent machine that keeps its installed packages, files, services, and configuration between sessions. Factory can provision one for you with 4 CPUs and 8 GB of memory, starting on the Plus plan, and its compute counts toward the same rolling usage limits as the models. Parallel sessions on one computer use Git worktrees, each with its own branch and working files, and a setup profile can prepare each new worktree. The worktrees share the computer's CPU, memory, services, databases, and ports.

boxes.dev first sets up your full development environment on a cloud machine called the Template box, with the tools, databases, services, and data your app needs, so an agent can run the app and test its changes end to end. A setup agent can port the environment from your laptop, including the files, local data, agent settings, and skills you choose to upload, or build it from a GitHub repository. boxes.dev then saves the Template box as a snapshot, and every task runs on its own devbox, a full, isolated copy of that machine with its own databases, services, and ports, so parallel tasks don't collide. A maintenance script can keep the Template box current as your code changes, running on a schedule or when files such as a lockfile change, and each successful run saves a new snapshot.

You'd never let an engineer ship code they hadn't run, and a full environment holds the agent to the same standard. On a boxes.dev devbox, the agent runs your whole app, with its databases and services, and tests its changes in the browser as it builds. It reproduces bugs in the real app to find the root cause instead of guessing from the code, so it writes better code and makes fewer mistakes. It can also take screenshots and record video for you to review, so you can hand it most repetitive manual testing.

Whose agent does the work

Factory runs Droid, its own agent, and boxes.dev runs Claude Code and Codex.

In Droid, you can pick models from Anthropic, OpenAI, Google, xAI, and open-model providers, or let Factory Router choose one for each task, and you can add your own API keys. Choosing a Claude or GPT model runs that model inside Droid.

boxes.dev runs the Claude Code and Codex CLIs on your devboxes, signed in with your Claude or ChatGPT plan or an API key, so your CLAUDE.md or AGENTS.md, skills, and settings work as they do on your computer. A thread can switch between the graphical view and the agent's own terminal UI.

Reaching the running app

On boxes.dev, you and the agent share a browser on the devbox, and both products bring a cloud machine's app to your computer.

The Factory App renders live sites beside a session, and you can select an element and tell Droid what to change. The Droid CLI can forward TCP ports from your computer to a Droid Computer, waking a managed computer first.

Each boxes.dev devbox runs a browser that you and the agent share, so you can watch the agent test the app, click through it yourself, or comment on page elements to show the agent what to change. Ports forwards the app to the same localhost port on your laptop. A public link shares a devbox's running app with anyone, and a Project URL gives your project one stable public address that you can point at any devbox, which suits OAuth callbacks and webhooks.

Working with your team

Both bring agents into Slack and share sessions with teammates. Factory can run shared channel work as a service account, and boxes.dev runs work in your project with your access, including requests from teammates you allow.

Mentioning @Factory in a Slack thread starts a Droid session with the thread's context, and follow-ups from Slack go to the same session. The session runs as you unless you choose a service account to run as. In Remote Delegations, in private preview, channel requests run as a service account with its own Git credentials and connectors, and your personal connectors don't carry over. Pull requests from those shared delegations come from factory-droid[bot], so Factory recommends requiring two human approvals to keep the requester from merging their own delegated work. You can share a session with your organization and review it on desktop, web, or mobile.

Each boxes.dev devbox belongs to one person and works with their access, such as their GitHub login and cloud credentials. Anyone who can prompt its agent could act with that access, so in the app, teammates get read-only access to your work. You can share a thread as a link, and a team admin can let teammates read every thread that isn't marked private and browse each other's projects in a Team workbench. Teammates can't send prompts, open your terminal, or control your devbox.

In Slack, mentioning @boxes.dev in a thread starts Codex or Claude Code on a new devbox, and later mentions in that thread send follow-ups to the same conversation. By default, only you can start work in your project from Slack or follow up on it. If you allow teammates, they can also start work there with @boxes.dev @YourName and send follow-ups, and their requests run with your access and usage. boxes.dev sends you a DM with links to each task a teammate starts, and commits can link to the thread that produced them. Team Templates let an admin prepare one starting environment for everyone on the team, while each member's own credentials go only to that member's project.

What comes with every boxes.dev devbox

The boxes.dev desktop app opens the same set of tools for whichever devbox you select:

• Terminal, with tabs that keep running after you close the app.
• Files, a file browser and editor with search across the workspace.
• Git/Review, for branch history and diffs, where comments on changed lines go to the agent together as one message.
• Browser, the browser on the devbox that you and the agent share.
• Ports, for port forwarding, stable .localhost addresses, and public links.
• Activity, which shows the processes using the machine's CPU and memory.

You can branch a conversation onto a new devbox that starts with the current files, including uncommitted work.

Where Factory shines

• Missions. For large projects, you plan features and milestones with Droid, then an orchestrator coordinates workers, validates progress, and reports in Mission Control.
• Model routing. Factory Router picks a model for each task from several providers, and sessions can switch to a pool of open models after premium usage runs out.
• Presentations and spreadsheets. Documents, presentations, and spreadsheets that Droid produces render beside the session, and Droid acts on comments you leave on them.
• Automations on Slack and GitHub events. Automations can start Droid when a message lands in a Slack channel or a GitHub event happens.
• An SDK for the agent. TypeScript and Python SDKs run Droid inside your own programs, and droid exec runs it headless in CI.

Pricing

As of September 2026.

A box-hour is one default devbox awake for an hour, and sleeping devboxes don't use any. On Starter, 40 box-hours works out to about two hours of devbox time each working day, and Pro's 250 to about twelve, spread across as many as ten devboxes at once. Your Claude or ChatGPT plan covers the agents' usage. See Plans, seats, and box-hours.

Your Claude or ChatGPT plan is also heavily discounted. By our estimate, when fully utilized, a Claude Max plan is at least 40x cheaper than the same usage at API prices, and the $200 ChatGPT Pro plan is over 30x cheaper. So on boxes.dev, you'll pay far less for the same tokens.

Factory counts model usage and Droid Computer compute against three rolling limits, and a request needs room in all three. Factory doesn't publish how many computer hours a plan includes. See Factory's individual plans and organization plans.

Using both

Factory and boxes.dev can work on the same repositories and pull requests. You can keep Factory for Missions and its automations, and use boxes.dev when a task needs Claude Code or Codex on its own copy of your full environment.

Frequently asked questions

Can Factory run Claude Code or Codex?

Factory runs Droid, its own agent, which can use Claude and GPT models. boxes.dev runs Claude Code and Codex themselves, with your Claude or ChatGPT plan or an API key.

What's the difference between a Droid Computer and a devbox?

Both keep their files and pause when idle. Several sessions share a Droid Computer, usually through Git worktrees. A boxes.dev devbox is a full copy of your Template box for one task, with its own databases, services, and ports.

Can I open a devbox in my own editor?

Yes. dvb ide opens a devbox in VS Code or a JetBrains IDE over SSH. See Install and use the CLI.

Sources

• Factory: Droid Computers, worktrees, Factory App, app quickstart, models, Factory Router, custom models, Remote Delegations, Slack, Linear, automations, automated code review, Missions, individual plans, and organization plans.
• boxes.dev: How boxes.dev works, Update your Template box and snapshots, Startup, teardown, and maintenance, Sleep, wake, and recover a devbox, Review a page with your agent, Preview your app, Project URLs, Browse, edit, and transfer files, Connect Codex and Claude, Organize and share threads, Team access and roles, Create and publish a Team Template, Work from Slack, Work from Linear, Shared project storage, Install and use the CLI, Use boxes.dev on your phone, and Plans, seats, and box-hours.