Sessions run on a device you bring, not the one in front of you - so the work continues even after you shut your laptop. Your own hardware, a cloud server, or serverless. The 2015 MacBook in a drawer, an EC2 instance, a Hetzner box, or a Cloud Burst lease. All of it under your control, all in one fleet. Enrolling is one pasted command, and a matching wipe script removes everything that command installed.
When a session runs on an enrolled device instead of the machine you're typing on, closing your lid changes nothing. The device keeps streaming, the plan keeps executing, the PR still merges. You walk away; the work carries on.
Kick off a long refactor on your desktop at home, shut the laptop on the train, and watch progress land on your phone the whole way in. The host doing the compute isn't the screen in your hands - that's the whole point.
Every enrolled device sends a heartbeat, so the fleet list is honest about what is awake. Sessions from every host collapse into one list on the Mac, in the browser, and on your phone, each row tagged with the machine it lives on. Archive a session on your phone and it stays archived on the Mac. Tap a session that lives on another box and you connect straight through: full transcript, live updates, working composer, not a frozen snapshot.
Because hosts are separate boxes, running four or five agents at once stops being a contest for one laptop's fan. That is the problem parallel Claude Code sessions solves with worktrees, moved up a level to hardware.
Point Continuum at a device and paste one command. Linux gets a tiny agent plus a systemd unit; Macs get Continuum in headless mode. Both auto-install over SSH or Tailscale, straight from Settings → Devices. It's your hardware, so nothing leaves your control.
The device shows up honestly - pulsing grey provisioning… while it sets itself up, then settles green live. No hidden state, no "it should be connected by now."
One script owns the whole install and narrates itself while it runs. On Linux that is: preflight the box, install the agent binary, write its environment, register a systemd unit, start the agent, provision its token, install Node, install the agent CLIs, verify health. On a Mac it installs Continuum, registers a LaunchAgent, starts it, and verifies health. Each step reports begin, ok, skip, or fail on its own line, and the devices list renders "Installing - <current step>" instead of one opaque spinner. When something breaks you get the step id that broke it.
Enrollment goes over SSH or your tailnet, which is the same access path you already use for running Claude Code on a remote box by hand. The difference is that a wipe script removes everything setup installed: the service unit, the binaries, the config directory, the staging files, the token. On a Mac it removes Continuum.app only if setup was the thing that installed it. Enrollment is reversible. If the box has no agent CLIs yet, setup installs them - the same packages covered in installing Claude Code on Linux.
No spare device handy? Connect your own Cloudflare or Vercel account and Continuum leases short-lived sandboxes to run the session. BYO quota caps, idle stops, hard caps - you set the ceiling, the sandboxes wind down when the work's done.
The lease runs on your cloud account, under your keys and your limits. On BYOK, Continuum adds $0 - it just orchestrates the lease, runs the session, and lets the box go. Hosted inference is optional if you want Continuum to supply the models.
Serverless hosts are short-lived by construction, so there is nothing to install and nothing to uninstall. You set an idle stop and a hard cap before the spawn; the sandbox winds down when the work finishes or the cap trips. That is the fix for the box you forgot to kill on Friday. For the token side of the same bill, see reducing Claude Code costs.
If you would rather not connect a cloud account at all, Continuum Cloud is the managed version for accounts that include it: pick Cloud as the device and a runner boots, clones, runs, and stops. It appears in the same chip as your Macs and Linux boxes, because it is a device pick like any other.
Your hardware, your cloud accounts, your keys, your provider subscriptions. Continuum never becomes a middleman - it orchestrates, and the compute + credentials stay yours. A session looks identical wherever it runs: same chat, same diff, same PR flow, with the running host as a chip next to the branch.
Every hop between controller and device rides an end-to-end-encrypted relay or your own tailnet. Move the work from your Mac to an EC2 box and nothing about the interface changes - just where it runs.
A device you pick is an answer, not a cache. Choose a host in the New Session chip and that choice survives disconnects, list refreshes, and relaunches. A Mac that goes to sleep drops off the online list for a moment; that is not permission to move your work to a different box. The pick is retired only when the device actually leaves your account. Switch hosts deliberately and the repo pick follows by name to that host's copy of the same repo, because the same project lives at a different absolute path on every machine.
A device answers the same endpoints the Mac daemon answers, so a phone talking to a Hetzner box and a phone talking to your desk Mac run identical code paths. That is why diff, plan, terminal, and PR all work no matter which host is underneath.
Nothing about a session is simulated on the host. The device checks out code, runs the vendor's own agent binary, executes the commands that agent asks for, and pushes the branch. Your control surface renders what came back.
Continuum doesn't reimplement the agents. The device runs the actual claude, codex, cursor, gemini, grok, or opencode binary and drives it. Model, reasoning effort, and plan-or-code mode are per session and can change mid-run. See Providers for the full matrix.
Worktree mode creates a git worktree on the device and runs the session there, so five sessions on one repo never fight over one checkout. Local mode runs in the repo itself when that's what you want. The mechanics are the same ones in Claude Code worktrees.
API keys and environment variables are injected on the host at spawn time. They are never typed into a phone and never sent to a control surface. A device holds credentials; a screen holds a view. More on Environments.
Short answers here, long answers in the docs.
Any Linux or Mac device you can SSH to - an old laptop, a Hetzner ARM box, an AWS EC2 instance, a machine in the closet - plus serverless Cloud Burst on Cloudflare or Vercel accounts you connect. Your Mac is the default device and controller; everything else is enrolled from Settings → Devices.
Yes, as long as the session is running on an enrolled device and not on the laptop itself. The device does the compute; your laptop is just a control surface. Close the lid and the session on the EC2 box or the old MacBook keeps streaming - you'll see it pick right back up on your phone or when you reopen.
No. On BYOK, Continuum adds $0: your hardware, your cloud accounts, and your provider subscriptions. Cloud Burst leases run against your own Cloudflare or Vercel quota with the caps you set; the model work still lands on the plans you already pay for. Optional Continuum-hosted inference (Plus, Max, Ultra) is a separate line only if you choose it.
Every session is visible in the fleet with its host chip, so a dead device is obvious, not silent. Respawn the work anywhere - your Mac, another device, or a fresh burst - and pick up from the transcript. The controller is the Mac; devices are replaceable. Remove a device from your account and its leftover sessions are archived rather than left behind as phantom offline rows.
No, and it shouldn't have one. Enrollment runs over SSH or your tailnet. After that, traffic between a control surface and a host rides an end-to-end-encrypted relay or your own Tailscale network. The host daemon accepts only loopback, CGNAT-range, and Tailscale peers, and every request carries a bearer token, so a device sitting behind NAT in your closet is the normal case rather than the hard one.
Most of the wall clock is downloads: the agent binary, then Node and the agent CLIs if the box doesn't have them. You watch it happen step by step in the devices list rather than staring at a spinner, and a failure names the step that failed instead of dumping a wall of SSH output. Re-running setup on the same box is safe; every step is idempotent.
Enroll a device in one line and close the lid. If you're weighing this against a hosted autonomous agent, read Continuum vs Devin; if you're weighing it against a Mac-only worktree runner, read Continuum vs Conductor.
your hardware · your cloud · your keys · Continuum adds $0 on BYOK