ings
Running several AI agents at once sounds like an easy productivity gain—until they all need your attention.
One is waiting for clarification. Another has stopped after an error. A third says the job is finished, but the output is missing something important. Moving between them can consume the time they were supposed to save.
The problem becomes more visible as agent workloads grow. In an October 14, 2026 customer story, OpenAI reported that Third Moment Research runs 10,000 agents concurrently on research sessions lasting 36 to 48 hours. Those figures describe a purpose-built research system, rather than thousands of chat windows managed by one person. Still, some of its operating practices translate to much smaller workloads.
For someone managing a handful of agents, three changes are particularly useful: make interruptions less frequent, make reviews faster, and give each agent a clearly bounded job.
1. Decide what happens when an agent gets stuck
Most task instructions explain what to produce. Fewer explain what to do when progress stalls.
That omission matters. An agent researching competitors might encounter an unavailable pricing page. An agent running tests might wait for a job that takes half an hour. Without further guidance, it may stop for help or repeat the same unsuccessful action.
Before starting, define which problems the agent can resolve independently. For a research assignment, that could mean checking another official source, marking information as unavailable, or continuing with the remaining companies. A decision that changes the scope of the assignment should come back to you.
Give repeated failures a stopping point, too. After two unsuccessful attempts using the same approach, for example, require the agent to inspect the error and explain what it would change before trying again. The appropriate limit depends on the task; the purpose is to prevent retries that produce no new information.
Long-running jobs need a separate rule. Where completion notifications are available, use them. Otherwise, choose a checking interval that reflects the expected runtime. A thirty-minute process rarely benefits from being checked every few seconds.
Third Moment encountered this problem when agents repeatedly checked unfinished backtests. According to OpenAI’s account, optimizing the underlying computation reduced one backtest from roughly three hours to three to five minutes, cutting unnecessary status checks and context clutter. That was an engineering improvement, not simply a better instruction to wait.
For everyday work, a small progress record is often enough to make recovery easier. Ask the agent to save what it has completed, where the output lives, what is blocking it, and what it intends to do next. A replacement session can then resume from the saved work.
Silence alone is not evidence of failure. Check the job’s expected duration and actual state before restarting it.
2. Put one agent in charge of the first review
Reviewing several outputs can take longer than assigning the work.
A coordinating agent can reduce that burden, provided it can actually access the other agents’ results. It needs shared files or tools for reading their status; naming a chat “project manager” does not create that access.
Its most useful responsibility is the first review.
For a competitor report, it should check whether every company has been covered, whether prices use comparable billing periods, and whether the sources support the claims. For a coding task, it should inspect the changes and relevant test results.
Ask each working agent to hand over the same basic information: the result, its location, the checks performed, and anything unresolved. This gives the coordinator something concrete to evaluate.
The coordinator should return incomplete work with a specific correction. “The comparison mixes monthly and annual prices” is actionable. “Improve the quality” is likely to generate another round of vague revisions.
Human attention can then go to the remaining decisions: missing evidence that affects a recommendation, conflicting requirements, or a change in scope.
Keep an eye on the coordinator’s judgment as well. An AI reviewer can overlook errors or accept another agent’s unsupported claims. Its conclusions should point to files, sources or test results that you can inspect.
3. Split the work before adding more agents
Parallel work helps when the tasks can genuinely proceed separately.
Anthropic’s experiment with 16 agents building a C compiler exposed the opposite situation. When they reached Linux kernel compilation, agents encountered the same bug and overwrote one another’s fixes. The researchers changed the testing setup so agents could work on different problems in different files.
A smaller project can run into the same difficulty. Two agents editing one report may duplicate sections. Several coding agents may change a shared component in incompatible ways.
Assign ownership before work begins. In a research project, one agent might collect pricing, another examine features, and a third document limitations. Give them the same product list and comparison criteria. Leave the final recommendation to a designated editor once the evidence is ready.
For code, separate branches or working directories can help contain changes, but someone still needs to integrate them and check that the combined result works.
Start with two workers and one coordinator. After a real assignment, look at how often you intervened, how long reviews took, how much rework was needed, and what the job cost.
Add another agent when there is a separate task ready for it—and when the existing team is already delivering work you can reliably use.
