How Many Coding Agents Can One Developer Actually Run?

Published August 17, 2026 · by the AQ team

Most developers plateau at two to four concurrent coding agent sessions, and the ceiling is not compute, rate limits, or tooling: it is attention. Every running agent generates interruptions (permission prompts, questions, finished work waiting on you), and every diff it produces is code you have to read and own. A fifth session started before the first one's output is reviewed adds a backlog, not throughput. This guide covers where the ceiling comes from, what practitioners actually run, the tactics that genuinely raise a personal limit, and why the durable fix is spreading sessions across a team, not one person's terminal tabs.

Why the ceiling is attention, not compute

Starting another agent costs almost nothing now. As of August 2026, parallelism is a first-class feature of the agent CLIs themselves: Claude Code ships a --worktree flag that starts each session in its own isolated git worktree, its desktop app gives every new session a worktree automatically, and agent teams coordinate multiple sessions natively. The mechanical blockers (file collisions, port conflicts, terminal management) are mostly solved. What did not scale is you.

Attention research explains why. Gloria Mark and colleagues at UC Irvine, in widely cited studies of interrupted work, measured that returning fully to a complex task after an interruption takes on the order of 23 minutes, with roughly two other tasks handled in between. The same research found people compensate for interruptions by working faster, at a measurable cost in stress. A coding agent session is, functionally, an interruption generator: it needs a decision every few minutes to every half hour, on an unpredictable schedule. Run five of them and you are not doing five tasks in parallel; you are doing one task, badly interleaved, called supervision.

Brent Fitzgerald's widely shared August 2026 essay The Human Is the Loop names the failure mode: don't trap the human inside the agent loop, refreshing terminals and rubber-stamping prompts; keep the human in charge and tag the agent in deliberately. "How many agents can I run?" is really "how many loops can I sit inside before none of them gets real judgment?"

What practitioners actually run

The published numbers cluster tightly. Anthropic's own power user tips for Claude Code recommend spinning up three to five git worktrees, each running its own session, as a headline productivity unlock (as of August 2026). Independent write-ups and community threads converge a notch lower: two is the comfortable steady state, three is workable when at least one task is long and hands-off, and past that the switching overhead eats the gains. The caveat everywhere: parallelism only pays when at least one session runs with minimal supervision; two sessions that each need you every two minutes are slower than one.

Treat your own felt speed with suspicion while you calibrate. A July 2025 randomized trial by METR had 16 experienced open-source developers complete 246 real tasks and found they were 19 percent slower with AI assistance while estimating, afterward, that they had been 20 percent faster. The tools have moved on since (METR itself labels the result historical), but the methodological lesson has not: measure merged, reviewed work over a week, not how busy your terminal grid looks.

Think WIP limits, not parallelism

The useful mental model comes from kanban, not from threading. Your throughput is set by how fast work exits the pipeline (reviewed, tested, merged), not by how much is in flight. Every agent session cycles through prompt, work, review, land, and you are the reviewer for all of them, so your review capacity is the pipeline's narrow point. Work-in-progress beyond that point does not ship sooner; it just ages, drifts out of your head, and gets rubber-stamped when you finally return to it.

That is where the two-to-four figure comes from: one steering session plus one to three grinding sessions is the most attention most people have. Everything else belongs in the queue, as a written task, not as a running session accumulating unreviewed output.

Tactics that raise your personal ceiling

Make agents push instead of you polling. Checking terminals on a timer means paying the context-switch tax on a schedule, needed or not. Every serious tool now supports the inverse: Claude Code's hooks can fire a desktop notification the moment a session waits on input (it is the first walkthrough in the hooks documentation), and Warp sends system notifications when an agent needs permission or approval (both as of August 2026). Wire these up before adding a third session.

Isolate everything by default. One task per git worktree, one dev server per checkout, so no session can corrupt another's state and no review requires untangling interleaved diffs. Our worktrees guide covers setup; the parallel sessions guide covers the daily workflow.

Lengthen the leash before adding lanes. The supervision cost per session is not fixed: a task with a written spec, a failing test to satisfy, and clear boundaries can grind for an hour unattended, while a vague one needs a decision every three minutes. Investing in the prompt and the guardrails raises your ceiling more than any terminal multiplexer. A session that needs you constantly is pair programming; that can be exactly the right mode, but count it as your one steering slot.

Batch reviews, and review properly. Reviewing three finished sessions in one sitting beats interleaving review with steering. What that review should cover (the transcript and the decisions, not just the final diff) is its own topic: see how to review an AI coding session.

The uncomfortable data: one person ends up holding all of it

Scaling agent count without scaling review is not hypothetical; it is the default. A July 2026 LeadDev analysis of 25,264 agent-generated pull requests across 2,361 popular GitHub repositories found that in 79 percent of agentic PRs the same developer both reviewed and modified the agent's contribution, and only about one in eight workflows involved multiple humans. Agents multiplied code generation, but the checking still lands on a single person, which means the whole pipeline is capped by one individual's two-to-four-session attention budget, and the check itself collapses into self-review.

Read the other way, the same data shows the headroom. The fleet a group can supervise is much larger than what any individual can, but only if sessions are visible and transferable: a teammate can only pick up a stuck session, or review a finished one, if it lives somewhere shareable rather than in a terminal on someone's laptop. Solo, the ceiling is your attention. On a team, the ceiling is the team's attention, provided the tooling lets attention move to where it is needed.

Where AQ fits

AQ is the multiplayer coding harness where engineering teams run AI coding agents like Claude Code and Codex together: shared live terminals, a code editor, and app previews, in your own cloud. It is built around this guide's constraint: it does not raise your personal attention ceiling (two to four is still the honest number); it changes whose attention a session can draw on.

Agents run as real CLIs (Claude Code, Codex, Cursor Agent, Kimi, Grok, or plain shells) in persistent tmux sessions on your team's VM, streamed live to the browser. Sessions survive a closed laptop and resume from any device, so a grinding task keeps grinding while you sleep, and the morning starts with review instead of restarts. Each workspace gets its own isolated git worktree (branch ai/{id}-{slug}, dependencies installed automatically, one-click rebase onto main), so the isolation discipline above holds by construction.

The team part is the point. Teammates open the same workspace and watch the same live session, so "is that agent stuck?" is answered by looking. If a session needs hands, its owner can approve a control request in one click and delegate the typing while keeping their own input. Workspace visibility stays owner-managed: team-visible by default if you want it, or private and shared with specific people. Linear intake keeps the queue honest too: label an issue ai-task and a workspace appears with status syncing both ways and ownership following the assignee; a human starts the agent when a slot frees up, nothing auto-launches.

Plainly: if you work alone and two to four sessions in tmux with notification hooks covers you, do that; this guide is enough. AQ earns its place when the sessions should outlive laptops and be reviewable by more people than the one who started them. The Free plan is a personal sandbox (AQ creates a private machine in an isolated network, nothing to install, no time limit), and the Team 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.