Every background coding agent follows the same fundamental loop: (1) Accept a task via CLI, chat, or API. (2) Spin up an isolated environment — a cloud sandbox, a container, or a VM. (3) Clone the repo, make changes, run tests. (4) Self-review and iterate until the task passes quality checks. (5) Open a PR for human review. The entire cycle happens without your IDE open. You submit the task and come back to a finished PR.

The word “background” is the key differentiator. Interactive agents (Level 2–3) run in your session — they stop when you stop. Background agents run independently. This decoupling is what enables parallelism: you can have multiple agents working on different tasks while you focus on architecture, reviews, or entirely different work.

Codex runs agents in cloud sandboxes — isolated environments with their own filesystem, terminal, and network access. Each task gets a fresh clone of your repo. The agent follows an iterative loop: plan, edit code, run tools (tests/build/lint), observe results, repair failures, and repeat. The Codex CLI supports non-interactive execution via the exec command, enabling automation and CI integration.

Conversation resumption — you can resume a prior session with new instructions, and the agent retains the original transcript, plan history, and approvals. GitHub Action integration — Codex can be triggered from CI workflows. Course corrections mid-flight — you can redirect the agent without resetting its progress.

Devin runs in a full Linux VM with desktop access — not just a terminal sandbox. It can launch desktop applications, interact with browsers, and test UIs visually. Devin 2.2 (released Feb 2026) introduced self-verification: the agent plans, codes, reviews its own output, catches issues, and fixes them before the PR is opened. It handles the full development loop independently, with 3x faster startup than previous versions.

Devin can break down large tasks and delegate to multiple managed sessions working in parallel, each in its own isolated VM. A coordinator session monitors progress, resolves conflicts, and compiles results. This is multi-agent orchestration built into the product — you submit one task, and Devin decides how to parallelize it.

Claude Code takes a different approach: instead of a separate cloud product, it extends the CLI with subagent spawning. You can move any task to the background with Ctrl+B and continue working in your main session. Multiple subagents run concurrently when tasks are independent — for example, running style-checking, security scanning, and test coverage analysis in parallel. Monitor all running agents with /tasks.

You teach Claude when to use parallel vs sequential execution by adding routing rules to your CLAUDE.md file. The main agent reads these rules and makes automatic delegation decisions based on task dependencies and file boundaries. Subagents can be defined as markdown files in .claude/agents/ directories, giving you reusable, specialized agents for common workflows.

Bug fixes with clear reproduction steps — the agent can run the repro, verify the fix, and confirm tests pass. Boilerplate and scaffolding — new CRUD endpoints, form components, migration files. Dependency updates — bump versions, fix breaking changes, run the test suite. Well-scoped features with clear acceptance criteria — “add a dark mode toggle that persists to localStorage.”

Architecture decisions — the agent can propose, but you need to evaluate trade-offs. Ambiguous requirements — if you can’t write a clear task description, the agent can’t execute it. Security-sensitive changes — auth flows, encryption, access control need human judgment. Cross-cutting refactors that touch many systems — the blast radius is too high for unsupervised work.

Stripe’s Minions system introduced the blueprint pattern: workflows defined in code that specify how tasks are divided into subtasks, with some handled deterministically (linting, formatting, boilerplate generation) and others handled by the agent (logic implementation, test writing). The blueprint acts as a recipe — it knows the steps, but the agent fills in the creative parts. This is how Stripe’s Minions produce over 1,300 PRs per week.

Blueprints reduce the agent’s decision space. Instead of figuring out the entire workflow from scratch, the agent only needs to handle the parts that require reasoning. The deterministic steps (clone repo, create branch, run linter, format code, run CI) are reliable and fast. The agent steps (understand the task, write the implementation, handle edge cases) get the full power of the LLM. This hybrid approach is more reliable than pure agent execution.

Background agents work best on tasks that take a human 30 minutes to 2 hours. Below that, the overhead of writing a good task description isn’t worth it. Above that, the agent’s context window fills up, it loses track of the plan, and quality degrades. The sweet spot is well-scoped, single-PR tasks with clear success criteria.

Background agents can produce PRs faster than humans can review them. If you have 5 agents producing 5 PRs per hour, but your team can only review 3 PRs per hour, you’ve just moved the bottleneck from code writing to code review. The review process must scale with agent output — through better PR descriptions, automated pre-review checks, and structured review workflows.

Pick one tool (Codex, Devin, or Claude Code subagents). Pick one low-risk task type — dependency updates or adding missing test coverage are ideal. Submit 3–5 tasks. Review every PR carefully. Measure: how long did the agent take? How much review effort was needed? What percentage of PRs were mergeable without significant changes?

If your first batch went well, expand to bug fixes and small features. Start running 2–3 agents in parallel. Develop a template for task descriptions that consistently produces good results. The template should include: what to change, acceptance criteria, which tests to run, and any constraints (don’t touch these files, follow this pattern).