When one person can spawn a dozen LLM agent sessions in parallel, the bottleneck is no longer the agents.
It is the human trying to keep track of them all.
Your working memory holds a handful of items at best, your context switching cost is real and measurable, and every interruption leaves residue that degrades the next task you pick up.
The question is not whether you can run 20 sessions simultaneously.
The question is whether you can remain effective while doing so.
The Cognitive Bottleneck
#
Before discussing strategies, it helps to understand what actually limits a human supervisor.
Working memory is tiny.
George Miller’s foundational work suggested that humans can hold approximately seven plus or minus two items in short-term memory.
Later research by Nelson Cowan revised this estimate down to about four chunks for young adults.
Either way, the number is small.
If each agent session requires you to remember its goal, its current state, its blockers, and the decision you were about to make, you hit the ceiling at three to five sessions, not twenty.
Context switching has a measurable cost.
Research on task switching in cognitive psychology shows that switching between tasks incurs a time penalty, sometimes called “switch cost.”
This cost ranges from fractions of a second to several minutes depending on task complexity.
When you switch from agent session A to agent session B, you must offload A’s context from your working memory, load B’s context, and reconstruct where you left off.
The more complex each session’s context, the more expensive the switch.
Attention residue accumulates.
When you switch from one task to another without fully completing the first, part of your attention remains stuck on the previous task.
The Zeigarnik effect describes how unfinished tasks persist in memory, consuming cognitive resources even when you are trying to focus on something else.
With multiple agent sessions running concurrently, many are perpetually unfinished, creating constant attention residue.
Decision fatigue compounds.
Each agent session requires you to make decisions: approve this output, redirect this approach, answer this clarifying question.
Research on decision fatigue shows that the quality of decisions degrades after a long session of choice-making.
Supervising many sessions means making many decisions, and the later decisions in the day will be worse than the earlier ones unless you manage the load.
Working memory, switch cost, attention residue, and decision fatigue together define the ceiling on how many sessions you can manage.
Every strategy below works by attacking one or more of them.
Strategy 1: Externalize All Session State
#
The single most powerful principle is to stop relying on your brain to hold session state.
If it is not written down, it is consuming working memory.
Maintain a state file per session.
Every agent session should produce a machine-readable and human-readable state file that captures its current status, goal, progress, blockers, and next steps.
When you return to a session after an hour or a day, you read the file, not your memory.
The file is the single source of truth.
This is the agent equivalent of the workstack concept applied at scale.
Use structured status summaries.
The state file should follow a consistent template across all sessions.
A format like the following works well:
Session: fix-auth-bug
Goal: Fix OAuth callback failing on production
Status: blocked
Progress: Identified root cause (clock skew on load balancer)
Blocker: Need production access to verify fix
Next: Deploy fix to staging, verify callback works
When every session uses the same structure, you can scan a dashboard of twenty sessions in under a minute.
The consistency eliminates the cognitive parsing overhead that comes from varied formats.
Write decisions to a log.
Every decision you make about a session should be written to the session’s log file with a timestamp and rationale.
This serves two purposes.
First, when you return to the session, you can see not just where it is but why it is there, without reconstructing the reasoning.
Second, the log becomes an audit trail that other humans (or agents) can consume.
Checkpoint before switching.
Before switching away from any session, write a one-line “resume hint” that tells your future self exactly where to pick up.
This takes five seconds and saves minutes of reconstruction time.
The hint should be specific enough that you can act on it without re-reading the entire session history.
Strategy 2: Standardize All Interactions
#
Variability is the enemy of scale.
Every difference between how sessions operate is a new thing your brain must parse, increasing cognitive load and switch cost.
Use a uniform session protocol.
Every session should follow the same lifecycle: initialization, execution, checkpointing, escalation, and completion.
The protocol defines what the agent does at each stage, what it reports, and how it signals that it needs human input.
When the protocol is uniform, switching between sessions costs less because you always know what to expect.
Standardize output formats.
If session A reports progress in a bulleted list and session B writes a paragraph and session C uses a table, your brain must context-switch not just on content but on format.
Pick one format and enforce it everywhere.
Markdown headers, numbered lists, and consistent section ordering let your eyes scan quickly without parsing structure.
Establish a shared vocabulary.
Define the terms agents use to communicate status: “blocked,” “waiting-for-human,” “in-progress,” “complete,” “failed.”
Every agent uses the same words to mean the same things.
This reduces ambiguity and eliminates the need to translate between sessions.
Create session naming conventions.
A session named “auth-fix-3” tells you nothing when you have twenty sessions.
A session named “fix-oauth-callback-prod-bug” tells you exactly what it is doing.
Descriptive names reduce the time to identify and triage sessions, which reduces the overhead of switching between them.
Strategy 3: Make Interactions Asynchronous and Batched
#
Synchronous interaction with agents is the enemy of parallelism.
If you must respond to each agent within seconds, you can only effectively manage one at a time.
Let agents run to a natural stopping point.
Instead of watching each agent in real-time and responding to each question as it arises, configure agents to work until they hit a genuine blocker.
At that point, they checkpoint their state and wait.
You then process the batch of blocked agents at your convenience.
Batch your decisions.
When multiple sessions need human input, collect all the requests and process them in a single sitting.
This is more efficient than context-switching for each one individually, because you stay in the same cognitive “mode” for the entire batch.
Five decisions made in one focused session will be faster and higher quality than the same five decisions made across five interruptions.
Time-box your session reviews.
Instead of monitoring sessions continuously, check them at fixed intervals: every 30 minutes, every hour, twice a day.
This creates predictable rhythm and eliminates the reactive, interrupt-driven pattern that fragments attention.
Between check-ins, agents work autonomously and you focus on other things.
Coalesce interruptions.
If you have three sessions that will each need input within the next 15 minutes, do not handle them one at a time.
Wait until all three are ready, then handle them together.
Interruption coalescing is a well-known technique in operating systems and it applies equally to human attention management.
Strategy 4: Make Agents Resolve Their Own Ambiguities
#
Every question an agent asks you is a context switch.
The fewer questions it asks, the more sessions you can manage.
Provide rich default resolution rules.
Instead of letting agents escalate every ambiguity, give them standing instructions for common situations.
“If the test suite fails, attempt to fix it before escalating.”
“If a dependency is missing, install it from the lockfile.”
“If a naming convention is unclear, follow the pattern used in the nearest file.”
These defaults eliminate a large fraction of questions that would otherwise interrupt you.
Define escalation thresholds explicitly.
Agents should escalate to you only when they cross a defined threshold: they have tried multiple approaches and failed, they need access they do not have, or they are about to make an irreversible decision.
Everything else should be handled autonomously.
The clearer the threshold, the fewer unnecessary escalations.
Allow agents to ask other agents.
If you have multiple sessions running, agents can sometimes resolve each other’s questions.
An agent that needs to understand how another part of the system works can query the agent working on that part.
This peer-to-peer resolution keeps you out of the loop for routine coordination.
Use confidence-based escalation.
Agents that can express confidence in their outputs can be configured to escalate only when confidence drops below a threshold.
High-confidence work proceeds without interruption.
Low-confidence work pauses for review.
This naturally filters your attention toward the sessions that need it most.
Strategy 5: Use Hierarchical Orchestration
#
The most effective way to manage many agents is to not manage them all directly.
Introduce orchestrator agents.
Instead of you supervising 20 worker agents, have 4 orchestrator agents each supervise 5 workers.
You interact only with the orchestrators, who aggregate and summarize their workers’ status.
This reduces your direct interaction count by a factor of 5 and lets you operate within your working memory limit.
This mirrors the pattern described in Scaling the LLM Agent Company, where the orchestration layer replaces the human management layer.
Fan-out and fan-in.
Give an orchestrator a single high-level task.
It decomposes the task, assigns subtasks to workers, collects results, and presents you with a synthesized output.
You never interact with the individual workers.
Your cognitive load is the same whether the orchestrator manages 3 workers or 30.
Assign team leads per domain.
If your agents work across multiple domains (frontend, backend, infrastructure, testing), assign one orchestrator per domain.
Each domain lead reports to you with a one-paragraph summary.
You manage four domain leads instead of twenty individual contributors.
Layer the hierarchy as needed.
For very large numbers of agents, add another layer.
A chief orchestrator manages domain orchestrators, who manage team leads, who manage workers.
Each layer compresses information, so you always deal with a manageable number of direct reports.
Strategy 6: Practice Progressive Disclosure
#
You should never need to understand everything about every session to make a decision.
Information should arrive in layers, from summary to detail, on demand.
Lead with the one-line summary.
Every session status should begin with a single sentence that tells you whether action is needed: “Session blocked, needs your decision on X” or “Session running normally, 60% complete.”
If the summary says no action needed, you move on.
You never read the details unless the summary demands it.
Provide drill-down on request.
Behind the one-line summary is a paragraph.
Behind the paragraph is the full session log.
Behind the log are the raw outputs.
Each layer is available but not shown by default.
This keeps your default view clean and your cognitive load low.
Use severity indicators.
Color-code or tag sessions by urgency: red for “needs immediate human input,” yellow for “proceeding but with a risk you should know about,” green for “all clear.”
Your eye scans for red first, yellow second, and ignores green.
This triage happens in seconds, not minutes.
Summarize at the right granularity.
An orchestrator reporting “all five workers are making progress” is useless if one of them is about to make a critical mistake.
An orchestrator reporting every token from every worker is noise.
The right granularity is: what is done, what is in progress, what is blocked, and what decision you need to make next.
Strategy 7: Isolate Sessions from Each Other
#
Interference between sessions is a major source of cognitive load.
When sessions share state, a change in one can invalidate your understanding of another.
Enforce session independence.
Each session should operate in its own workspace, with its own file tree, its own dependencies, and its own state.
Sessions should not mutate shared resources that other sessions depend on.
This prevents the “I changed something in session A that broke session B” problem, which is one of the most expensive debugging scenarios when managing many sessions.
Use separate branches or worktrees.
If sessions work on the same repository, each should use its own 
git worktree or branch.
This ensures that the output of one session does not corrupt the working state of another.
When you are ready to integrate, you merge branches deliberately, not accidentally.
Scope tools and permissions per session.
Each session should have access only to the tools and resources it needs.
A session fixing a frontend bug does not need database write access.
This reduces the blast radius of errors and eliminates cross-session interference.
Make session boundaries explicit.
When you switch from session A to session B, the boundary should be clear.
Close session A’s workspace, open session B’s.
The physical or virtual separation reinforces the cognitive separation.
Strategy 8: Build a Session Dashboard
#
When managing more than three or four sessions, you need a single view that shows all of them at once.
Switching between terminal tabs or IDE windows to check on each session is itself a form of context switching.
Create a single pane of glass.
A dashboard that lists all active sessions with their status, progress, and severity indicators lets you assess the entire fleet in one glance.
This dashboard can be as simple as a generated text file or as sophisticated as a web UI.
The key is that it presents all sessions in a uniform, scannable format.
Surface only actionable information.
The dashboard should show you what needs your attention, not everything that is happening.
Sessions running normally should be collapsed or summarized.
Sessions that need input should be highlighted.
The dashboard is a triage tool, not a log viewer.
Automate status collection.
The dashboard should be generated automatically from the state files that each session produces.
No manual updates.
If a session’s state file changes, the dashboard reflects it.
This eliminates the overhead of manually polling each session for status.
Add alerting for critical events.
Instead of watching the dashboard continuously, configure alerts for events that genuinely require immediate attention: a session failed, a session is about to make an irreversible change, a session has been blocked for more than N minutes.
Everything else can wait for your next scheduled review.
Strategy 9: Use AI to Triage AI
#
One of the most effective ways to manage many agent sessions is to use an LLM to help you manage them.
AI-assisted summarization.
Before you look at a blocked session, have an LLM read the session log and produce a one-paragraph summary of what happened, what the blocker is, and what decision you need to make.
This saves you from reading potentially hundreds of lines of conversation history.
The summary gets you to the decision point faster.
AI-assisted triage.
When you return from a break and find 12 sessions waiting for input, have an LLM rank them by urgency and group similar requests.
“Sessions 3, 7, and 12 all need the same decision about database schema, you can answer them together.”
“Session 9 is urgent, it is blocked on a production deploy.”
This pre-processing reduces your cognitive load and helps you batch effectively.
AI-assisted decision drafting.
For each blocked session, have an LLM propose a decision with rationale.
You review the proposal, accept it or modify it, and move on.
Reviewing a well-formed proposal is faster and less cognitively demanding than constructing a response from scratch, especially for the tenth session of the day.
AI-assisted state reconstruction.
When you return to a session after days away, have an LLM produce a “previously on” summary that reconstructs the relevant context.
This is faster and more reliable than reading the full log yourself, and it handles the long-gap resumption problem that pure state files struggle with.
Strategy 10: Manage Your Own Cognitive Resources
#
The human supervisor is a finite resource.
Strategies that optimize agent throughput while ignoring human cognitive limits will fail.
Chunk sessions into clusters.
Instead of treating 20 sessions as 20 independent items, group them into 4 clusters of 5.
Each cluster shares a domain, a goal, or an orchestrator.
You manage 4 clusters, not 20 sessions.
This leverages chunking, the same memory technique that lets experts recall complex board positions in chess.
Dedicate focus blocks.
Reserve uninterrupted blocks of time for session supervision.
During a focus block, you process the queue of blocked sessions, make decisions, and unblock agents.
Outside of focus blocks, you do other work.
This prevents the constant low-level attention drain that comes from monitoring sessions while trying to do other things.
Reserve decision budget for high-stakes sessions.
Not all decisions are equal.
A decision about whether to deploy to production matters more than a decision about variable naming.
Allocate your decision budget accordingly.
Make the important decisions when you are fresh.
Batch the trivial decisions and make them in a low-energy slot.
Take recovery breaks.
Context switching and decision-making are cognitively expensive.
After a heavy session of supervising multiple agents, take a deliberate break to let attention residue dissipate.
This is not laziness, it is maintenance of the tool that matters most: your judgment.
Strategy 11: Reduce Session Count Through Better Task Definition
#
The easiest session to manage is the one you never needed to start.
Write precise specifications.
A well-specified task runs autonomously and produces fewer questions.
A vaguely specified task generates constant clarifying questions, each of which is a context switch.
Investing in specification quality before launching a session benefits the session for its entire lifetime.
This is the same principle described in The Importance of Context When Interacting with LLMs: the quality of the context determines the quality of the output.
Merge related tasks.
If two tasks touch the same code or the same domain, combine them into one session instead of running two.
One session managing a coherent area is easier to track than two sessions with overlapping scope.
Eliminate unnecessary sessions.
Before launching a new session, ask whether the task is worth the supervision overhead.
Some tasks are faster to do yourself than to delegate to an agent and then supervise.
The shifting bottleneck principle applies: as agent supervision becomes the bottleneck, the optimal strategy shifts from spawning more agents to being more selective about which tasks to delegate.
Pre-compute common answers.
If you find yourself answering the same type of question across multiple sessions, encode the answer once in a shared resource that all sessions can access.
A shared FAQ, a coding standards document, or a decision tree eliminates a category of future questions.
Strategy 12: Version and Review Session Patterns
#
Managing many sessions is a skill that improves with deliberate practice.
Record what worked.
When a session runs smoothly from start to finish, note what made it smooth.
Was the specification clear?
Were the escalation thresholds well-calibrated?
Did the status format make triage easy?
These observations compound into better patterns over time.
Post-mortem failed sessions.
When a session drifts from its instructions, review why.
Did the agent lack critical context?
Did the escalation threshold let it run too long without checking in?
Did the state file fail to capture the information you needed to intervene effectively?
Each failure is a data point for improving the protocol.
Iterate on the protocol.
The session protocol, the status format, the escalation rules, and the dashboard design should all evolve as you learn what works.
Treat your agent management system as a product that you are continuously improving.
The goal is not to find the perfect system on day one but to get a little better every week.
Share patterns across teams.
If multiple people in your organization supervise agent sessions, share what works.
The patterns that reduce cognitive load for one person will likely help others.
This is the same knowledge-sharing principle that makes software engineering teams effective: institutional knowledge compounds when it is explicit and shared.
The Ceiling: How Many Can You Actually Manage?
#
There is no single number, but the constraints are real.
With no system, no tooling, and synchronous interaction, a human can effectively manage 1 to 2 concurrent agent sessions.
The cognitive overhead of tracking each session’s state in working memory and responding to questions in real time is too high to scale further.
With externalized state files, standardized protocols, and asynchronous batching, 4 to 6 concurrent sessions become feasible.
You are no longer holding state in your head, and you batch your interactions to reduce switch cost.
With hierarchical orchestration, progressive disclosure, and a dashboard, 10 to 15 concurrent sessions are manageable.
The orchestrators compress information, the dashboard provides a single view, and you interact with a manageable number of direct reports.
With AI-assisted triage, tight escalation thresholds, and well-specified tasks, 20+ concurrent sessions are achievable for a human who has invested in the workflow.
At this scale, you are no longer managing individual sessions.
You are managing a system that manages sessions.
The progression mirrors the task-stack philosophy: you push interruptions onto a stack, handle them in batches, and pop them off when done.
The difference is that the stack now contains not just your own tasks but the states of dozens of autonomous workers, and the stack is externalized rather than in your head.
The Meta-Principle
#
Every strategy in this article reduces to one of four operations on the cognitive constraints:
Reduce working memory load by externalizing state, standardizing formats, and chunking sessions into clusters.
Reduce switch cost by standardizing protocols, batching interactions, and isolating sessions.
Reduce attention residue by letting sessions reach natural stopping points, taking recovery breaks, and using focus blocks.
Reduce decision fatigue by having agents resolve their own ambiguities, using decision templates, and reserving decision budget for high-stakes choices.
The agents are not the bottleneck.
Your brain is.
Every hour you spend engineering the workflow around your own cognitive limits is worth ten hours of trying to power through them.
References
#
Scheduled issue-to-PR automation in OpenChamber
Jeff Bezos drew in his 2016 letter to shareholders