boxes.dev vs Devin

At a glance

As of September 2026.

Whose agent does the work

Devin is an agent of its own, and boxes.dev runs Claude Code and Codex.

Devin's cloud sessions run Devin, Cognition's agent, with models that Devin's plans include from OpenAI, Anthropic, Google, and others. Devin meters usage by the work each session does, with virtual machine time as a small part of it, drawing on an allowance that refreshes daily and weekly, then on extra usage at API prices.

boxes.dev runs the Claude Code and Codex CLIs on cloud devboxes, signed in with your Claude or ChatGPT plan or an API key, so their commands, skills, and settings work as they do on your computer.

One environment per organization, or one per project

Every Devin session in an organization starts from the same snapshot, and each boxes.dev project has a Template box of its own.

Devin's environment is a bootable snapshot built from a blueprint that lists your repositories, tools, dependencies, environment variables, and secrets. Devin can write the blueprint for you, and a new snapshot is built whenever the configuration changes. Each organization has exactly one active snapshot, and every session boots a fresh copy of it.

boxes.dev first sets up each project's 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. 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. Team Templates let an admin prepare one starting environment for everyone on the team.

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, and 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.

Reaching the running app

Both let you open the app running on the cloud machine, and boxes.dev also gives each devbox public links and your project a stable URL.

In a Devin session, you and Devin can open services running in the VM from the session's browser, and devin forward in the Devin CLI forwards a VM port to localhost on your computer. For standalone apps it builds, Devin can deploy static frontends and some backends to addresses that Devin hosts.

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 boxes.dev also lets teammates you allow start work in your project from Slack, with your access.

Mentioning @Devin in a Slack channel starts a session that replies in the thread, and a session can sync with a Slack thread in both directions, so your team can follow along. Teams plans add sharing and collaboration on sessions.

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 Claude Code or Codex 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.

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 the forwarding, .localhost addresses, and public links described above.
• Activity, which shows the processes using the machine's CPU and memory.

A boxes.dev devbox sleeps when nobody is using it, and an agent that is still working keeps it awake. Sleep keeps the machine's files and memory, so dev servers, databases, and terminal sessions resume where they left off, and the devbox stays yours until you delete it. AWS, Tailscale, and the MCP servers and agent plugins you add for the project reach every devbox, and agents on different devboxes can leave each other notes in a shared /project folder. You can branch a conversation onto a new devbox that starts with the current files, including uncommitted work.

Where Devin shines

• Orchestrating many sessions. A coordinating Devin can split a large task across managed Devins, each in its own VM, monitor them, resolve conflicts, and compile the result.
• Devin Review. Large pull requests become organized diffs with explanations, bug findings, and a chat about the codebase.
• Devin Desktop. A code editor with in-line and multi-line autocomplete, powered by Devin's own models.
• Automations with many triggers. Sessions can start from CI failures and other GitHub events, Linear label changes, Slack reactions, PagerDuty incidents, or webhooks, and a triage Devin can watch a Slack channel.

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.

Devin's usage grows with actions such as planning, running code, and browser use, and Devin doesn't count usage while a session waits for you or sleeps. See Devin's pricing and how Devin meters usage.

Using both

Devin and boxes.dev can work on the same repositories. You can keep Devin for the work its automations and review handle, and use boxes.dev when you want Claude Code or Codex on a copy of your full environment.

Frequently asked questions

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.

Can agents on boxes.dev work while I'm away?

Yes. A boxes.dev devbox stays awake while its agent works, and work can start from a Slack mention, an assigned Linear issue, a schedule, or an API call. You can follow up from the iOS and Android apps.

Which is easier to budget for?

boxes.dev charges a seat price with a published number of box-hours and a published rate for extra time, and your Claude or ChatGPT plan covers the agents. Devin's usage depends on how much work each session does, drawing on an allowance that refreshes daily and weekly, then on extra usage at API prices.

Sources

• Devin: environment setup, usage, session tools, Devin Cloud in the CLI, SSH and port forwarding, Slack, GitHub, advanced capabilities, automations, Devin Desktop autocomplete, Devin Review, app deployments, and pricing.
• 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, Create and publish a Team Template, Connect Codex and Claude, Shared project storage, Organize and share threads, Team access and roles, Commit, push, and open a pull request, Install and use the CLI, Work from Slack, Work from Linear, Use boxes.dev on your phone, and Plans, seats, and box-hours.