Background Agents and Asynchronous Delegation
Synchronous agent use — you watch the agent work — caps your leverage at one attention-stream. Asynchronous delegation removes the cap: hand an agent an issue-sized task, walk away, and get back a pull request. The category matured through 2025–2026 into a standard part of professional workflows, and it is still shipping fast enough that any tool matrix goes stale in months (this one is dated August 2026).
- GitHub Copilot coding agent — the canonical issue-to-PR loop: assign a GitHub issue to Copilot; it works in a GitHub Actions sandbox, explores the repo, edits, runs tests, and opens a PR. Frictionless if you're already on Copilot Business/Enterprise.
- Devin (Cognition) — the most autonomous of the cloud agents; Devin 2.0 cut entry pricing from $500/mo to ~$20/mo, moving it from enterprise-only to individually trialable.
- Google Jules — asynchronous, issue-driven workflow tied to your repository.
- Codex Cloud (OpenAI) and Cursor Cloud Agents — cloud execution lanes attached to their local/IDE siblings, so the same harness spans interactive and delegated work.
- Claude Code (web + GitHub integration) — Claude Code sessions running server-side against your repo, plus PR-triggered automation via Actions.
- OpenHands — the self-host option: open-source, model-agnostic, deployable inside your own boundary.
Mechanically these are ParallelAgentsAndWorktrees with the isolation moved server-side: each delegated task gets a sandboxed checkout and branch, and the PR is the merge discipline. Long-running platforms add checkpointing and resume, with sessions ranging from minutes to days.
What Delegates Well
Async delegation works when the task is well-specified, bounded, and mechanically verifiable — the agent cannot ask you mid-flight follow-ups, so ambiguity that a synchronous session would resolve in one exchange becomes a wrong PR:
- Bugs with a reproduction (the repro is the acceptance test)
- Test-coverage pushes against defined modules
- Dependency bumps and the resulting fix-ups
- Mechanical migrations with a clear pattern and a worked example
- Documentation-drift sweeps against the code
What delegates poorly: open design questions, anything requiring taste or product judgment, tasks whose acceptance criteria you can't write down, and work in code you don't yet understand yourself — reviewing a PR in unfamiliar territory costs more than pairing synchronously would have.
A reliable task template: context (links, constraints, relevant files), acceptance criteria (checkable), verification command (the exact command whose green output means done). If you can't fill in the third field, the task isn't ready for async.
The Economics: Your Review Queue Is the Bottleneck
The naive read is "agents work while I sleep, so throughput is free." The actual constraint is that every delegated task returns as a PR you must review, and review of unfamiliar diffs is expensive. Async delegation pays when:
- Tasks are chosen so the verification is cheap (mechanical checks, good tests) even when the diff is large.
- A review agent runs as first pass on every returned PR (VerificationLoopsForAgenticCoding), so human review starts from findings, not from scratch.
- You dispatch in batches and review in batches, rather than context-switching per PR — the dispatcher-and-review-queue rhythm that defines Level 4 of the AgenticCodingMaturityModel.
Babysitting — watching an async agent work — is the anti-pattern that deletes the entire benefit. If a task needs watching, it wasn't an async task.
Safety and Sandboxing
- Branch protection is the contract: agents open PRs; they never push to main. CI runs the same gates as for humans — the agent's claim that tests pass is not the gate; CI's green check is.
- Sandbox secrets narrowly: the agent's execution environment gets the minimum credentials for build-and-test, never production secrets.
- Treat repository and issue content as untrusted input: an agent that reads issues, comments, and code can be steered by instructions planted in them — prompt injection is a real attack surface for issue-driven agents. See AgenticCodingFailureModes.
- Cost ceilings per task: runaway sessions on a hard task can burn a day of budget; platforms expose per-task limits — set them.
See Also