aq.dev / guides / always-on-coding-agents

Always-On Coding Agents: Where Should They Actually Live?

An always-on coding agent is one whose session survives you walking away: the laptop lid closing, the Wi-Fi changing, the workday ending. As of November 2026 there are three practical places to get that. You can fight your laptop's power management and keep the agent local, you can run the agent on a VM you control and let tmux hold the session, or you can hand tasks to a vendor's cloud (Claude Code cloud sessions, Codex Cloud, Cursor cloud agents, GitHub Copilot's cloud agent, and since November 3, 2026, Google's Antigravity Remote Agents). They differ on the axis that matters most: whether you get a persistent machine you own, or a task that runs to completion on someone else's. This guide walks all three honestly.

AQ is the persistent-machine route with shared team access: real agent CLIs run in persistent sessions and isolated git worktrees on a team-owned or AQ-managed machine, and teammates open the same live workspace from a browser.

The question that decides everything: where does the agent process run?

Two features can look identical from a phone: you open a browser tab, you see your agent working, you send it a message. What differs is where the agent process lives. In remote execution, the agent and its tools run on a machine someone else keeps powered (a vendor's cloud or your own server), so the work continues with your computer shut. In remote control, the agent still runs on your own computer, and the browser is a window onto it: when that computer sleeps or goes offline, there is nothing to reach.

Google now ships both, under similar names, which makes Antigravity the clearest illustration. Per Google's Remote Agents documentation, checked November 8, 2026, Remote Agents run "your agent sessions and tools in an isolated, Google-managed remote environment rather than on your local machine," and they keep working "even when you close your browser, put your laptop to sleep, or switch between desktop and mobile devices." Antigravity Remote Control is the other kind: it lets you drive Antigravity desktop sessions and CLI instances running on your own machines from any browser, and Google's comparison says it requires your host machine "to remain powered on and online." Once you know which of the two you have, the rest of the comparison follows:

TopicRemote control of your own machineVendor-managed remote executionA persistent machine your team keeps
ExampleAntigravity Remote ControlAntigravity Remote AgentsA VM you own, or AQ
Keeps working with your computer offNo: the host must stay powered on and onlineYesYes
File persistenceWhatever is on your diskPer Google, uploads persist across conversations in the project (up to 100 MiB per project); Google's docs do not describe how long the workspace itself livesThe working tree stays on the machine until you remove it
Repository accessYour local checkoutsGitHub repositories cloned into the workspace, plus Google Drive files read on demandAny repository the machine can reach, any git host
Whose credentialsYours, on your machineOAuth grants Google says are encrypted at rest and injected when the agent calls an authorized serviceEach person's own CLI and GitHub logins, on a machine in your account (or a dedicated AQ-managed one)
Local hardware and dev serversYour hardware, your localhostGoogle's docs do not describe hardware, ports, or previewsThe machine's hardware; dev servers keep running between tasks
CleanupYours to manageNot described in Google's docs as of November 8, 2026Yours, or the platform's when a task is closed

Two details from Google's documentation matter for planning. Remote Agents are rolling out gradually to Google AI Pro and Ultra subscribers who sign in with a personal Google Account, and are not offered on the free plan, Google AI Plus, or Google Workspace and Google Cloud business accounts. And unless you change it, a remote agent's permission preset is always-proceed, so it runs commands without asking. The encryption and isolation statements above are Google's own descriptions; AQ has not tested them.

Why a laptop is never really always-on

Agent CLIs like Claude Code and Codex are ordinary terminal processes. When the operating system sleeps, the process freezes mid-task and does not resume the work when the machine wakes. Every laptop is built to sleep: on battery, on idle, and (on Apple Silicon Macs) whenever the lid closes, regardless of what utilities like caffeinate promise. Even a laptop that stays awake is one OS update, one dead battery, or one hotel Wi-Fi handoff away from a dead session.

You can push the boundary. macOS caffeinate prevents idle sleep for a wrapped command, and Windows lets you set the lid-close action to "do nothing" while plugged in. That is genuinely enough for a two-hour run while you make dinner, and if that is your actual problem, keeping Claude Code running after closing your laptop covers every trick in detail (and the Codex version exists too). But a kept-awake laptop is a workaround, not an architecture: it still travels, reboots, and drops off the network with you. Always-on means the agent lives somewhere that does not.

Route 1: a VM you own

The reliable default is boring: a Linux VM in your own cloud account (or a spare machine at home), the agent CLIs installed and logged in, and tmux holding each session. tmux runs a server process on the machine; your SSH connection is just a client. When your connection drops or your laptop sleeps, the server and the agent inside it keep running, and you reattach from any device later.

# On the VM, once: install and log in to your agent CLIs
ssh dev-box

# Per task: a named session that outlives every disconnect
tmux new -s payments-refactor
claude        # or codex, or any terminal agent

# Detach: Ctrl-b then d. Close the laptop. Hours later, from anywhere:
ssh dev-box
tmux attach -t payments-refactor

What you get for that effort: sessions that survive your laptop entirely, any agent CLI you like (including several at once), full custody (the repository clone, GitHub tokens, and shell live on hardware in your own account), and access to anything inside your network. The costs are equally concrete. A VM able to run builds comfortably runs from a few dollars to some tens of dollars per month depending on size and provider, which is a rounding error next to what the agent's model usage costs. The real price is operational: you harden SSH, you script git worktrees so parallel tasks do not trample one checkout, and you remember that tmux sessions live in memory, so a reboot clears them unless you add systemd units or a resurrection plugin. The step-by-step path is in run Claude Code on a cloud VM, and self-hosted AI coding agents compares the broader landscape.

Route 2: a vendor cloud

Every major agent vendor now runs its agent for you, and these are genuinely good at what they are scoped for. Each claim below comes from the vendor's own documentation, dated where it was last checked.

Claude Code cloud sessions (Claude Code on the web; documented for Pro, Max, Ultra, and Team plans and eligible Enterprise seats as of November 7, 2026) give each task an isolated Ubuntu VM in the default Anthropic-hosted setup, which clones the repository, runs the environment's setup script, and works on a branch. Sessions persist when you close the browser and can be followed from the mobile app; Team and Enterprise organizations can also route sessions to self-hosted environments in public beta. Claude cloud sessions explained covers what persists and for how long.

Codex Cloud runs tasks on OpenAI-managed virtual machines. OpenAI relaunched it on September 29, 2026 around published cloud environments: a reusable setup holding repositories, dependencies, tools, and access settings, from which every task gets its own isolated workspace. Internet access is off until enabled per environment. It is task-scoped by design: you delegate a unit of work, not a machine. Details are in Codex Cloud tasks explained.

Cursor cloud agents run in isolated Ubuntu VMs on Cursor's cloud, each with a full desktop and browser the agent can drive to verify its own changes, and Cursor positions them for long tasks that take hours. An enterprise self-hosted option (announced March 2026) keeps the workers on your infrastructure while orchestration stays in Cursor's cloud.

GitHub Copilot's cloud agent works inside an ephemeral GitHub Actions-powered environment: assign it an issue or prompt, it explores the repository, runs tests, and opens a pull request, and you can steer a running session with follow-up messages. Enterprises can point it at self-hosted Actions runners. (Cursor and Copilot details as of August 2026.)

Antigravity Remote Agents (rolling out from November 3, 2026, per Google's changelog) run Antigravity sessions and tools in an isolated, Google-managed environment. A project attaches GitHub repositories, Google Drive files, and uploads, and you start and manage conversations from the Antigravity desktop app, the Antigravity CLI, or the web. The same release reorganized Antigravity's Automations into Scheduled, Always on, and Paused lists, which is Google's answer to standing jobs. Access is for eligible personal Google AI Pro and Ultra accounts; Google's plans page lists no separate price for it. The Antigravity CLI page covers the agy command itself.

The shared tradeoffs are structural, not quality complaints. Each vendor cloud is built around its own agent (GitHub's also hosts some third-party agents), so a team using Claude Code and Codex side by side gets two separate consoles with different behavior. The environments are task-scoped or reclaimable, not persistent machines: state you did not push, a database you seeded, a dev server you left running, all evaporate between tasks. And except for the self-hosted variants, execution happens in the vendor's cloud, which your security review may or may not accept for private code.

The real question: do you need a task runner or a machine?

Vendor sandboxes answer "run this task while I do something else." A VM answers "give my agents a permanent place to live." If your always-on need is fire-and-forget PR-sized tasks, a sandbox is less work and you should use one. If it is longer-horizon work (an agent mid-refactor you want to reopen tomorrow, several agents in parallel on one codebase, dev servers a teammate can click through, tools and credentials that persist), you want a machine, and the glossary entry on background agents vs cloud agents unpacks the vocabulary vendors use around this split. If you are comparing how platforms isolate and clean up each task, coding agent workspaces covers the lifecycle.

TopicKept-awake laptopVM you ownVendor cloud
Survives lid closeSometimes (settings dependent)YesYes
LifetimeUntil sleep, reboot, or travelPersistent until you stop itTask-scoped or reclaimed on inactivity
Which agentsAny CLIAny CLI, several at onceMainly that vendor's agent
Code and credential custodyYour machineYour cloud accountVendor's cloud (self-hosted variants excepted)
Setup effortMinutesAn afternoonMinutes

Where AQ fits

AQ is the multiplayer coding harness where teams run AI coding agents like Claude Code and Codex together, in shared live workspaces on their own cloud. In this guide's terms, AQ is the persistent-machine route with the afternoon of setup and the ongoing glue done for you, plus the part the three routes above do not give you: your team in the same live session.

Real agent CLIs (Claude Code, Codex, Cursor, Kimi Code, Grok, Antigravity CLI, Devin, and more) run in persistent sessions on your team's machine, each person signed in with their own account, and the work streams live to the browser. The machine is the remote-execution kind: closing your laptop does not stop anything, and you pick the work up from any device, phone included. Each work item gets its own isolated git worktree and branch, so parallel agents never collide, and it can run a live app preview with a shareable link. Teammates open the same workspace and watch the same live session; typing into someone else's terminal happens only after its owner approves a control request. Custody stays yours: VMs you connect from your own cloud, or a dedicated always-on AQ-managed VM in its own isolated network, and AQ never marks up usage on your own subscriptions. When a work item is closed, AQ removes its worktree from the machine.

AQ does not offer Google-managed Remote Agents, Antigravity Remote Control, Drive-backed projects, or Antigravity's OAuth injection; it runs the Antigravity CLI as one harness among many, on a machine your team keeps.

Pricing is two plans: Free runs agents on your own Mac with the AQ Mac app (private to you, free with no time limit), and the AQ Pro plan is $50 per user per month in early access (standard $200, billed monthly), covering VMs you connect from your own cloud or a dedicated always-on AQ-managed VM, with the rate locked for your first 12 months.

Plainly: for solo fire-and-forget tasks, the vendor clouds are excellent and simpler. For one engineer comfortable in tmux, the plain VM is enough. AQ earns its place when always-on stops being a personal convenience and becomes how the team works: many agents, one place, everyone able to see and steer them.

Frequently asked questions

Can I keep a coding agent running 24/7 on my laptop?

Not reliably. Utilities like macOS caffeinate prevent idle sleep, and Windows can be set to ignore the lid, but Apple Silicon Macs sleep on lid close regardless, and every laptop eventually reboots, updates, or leaves the network. A kept-awake laptop covers a single evening run; always-on means moving the session to a machine that never sleeps, either a VM you own or a vendor's cloud.

Do vendor cloud agents keep running after I close the browser?

Yes, while a task is active. Claude Code cloud sessions persist when you close the browser and can be followed from the mobile app, Codex Cloud tasks run on OpenAI-managed VMs, Cursor and Copilot agents finish without you watching, and Google says Antigravity Remote Agents keep working when you close the browser or put your laptop to sleep. The caveat is lifetime: these are task-scoped or vendor-managed environments, so state you did not push or upload does not persist the way it would on your own VM.

What is the difference between Antigravity Remote Agents and Remote Control?

Where the agent runs. Per Google's documentation checked November 8, 2026, Remote Agents run sessions and tools in an isolated, Google-managed environment and keep working while your laptop sleeps. Remote Control lets you drive Antigravity sessions running on your own machine from any browser, and that host must stay powered on and online. Remote Agents are rolling out to personal Google AI Pro and Ultra accounts; Remote Control can need an account or organization setting to be enabled.

What does an always-on VM for coding agents cost?

Less than the model usage it hosts. A small cloud VM suitable for agent work costs from a few dollars to some tens of dollars per month depending on size and provider, and one VM can host many agent sessions in parallel. For most teams the LLM subscription or API spend dominates total cost, so the VM is not the line item to optimize.

Which is safer for private code: my own VM or a vendor sandbox?

They draw different boundaries. On your own VM, the repository clone, GitHub tokens, and shell stay in your cloud account, and only prompts go to the model provider. In a vendor cloud, the execution environment itself runs in the vendor's cloud (Anthropic, OpenAI, Cursor, GitHub, or Google), under that vendor's isolation and data terms. Anthropic, Cursor, and Copilot offer self-hosted execution variants for organizations. Which is acceptable depends on what your security policy actually requires: check whether it constrains where code executes, or only where it is stored.

Can several always-on agents share one machine?

Yes, and one VM running several agents is usually better economics than several sandboxes. The requirement is isolation between tasks: give each agent its own git worktree and its own tmux session so two tasks never edit one checkout. That is scriptable by hand, and it is the arrangement AQ sets up per work item automatically, one isolated worktree and persistent session per task.