Chapter 15: Async & Background Agents
From Pair Programmer to Delegated Teammate
The biggest shift of 2026 is that the most valuable agent work no longer happens at your keyboard. It happens asynchronously, in the cloud, in parallel. You delegate a task or assign a GitHub issue, the agent spins up its own sandboxed environment, does the work, runs the tests, and comes back with a pull request. You review the outcome rather than babysit the process.
The async agent landscape:
* OpenAI Codex (cloud tasks) - delegate work that runs in an isolated environment and returns a PR
* Google Jules - asynchronous agent that clones your repo, plans, and proposes changes
* GitHub Copilot coding agent - assign an issue; it works and opens a PR for review
* Claude Code background and cloud tasks - long-running and headless work, including orchestrated subagents
* Devin - an autonomous engineer for delegated, multi-step tasks
* Grok Bot and Cursor cloud agents - always-on agents with their own cloud machines, subscribed to events instead of waiting for assignments
Why Async Changes the Workflow
Synchronous agents are bounded by your attention - you can only watch one work at a time. Async agents are bounded by your ability to review and by the quality of the intent you gave them. That inverts the constraint. A single engineer can have five agents working in parallel on five issues, then spend their time reviewing five pull requests instead of writing five features.
This is where intent specs and evals stop being optional. When you are not watching the agent work, the only things standing between "looks done" and "is done" are the success criteria you wrote down and the evals that check them. An async agent that self-reports success on a half-finished job is the Silent Partial Completion failure mode at scale.
Patterns for Running a Fleet
Decompose into independent units. Async agents shine on well-scoped, parallelizable work: a batch of migrations, a set of test-coverage gaps, a list of dependency upgrades. Hand each unit a clear intent and let them run.
Isolate to avoid collisions. Give each agent its own branch or worktree so parallel work does not conflict. Merge through normal review and CI.
Gate on evals, not vibes. Every returned PR runs the same CI eval suite. The agent's confidence is not a signal; the eval result is.
Keep a human on irreversible actions. Async agents can open PRs freely. They should not deploy, run schema migrations, or send customer communications without an approval gate.
From Sessions You Drive to Standing Agents You Steer
The late-2026 shift is that async agents stopped being tasks you launch and became processes that are always on. Claude Code Routines run scheduled agent work on cron, webhooks, or API triggers. Cursor's cloud agents subscribe to events - a PR opens, a Slack thread mentions the service, a deploy fails - and pick up the work without being asked. Grok Bot ships agents with persistent cloud machines of their own. The mental model moves from delegating tickets to running a small standing team.
That promotion changes the governance bar. A standing process with tool access is production infrastructure whether or not you call it that - so every ambient agent gets what any service gets: an intent spec, a named owner, an eval gate on its output, and a budget. An agent you launch and watch can borrow your judgment in real time. An agent that wakes up on a webhook at 3am cannot, which is exactly why the intent spec discipline from Chapter 4 exists.
The enterprise blocker fell in mid-2026, too: cloud agents learned to run on customer infrastructure. Self-hosted runners give you the cloud operating model - sessions that survive a closed laptop, scheduled work, central visibility - with execution inside your own network boundary, which is what regulated environments had been waiting for (see Chapter 22).
Migration at Scale: A Real Pattern
Repetitive transformation work - the kind no team wants to staff but every business needs done - is the killer application for async agents. A migration of hundreds of pages or services becomes a pipeline: each item gets an intent spec (objective, success criteria, cost ceiling, stop rule), an agent transforms it in an isolated environment, an eval verifies the result against a visual diff and link check, and anything that trips an escalation trigger routes to a human. Run hundreds of these and the throughput is not human-paced. The discipline that makes it safe is intent, not optimism.