boxes.dev vs GitHub Copilot

At a glance

As of September 2026.

Where the agent works

Copilot's cloud agent works on GitHub in a fresh environment for each task, and a boxes.dev devbox is a development machine that stays yours.

Each cloud agent task runs in an ephemeral environment powered by GitHub Actions, using AI credits from your Copilot plan and your account's Actions minutes. The agent changes code on a branch in one repository, can open one pull request for the task, and stops at a hard limit of 59 minutes. The Copilot app and CLI can also run a session in a cloud sandbox, in public preview. Stopping a sandbox saves a snapshot of its files, environment variables, and in-progress work, and resuming restores it.

A boxes.dev devbox stays awake while its agent works and sleeps when nobody is using it. Sleep keeps the machine's files and memory, like closing a laptop's lid, so dev servers, databases, and terminal sessions resume where they left off. A project can hold several repositories, and the devbox stays yours until you delete it.

How the environment is prepared

Copilot runs a setup workflow before each task, and boxes.dev copies a machine where your app already runs.

For the cloud agent, a copilot-setup-steps.yml workflow on your default branch runs in GitHub Actions before Copilot starts. It can install tools and dependencies, use larger runners, and read Actions secrets and variables. It runs again in a fresh environment for every task.

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

Reaching the running app

On boxes.dev, you and the agent can both use the app running on a devbox, and Copilot's cloud agent tests web pages in its Actions environment with the Playwright MCP server, which is enabled by default.

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 work with teammates. In shared Slack channels, Copilot works under its app identity, and boxes.dev runs work in your project with your access, including requests from teammates you allow.

People with access to a repository can see its Copilot cloud agent sessions and the pull requests they open. In Slack and Microsoft Teams, in public preview, mentioning @GitHub in a thread starts a cloud agent session. In Slack, anyone in the conversation can add context, and people with write access to the repository can steer the session. A session from a DM works with your GitHub permissions, while one from a shared channel or thread opens pull requests under Copilot's app identity, which need one more approval before merging when the repository already requires one.

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.

Agents can start other agents on new or existing devboxes, message each other, and leave notes in a shared /project folder.

Where GitHub Copilot shines

• Agents on GitHub issues and pull requests. You can assign an issue to Copilot or mention @copilot on a pull request, and anyone with access to the repository can follow the session.
• Models from several providers. Copilot offers models from several providers, with Auto choosing one for each task, and code completions in your editor.
• Checks on agent changes. Copilot code review comments on pull requests, and CodeQL, secret scanning, and the GitHub Advisory Database check third-party agents' changes.
• Automations on GitHub events. Cloud automations can start the agent when an issue is created, a pull request opens, or a pull request gets new commits.
• Agent merge. In the Copilot app, agent merge works on whatever blocks a pull request and merges it as soon as GitHub allows.

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.

Copilot's AI credits also cover Claude and Codex as third-party agents, and cloud sandboxes add charges for running time, memory, and snapshot storage. See Copilot plans and cloud sandbox billing.

Using both

Copilot and boxes.dev work on the same GitHub repositories and pull requests. You can keep Copilot for code review and short tasks from issues, and use boxes.dev when a task needs Claude Code or Codex on a copy of your full environment.

Frequently asked questions

Can I use Claude Code with GitHub Copilot?

Copilot's paid plans include Claude as a third-party agent on GitHub, in public preview. It uses Anthropic's Claude Agent SDK and follows the cloud agent's limits. boxes.dev runs the Claude Code and Codex CLIs themselves, 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.

Does boxes.dev work with GitHub pull requests?

Yes. Agents on a devbox push branches and open pull requests on GitHub, and you can review, update, and merge them from the desktop app. See Commit, push, and open a pull request.

Is there a time limit on boxes.dev tasks?

No. A boxes.dev devbox stays awake while its agent works, using your plan's box-hours, and sleeps after about five minutes without activity.

Sources

• GitHub Copilot: cloud agent, starting sessions, the GitHub CLI, the agent tasks API, Slack, agent environment, cloud and local sandboxes, cloud sandbox billing, third-party agents, Anthropic Claude, the Copilot app, issues and pull requests in the app, automations, bring your own key, and 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, Browse, edit, and transfer files, Preview your app, Project URLs, Connect Codex and Claude, Commit, push, and open a pull request, Organize and share threads, Team access and roles, Agent permissions, Create and publish a Team Template, Install and use the CLI, Work from Slack, Work from Linear, Use boxes.dev on your phone, and Plans, seats, and box-hours.