A cloud agent is a coding agent that runs on a remote machine instead of your laptop. It gets its own checkout of your repository, its own terminal and dependencies, and it keeps working after you close the lid. When it finishes, you review a branch or a pull request. An open source cloud agent is one where the software coordinating that work (the workspace, the sandbox orchestration, the credential handling) is published under an open source license, so you can read it, run it yourself, and change it.
That definition hides three separate choices. The workspace can be open source while the model is proprietary. A cloud machine does not come with model access. And an agent that can open a pull request still needs repository permissions, a working build, and a clear definition of done.
Zuse is an open source workspace for coding agents, built cloud agents first. It runs Claude Code, Codex, and other agents in isolated cloud workspaces or on your own machine, and every change comes back to you for review. This guide explains how cloud coding agents work, where local agents are still the better fit, why open source matters more for cloud agents than for most developer tools, and how Zuse is put together under the hood.
What is a cloud agent?
A cloud coding task has four parts. Evaluating any tool gets easier once you can point at each one.
- The repository: a specific checkout and branch. In the cloud this is usually a fresh clone from your Git host, not the files on your laptop.
- The runtime: the machine, its CPU and memory, installed toolchains, environment variables, and any services the tests need.
- The agent: the program that reads your instructions, calls a model, and uses tools (shell, file edits, browser) under a permission policy. Claude Code and Codex are agents. So is OpenHands' agent, or Cursor's.
- The workspace: the interface where you start tasks, follow the conversation, read terminal output, and review the diff.
"Cloud agents" is now a product category. Cursor renamed its background agents to Cloud Agents, GitHub documents the Copilot cloud agent, Anthropic runs Claude Code cloud sessions, and OpenAI has Codex Cloud. They share a shape: each task gets an isolated machine, works on a branch, and hands back a pull request. They differ on who owns each of the four parts above.
Cloud agents vs local agents
A local agent runs on your computer, in your checkout, with your installed tools and your logged-in CLIs. A cloud agent runs on a machine provisioned for the task. Neither is strictly better.
| Local agent | Cloud agent | |
|---|---|---|
| Where code runs | Your machine | A remote VM or sandbox per task |
| Needs your laptop awake | Yes | No |
| Starting state | Your checkout, including uncommitted files | A fresh clone of a pushed branch |
| Isolation between tasks | Separate Git worktrees on one machine | Separate machines |
| Parallelism limit | Your CPU, RAM, and disk | Your compute budget |
| Credentials | Whatever your CLIs are already logged into | Must be provisioned for the remote machine |
| Access to local devices and services | Yes | Only what you expose to it |
| Good for | Device testing, local data, quick iterations | Long tasks, many parallel tasks, work that should continue while you're away |
The tradeoffs that bite in practice:
- Setup. A cloud machine starts from an image. If your repository doesn't install and build from a clean clone, a cloud agent will spend its first hour fighting your environment. Fix that first; it pays off for CI too.
- Uncommitted work. Cloud agents clone from your Git host. If the fix depends on local changes you haven't pushed, the cloud agent can't see them.
- Hardware. A native app change that needs a simulator or a phone on USB is a local task. A cloud machine can run the unit tests, but it can't prove the app launches on a device.
- Concurrency. Running six agents on a laptop means six dependency installs, six dev servers, and a hot machine. Six cloud machines is a billing question, not a thermal one.
Most teams end up using both. The useful question for each task is: where can this task produce the evidence I need to merge it? Our local vs cloud guide turns that into a short checklist.
Why open source matters for cloud agents
For a local tool, open source is nice. For a cloud agent it carries more weight, because a cloud agent holds three sensitive things at once: your source code, your repository write access, and your model credentials. When the coordinating software is closed, you trust a description of how those are handled. When it's open, you can check.
You can inspect how credentials and code are handled
Questions worth answering before you connect a repository to any cloud agent:
- Where do model credentials live, and does the machine running untrusted code ever see a long-lived refresh token?
- What can the agent do without asking? Is "full access" an OS sandbox or just a permission flag?
- How is the repository cloned and pushed, and with whose identity?
- What is stored after the task ends, and where?
With Zuse you can answer those from the source. The workspace is licensed under AGPL-3.0. The native Rust rewrite, opcodehq/zuse, is public under the same license and documents its cloud design, acceptance status, and open gaps in the repository.
You can run it on infrastructure you control
Open source makes self-hosting possible, but it doesn't make every hosted feature a one-command install. Be specific about what you can run yourself today:
- The agent loop on your own machine. Zuse Serve turns a Mac or Linux computer, including a VM you rent, into a durable environment you open from the hosted web app or Zuse for iPhone. The repositories, agent CLIs, credentials, and session state stay on that computer. Run
npx @zusehq/serve, finish sign-in in a browser, and the machine shows up in your sidebar. - Your own sandbox account. For Zuse's managed cloud chats, you can connect your own boxd, Boat, or E2B API key. Compute is then billed by that provider to your account, and a Zuse subscription isn't required for it.
- Any computer over SSH. The desktop app can add another computer over SSH. It installs a private Zuse runtime there, bound to loopback, and uses your existing SSH setup.
The hosted control plane for cloud chats (accounts, image builds, sandbox lifecycle) is in the same open source repository, but it is not packaged as a turnkey self-hosted product. If running the entire control plane on your own infrastructure is a hard requirement, check the current repository state rather than assuming it.
You avoid lock-in at three layers
- Agent. Zuse wraps the agents you already use instead of shipping its own model. Locally it supports Claude Code, Codex, Cursor, Grok, OpenCode, Kiro, Pi, and other agents that speak the Agent Client Protocol. Cloud chats support Claude Code, Codex, Cursor, and Grok. You can switch agents per chat.
- Compute. Cloud chats run on boxd, Boat, or E2B, picked per chat. Changing provider doesn't change how you work.
- Data. Work lands as commits on branches in your Git host. Local chat state is a SQLite file (
zuse.sqlite) in the app's data directory, and settings are JSON under~/.zuse/. Nothing about your repository is stored in a proprietary format you need Zuse to read.
You bring your own keys and plans
Zuse doesn't resell model tokens. You connect your own Claude or ChatGPT plan, an API key, or a compatible endpoint, and the provider bills you directly at its own rates. That keeps the provider's dashboard as the source of truth for spend and rate limits, and it means Zuse has no margin riding on how many tokens your agents burn. We explain the reasoning in bring your own keys, and walk through the exact setup in how to run cloud coding agents on your existing Claude or ChatGPT plan, including what each provider's terms say.
How Zuse runs agents in isolated workspaces
This section describes the current implementation in swarajbachu/zuse. Where something is a design target rather than shipped behavior, it says so.
Local: one Git worktree per chat
On your machine, each chat can get its own Git worktree: a separate checkout on its own branch, created with git worktree rather than a second clone. Every session in that chat (including sessions using different agents) shares that checkout, and the file tree, terminal, dev servers, diff view, and pull-request actions are all scoped to it. Your main checkout keeps its branch and uncommitted changes.
Worktrees share the repository's object database, so history isn't copied per task. Zuse also links node_modules from the main checkout when the lockfile is byte-for-byte identical, and leaves it alone when it isn't so setup can install the right dependency graph. Build output like .next, dist, and target is still per worktree, so disk use grows with active tasks. More detail in Git worktrees for every chat.
Cloud: one machine per chat
A cloud chat runs on its own machine. Setup happens once per account:
- Connect GitHub. Install the Zuse GitHub App on the repositories you choose. Cloud agents commit, push, and open pull requests as you.
- Connect agents. Under Zuse agent accounts, authenticate each agent once. The same connection works on every compute provider.
- Build an image. Each compute provider gets its own image containing your connected repositories, so new chats don't start from an empty disk.
After that, choosing Cloud · boxd (or Boat, or E2B) in the composer starts a machine for that chat on a fresh branch. It doesn't use your local checkout or uncommitted files. A cloud chat can't be moved to your laptop, or the reverse; to continue elsewhere, push the branch and start a new chat from it.
The providers behave differently when paused, and Zuse doesn't hide that:
| boxd | Boat | E2B | |
|---|---|---|---|
| Pause | Hibernates; memory, processes, and files come back on resume | Disk is preserved; Zuse restarts its runtime and agents | Normal pauses keep disk and memory |
| Sizes | Small, Standard, Large | Small, Standard, Large | One size, set by the deployment's template |
| Extras | Fork a chat into a new machine; publish preview URLs |
Exact sizes are in the cloud machine docs. Resume time depends on the image, region, and capacity, so we don't quote a number for it.
Messages you send while a machine is paused wait in a queue and are delivered when the runtime takes the command. Delivery state is shown explicitly, so "accepted" isn't confused with "executed". The recovery journal covers why those states matter.
Credentials: an authority, not a copy on every machine
The part of a cloud agent that deserves the most scrutiny is how model credentials reach the machine running untrusted code. In Zuse's cloud, agent credentials are held by a private, per-account authentication service, not baked into each workspace:
- When you paste an API key or token, the client encrypts it to that service's public key (RSA-OAEP in the current code). The API never returns it.
- Before saving a Claude credential, the service verifies it by running the official
claudeCLI in a throwaway config directory with any other ambient Anthropic credentials stripped, so a different key on the machine can't make a bad one pass. - For Codex with a ChatGPT login (and Grok with a device login), Zuse runs the official
login --device-authflow inside that private service. Workspaces then receive a short-lived access token, sealed to the specific workspace, its runtime generation, and its key, with an expiry. Refresh tokens stay in the service and are not copied into workspaces. - Static credentials (a Claude setup token, or an API key) have no refresh token to hold back. They reach a workspace through the same sealed, expiring delivery and are kept in process memory, but the value delivered is the credential you pasted, so the machine running the agent does see it.
That describes images built with the current broker, which production has enabled. Chats started from older images keep the image-based sign-in they started with, and a custom Boxd snapshot can be set to use logins copied from your source machine instead.
You can read the implementation in infra/api/src/cloud-auth-authority.ts. The guide to running agents on your existing plan covers which sign-in methods each agent supports.
Agents speak their native protocols
Zuse doesn't screen-scrape a terminal. It drives each agent through the interface the vendor ships: Claude Code's structured session events, Codex's app-server protocol, and ACP for compatible agents. That's why provider features like Claude's slash commands, Codex review, plan mode, and subagents show up in the timeline as structured events, and why sessions can resume after the agent process stops.
Permissions are explicit, and "full access" isn't a sandbox
Two controls decide what an agent may do, in the cloud or locally (docs). Cursor uses its own SDK sandbox with automatic review instead, and Pi supports neither control.
- Plan mode is read-only. The agent inspects and proposes; mutating tools stay blocked even under Full access.
- Runtime permission mode is one of Ask for approval (reads proceed, everything else asks), Approve for me (the provider's native safety reviewer decides, and escalations come to you; available for compatible Codex, Claude, and Grok installs), or Full access (ordinary tools run without asking; plan-mode exits and sensitive paths still ask).
Full access uses the provider's unrestricted mode. Zuse's docs say plainly that it is not a sandbox. In the cloud, the isolation boundary is the machine. Locally, it's a worktree on your machine, which is why defaults matter more there.
Cloud chats can also ask to run commands on your desktop, for things like reaching a local service. Each request shows the command and working directory and needs approval (once, for the session, or always), and Full access in the cloud does not bypass that device approval.
Where it's going: the Rust rewrite
Zuse is being rewritten as a native Rust application in opcodehq/zuse: a GPUI desktop app and a WebAssembly browser target sharing one engine that owns processes, workspaces, durable conversations, and agent execution. The hosted cloud is being rebuilt there too. The repository's own docs mark which parts are verified and which are still in progress, including live provider execution and the full archive lifecycle. Two points from those docs are worth knowing as a user. An accepted constraint: resuming a cloud chat continues the same branch and files without fetching, rebasing, or renaming anything. And a proposed credential design: refresh tokens stay with a central authority and are never placed in workspace snapshots. Treat the rest of that repository as a roadmap, not a feature list.
Delivery, pauses, and recovery
A responsive UI and an active agent are different states. A message can be waiting locally, accepted for delivery, or being processed, and a transcript can be readable while the machine is asleep. When you evaluate any cloud agent, check that after a reconnect you can tell whether your last message was delivered without resending it, that a machine which lost its files says so instead of hiding behind a cached transcript, and that a rejected credential is reported differently from a network failure.
Zuse's 0.21.0 release added explicit delivery outcomes with duplicate-send protection, separate errors for rejected Codex credentials, and reporting of missing runtime data while keeping cached transcripts readable.
Review every change before it merges
An agent's output is a diff plus evidence. Read the whole diff, including config, lockfiles, and CI files; agents sometimes "fix" a failing test by loosening it. Ask which checks actually ran and where: a type check, a unit test, a browser run, and a device launch prove different things. If a required check couldn't run, the pull request should say so.
Zuse keeps the conversation, terminal output, files, and diff in one place, so you can trace a claim like "tests pass" back to the command that produced it. Our review checklist is the routine we use. A second agent reviewing the diff helps; the merge decision should still be yours.
Running agents in parallel
Cloud agents make parallelism cheap to start, which moves the bottleneck to review. Give each task one owner and one branch, settle shared interfaces before fanning out dependent work, and add concurrency only after one task has gone cleanly from start to merge. Parallel agents without collisions goes deeper, and token maxing your subscriptions covers getting more out of a flat-rate plan.
What it costs
Three costs are easy to blur together. Keep them separate:
- Workspace software. Zuse is open source and free to use locally during beta.
- Compute. Cloud machines cost money whoever runs them. With Zuse you either use the Cloud Workspace plan, which includes a monthly compute allowance, or connect your own sandbox provider key and pay that provider. See pricing for current numbers.
- Model usage. Billed by Anthropic, OpenAI, or whichever provider you connect, under your plan or API key. Bringing your own plan changes who bills you for inference; it doesn't make the compute free.
To estimate, time one representative task end to end, including review. Know your token spend covers the model side.
The cloud agent landscape, briefly
These products overlap with Zuse in different ways. The descriptions below come from each vendor's own documentation at the time of writing; check current docs for anything you plan to rely on.
| Product | Who runs the machine | Agents and models | Source |
|---|---|---|---|
| Cursor Cloud Agents | Cursor-managed VMs; tool calls can run on your own machines while the agent loop stays in Cursor's cloud | Cursor's agent, with a curated model list | Closed |
| GitHub Copilot cloud agent | GitHub cloud sandboxes, GitHub Actions runners, or a remote custom environment | Copilot, with model selection; Claude and Codex agents in public preview | Closed |
| Claude Code cloud sessions | Anthropic-managed, or your org's self-hosted environment | Claude Code | Closed |
| Codex Cloud | OpenAI-managed | Codex; requires a ChatGPT sign-in | Codex CLI is open source; Codex Cloud is a hosted service |
| Devin | Cognition-managed; Devin for Terminal runs locally | Devin; Devin Desktop also runs third-party agents over ACP | Closed |
| Amp | Amp-managed "Orbs", or local | Amp | Closed |
| OpenHands | Your laptop, a VM, Docker, or OpenHands Cloud | OpenHands agent, Claude Code, Codex, and other ACP agents | MIT core; OpenHands Cloud is commercial |
| Zuse | Your machine, your VM via Zuse Serve, or cloud chats on boxd, Boat, or E2B | Claude Code, Codex, Cursor, Grok, OpenCode, and others | AGPL-3.0 |
A vendor's own cloud agent is the easiest start if you've standardized on that vendor, and some (GitHub Copilot, Devin Desktop) now run other agents too. Zuse is for teams that want to choose the agent per task, keep their existing plans, and be able to read the code that holds their credentials. OpenHands is the closest open source comparison; it leans toward self-hosted agent servers and automations, while Zuse leans toward a desktop and mobile workspace with managed cloud machines and local worktrees in the same sidebar. If you're comparing with Devin specifically, read our open source Devin alternative guide.
For a wider view, our cloud coding agents comparison lists hundreds of cloud agents, agent workspaces and coding CLIs side by side, with a source link for every row.
Run your first cloud task
- Pick a repository that builds from a clean clone. If it doesn't, fix setup before involving an agent.
- Choose one bounded task with a known check. "Fix the duplicate notification after reconnecting; reproduce by disconnecting mid-delivery; run the delivery tests" beats "improve notifications".
- Set up access once. Connect GitHub, authenticate the agent, and build an image (steps). Verify each separately: a working clone doesn't prove the model accepts your credentials.
- Start the chat with a Cloud · machine selected, and confirm the first reply arrives.
- Review the branch: the diff, the commands that ran, and anything the agent says it couldn't verify.
Once one task goes cleanly from start to merge, add a second one in parallel.
FAQ
What are open source cloud agents?
Coding agents that run on remote machines, coordinated by software whose source code is published under an open source license. You can inspect how the workspace handles your code and credentials, and run parts of it on infrastructure you control. The model behind the agent can still be proprietary.
How are cloud coding agents different from local agents?
Local agents run on your computer against your checkout, including uncommitted files. Cloud agents run on a separate machine per task, start from a pushed branch, keep running when your laptop sleeps, and scale past your laptop's CPU and memory. Local is better for work that needs your devices or local data; cloud is better for long or parallel tasks.
Can I run Claude Code in the cloud with Zuse?
Yes. Cloud chats support Claude Code with a Claude subscription token, an Anthropic API key, or a compatible endpoint, and Codex with a ChatGPT sign-in, an OpenAI API key, or a compatible endpoint. Provider terms apply to how you use each; see the plan guide.
Is Zuse free?
The desktop app is open source and free to use locally during beta. Cloud machines cost money: use the Cloud Workspace plan or connect your own boxd, Boat, or E2B key and pay that provider. Model usage is always billed by your model provider. See pricing.
Can I self-host Zuse?
You can run agents on any Mac or Linux machine you control with Zuse Serve and reach it from the hosted web app or Zuse for iPhone. The hosted cloud control plane's code is in the repository, but it isn't packaged as a turnkey self-hosted install.
Does Zuse see my code or resell tokens?
Zuse doesn't resell tokens; your provider bills you directly. Locally, your code stays on your machine and goes to the model provider you chose. In the cloud, your repository is checked out on the machine running your chat, on the compute provider you selected, and your account image (which includes your connected repositories) is stored with each provider you build it for.
Which agents does Zuse support?
Locally: Claude Code, Codex, Cursor, Grok, OpenCode, Kiro, Pi, and ACP-compatible agents. In cloud chats: Claude Code, Codex, Cursor, and Grok.
Do cloud agents replace code review?
No. They produce branches and evidence faster, which makes review the bottleneck. Read the diff, check which commands ran where, and keep the merge decision with a person.
Start with one reviewable task
Download Zuse, read the setup docs, or inspect the source. The journal has release notes and engineering write-ups as the cloud workspace evolves.
