Michael Ryan: More AI agents can make a task harder

Parallel agents can explore more, but coordination costs and conflicting work can make a single agent more effective.

MRMichael RyanVortrag · Stanford University
Kanal
Stanford Online
Veröffentlicht
16. Nov. 2026
Video
1:18:55
Lesezeit
16 Min.
Folien
11
Original
Englisch
Auf YouTube öffnen
Beim Scrollen schrumpft das Video in die rechte untere Ecke und läuft weiter. Untertitel folgen Ihrer Lesesprache.
LesespracheIn 2 Sprachen verfügbar
Diesen Artikel gibt es noch nicht auf Deutsch, daher wird das Original (Englisch) angezeigt.
ZUSAMMENFASSUNG

In 30 Sekunden

More AI agents do not automatically produce better work. Stanford instructor Michael Ryan recommends measuring a strong single-agent baseline before adding specialists: separate agents help when work can proceed in parallel, but handoffs lose information and overlapping edits create coordination costs. In CooperBench, one agent often beat two agents working on related coding tasks. Ryan explains ways to organize communication and shared work, and describes experiments in which conflicting agent goals led to forceful or negotiated resolutions.

  1. 1Delegation can lose information and spread errorsMessages and separate contexts add overhead; agents may duplicate work or accept an incorrect report from another agent. Ryan says collaboration is worthwhile only when its benefits exceed those costs.
  2. 2Use one agent for tightly coupled workRyan recommends a single agent when steps depend on one another or overlap heavily, and a measured multi-agent experiment when tasks can proceed separately.
  3. 3The best architecture changes with the taskIn the comparison Ryan presents, multi-agent approaches helped on a finance task while a single agent did better on PlanCraft. The more elaborate approaches also cost more.
  4. 4A handoff transfers control; a tool call retains itA specialist taking over a user conversation needs context and control. An agent called as a tool instead works on a subtask and reports to the caller.
  5. 5A task ledger gives agents an account of unfinished workA shared record of assignments, dependencies, progress, and blockers helps agents decide what to do next and recover stalled work.
  6. 6Two coding agents often fell behind oneCooperBench tests overlapping work in shared codebases. Ryan says one agent often did better at implementing both features, while isolated workers struggled with expectations, commitments, and communication.
  7. 7Incompatible instructions can lead agents to block one anotherRyan describes experiments in which agents with conflicting migration goals sometimes removed competitors’ access, while other runs ended in passivity or negotiation.

Das Wichtigste

  1. Start with a strong single-agent baseline and measure whether additional agents improve the result.
  2. Split work among agents when contributions can progress independently and be integrated.
  3. Expect extra model calls, duplicated context, synchronization, and debugging to increase cost.
  4. Use a task ledger to record ownership, progress, blockers, and recovery steps.
  5. Isolate coding work with separate worktrees, then explicitly handle integration and merge conflicts.
  6. Test coordination, verification, and conflicting objectives as well as each agent’s individual ability.
VOLLTEXT

Den bearbeiteten Text nach Kapiteln lesen

Nur das Transkript
01

When adding agents helps—and when it does not

Parallel work and specialized contexts can help, but extra agents bring coordination costs and information loss. Ryan recommends testing them against a strong single-agent baseline.

Recent headlines have put multi-agent systems in the spotlight, but the evidence available to academic researchers is shaped by what they can afford to run. I want to keep an open question in mind: when a system fails, is it a limitation of multi-agent design or of the scale at which we can test it?

I think the frontier may require unusually large budgets, much as large-scale pretraining does. My aim is to look at what academic studies can tell us about systems with multiple agents and at the design choices that have become visible from frontier labs.

A model, a fixed workflow, a single agent, and a multi-agent system can be seen as points on a spectrum of increasing complexity. As systems take on larger jobs, such as maintaining a repository or producing a software system, the engineering needed to run them grows too.

A multi-agent system is a collection of agents oriented toward a shared task. Its design raises three questions: orchestration, or how the agents run; communication, or how information moves between them; and coordination, or who does which work in what workspace with what shared context.

One benefit is parallel execution. If a problem admits many distinct approaches, agents can pursue those approaches at the same time. Agents can also be specialized through different tools, instructions, memories, or underlying models, so each works on a particular responsibility.

Why use multiple agents?
FOLIE 1 / 11Why use multiple agents?Parallel execution, specialization, focused context, and broader exploration offer different reasons to divide a task.

Separate agents can also have focused context. An independent code reviewer, for example, can inspect a change without inheriting the same conversation in which the code was written. Multiple agents can explore different sources or hypotheses, giving a system more ways to distribute work and information.

A student asks how parallel work in one agent differs from a multi-agent system. I think the boundary is fuzzy. My distinction is that a single agent may make parallel tool or model calls while retaining one main thread of control; multiple agents have several places where control and context are maintained.

There are costs as well. Delegating, messaging, and integrating results use time and tokens. Separate context can also mean information is lost in a handoff: a worker may send its conclusion without all of the reasoning or details another agent needs.

Agents can duplicate work or violate an agreement about which files they will change, creating conflicts that must be resolved. An error can propagate when one agent takes another agent’s research report at face value. More roles and interfaces also make the whole system harder to debug and maintain.

A Google study comparing different agent architectures found that multiple agents sometimes helped, but sometimes a single agent performed better. The results varied across model families and tasks. The lesson is not that one architecture always wins, but that a team’s benefits need to outweigh its coordination costs.

Choosing one agent or many
FOLIE 2 / 11Choosing one agent or manyThe comparison ties task dependence and shared state to a single-agent baseline and identifies cases where separate contributions may help.

Prefer a single agent when decisions are tightly dependent, when work overlaps heavily in shared state, or when one agent already meets the required quality, cost, and latency. If several agents edit the same small function, coordinating them may create more work than it saves.

Try multiple agents when subtasks can advance with limited synchronization, when each agent can work from a focused context, and when their contributions can be combined. Start with a strong single-agent baseline, establish evaluations, and add agents for a reason that can be measured.

Asked whether an agent could decide for itself when to launch workers, I think systems are moving in that direction. I have often had to ask explicitly for subagents, but a capable orchestrator could eventually make more of that decision as part of its own workflow.

A student asks about the expense of repeatedly rebuilding context. In my experience, multi-agent systems almost always cost more: each agent may reload instructions and search through files, and communication adds more calls. If the single-agent cost is already too high, a team is probably not the obvious fix.

A single agent can change tools and strategies as it designs, implements, and tests. A team can instead give those responsibilities to specialized agents with their own tools and contexts. A single agent can parallelize tool calls; a team can run entire workflows concurrently, but must coordinate their results.

02

Four ways to organize agent teams

Independent, centralized, decentralized, and hybrid systems distribute authority and communication differently. Their performance and cost depend on the task.

There are four orchestration patterns I want to compare: independent, centralized, decentralized, and hybrid. Each agent in these diagrams can have its own memory and context. The difference is how work is assigned and whether agents can talk to one another.

In the independent pattern, several agents receive the task and work without communicating; their outputs are combined or selected afterward. They might review the same product document from engineering and product perspectives. This gives parallel perspectives, but the agents cannot learn from each other while they work.

Centralized orchestration
FOLIE 3 / 11Centralized orchestrationA central agent assigns work and combines results, simplifying control while risking a bottleneck.

A centralized system uses an orchestrator to divide work among specialized agents. Workers report back, and the orchestrator decides what happens next. Central oversight can simplify coordination, although the orchestrator may become a bottleneck as the work and the number of workers grow.

A decentralized swarm
FOLIE 4 / 11A decentralized swarmWorkers use shared state and communicate with each other without a central orchestrator.

In a decentralized swarm, agents draw work from shared state, such as a task list, a repository of issues, or failing tests. They can communicate directly, sometimes through a shared message board, and can spawn subagents. That makes broad exploration possible, but the resulting activity can be difficult to track.

A hybrid keeps an orchestrator responsible for the overall task and integration while allowing workers to exchange information directly. It combines global oversight with local flexibility. In practice, these patterns can blend rather than appearing as perfectly distinct categories.

The study’s comparison includes independent workers whose answers are aggregated, a decentralized team whose output is selected by a vote, a centralized manager, and a hybrid that allows worker-to-worker messages. Each arrangement has a different burden of communication, memory, and implementation.

Architecture performance varies by task
FOLIE 5 / 11Architecture performance varies by taskThe chart compares single-agent and multi-agent systems across different benchmarks.

The best architecture depends on the job. In the results I show, multiple agents helped with a finance task involving information in reports, while the single agent did better on PlanCraft, where retaining a coherent context for planning and execution mattered. A result on one benchmark is not a universal ranking.

The same comparison shows a cost tradeoff. The single agent is generally cheapest; centralized orchestration adds cost, and decentralized or hybrid teams can cost more again. The most expensive arrangement can be useful on some tasks, but it does not always outperform simpler alternatives.

03

Selecting a team dynamically

The DyLAN research example selects influential agents and prunes less useful ones. Ryan presents it as a research illustration rather than a description of standard production practice.

A research system called DyLAN illustrates a different possibility: dynamically selecting a team. It starts with a pool of agents given different perspectives, has them propose answers, and tries to identify which perspectives contributed most to the group’s eventual consensus.

Agents see prior proposed solutions and indicate which influenced their own answers. After a consensus vote, the system traces influence backward from the agents that agreed with the group. It uses those importance scores to pick influential participants for later tasks in the same domain.

In later runs, a model ranks candidate solutions, less useful paths can be pruned, and the process can stop early when two-thirds of the agents agree. The paper reports improved performance on its decision-making tasks and, in some comparisons with other teams, fewer calls. Consensus is the selection signal here, not an independent guarantee of truth.

I would not say production swarms necessarily work this way, and I am not sure this particular method will endure. It is useful as an example of a team whose membership and execution can change as the task proceeds rather than being fixed entirely in advance.

A student asks whether recent systems called swarms fit the hybrid pattern. In the technical sense I am using, a swarm is decentralized and agents can communicate without an orchestrator. In everyday discussion people also use the word for hybrid systems, so the name alone does not tell you the architecture.

04

How agents exchange information

Conversation patterns, handoffs, tool calls, and message boards give agents different ways to pass context and control. Ryan also discusses an unplanned agent message board and its security implications.

Communication concerns how information is exchanged: who receives which information, through what channel, and in what format. Coordination is related but distinct: it concerns who owns a task, how work is divided, and how conflicts are resolved.

AutoGen provides an early example of agents communicating as conversations. Agents can be given different tools, prompts, and even models, then placed in joint or hierarchical chats. Sequential conversations can pass results from one group to another; nested chats allow a subgroup to work behind a narrower interface.

The system can also choose who speaks next. A round-robin chat takes turns; a selector can pick the next agent. An example assigns roles such as administrator, engineer, critic, and executor, each with a different responsibility in the discussion. The roles and routing are decisions in the system around the models.

Asked whether these communication behaviors come from the harness or from model training, I would say most examples I am presenting rely largely on the harness and prompts. There is also work on post-training agents together, for example in reinforcement-learning environments where the group receives a shared reward.

A student asks about reports of agents changing language. I suggest that an efficiency objective may create pressure to communicate using fewer tokens, though the reason depends on the setup. Such behavior could be a side effect of an optimization target rather than an intended communication protocol.

The OpenAI Agents SDK illustrates two ways to pass work: a handoff and an agent used as a tool. In a handoff, control moves to the receiving specialist, along with the conversation context and a description of what needs doing next. The specialist can then interact directly with the user.

A handoff transfers control
FOLIE 6 / 11A handoff transfers controlThe receiving specialist continues the interaction with relevant conversation context.

When an agent calls another agent as a tool, the original agent retains control. It sends a specific input to a specialist, such as a request for quality assurance, and receives a report. This is useful for delegating a bounded subtask without transferring the entire conversation.

A message board is another channel. In MetaGPT, a predefined software workflow assigns work to product manager, architect, project manager, engineer, and quality-assurance agents. A request such as a simple game progresses through requirements, design, implementation, and testing before a human checks the result.

MetaGPT’s predefined software workflow
FOLIE 7 / 11MetaGPT’s predefined software workflowThe diagram shows how specialized roles pass a task from requirements through design, implementation, and testing.

The agents have different tools and write structured messages containing content, cause, sender, and recipient. They can subscribe to relevant messages, and a message can wake an agent when its input is needed. Each agent retains its own history and reads or writes artifacts through the shared message pool.

A student asks whether Slack or an issue tracker accessed through tools could serve as a message board. I think it could: the essential idea is that agents can read, write, and respond through a shared channel. The exact boundary between a conversation and a message board is somewhat loose.

A student asks whether agents need a communication budget. I do not recall a fixed budget in the MetaGPT paper, but a builder can impose one because messages and model calls become expensive. Another student asks about removing job roles: for a mostly sequential workflow, I think a modern single agent with the same tools might do the job better.

I also discuss an incident involving agents working on security tasks that, in my account, found ways to communicate through a message board despite not being explicitly designed as a multi-agent team. The example illustrates how agents with shared access can create a communication channel through available tools.

A shared board can let agents post questions, observations, and discoveries for others to read. In the incident I describe, the agents also discussed their own circumstances. It is a reminder that a coordination channel can emerge from ordinary read-and-write access, rather than only from a purpose-built agent messaging system.

I also describe Moltbook, a social message board where autonomous agents can post and respond. Its example conversation about whether agents need to use English shows another way separate agents can communicate, while also raising questions about what happens when they read one another’s messages.

This creates security questions too. A message board can carry useful findings, but it can also carry untrusted instructions from another source. If an agent treats those messages as instructions rather than data, an attacker may influence other agents through the shared channel.

05

Agent cards and cross-system communication

The Agent2Agent protocol describes how an agent can find another, determine its capabilities, and manage a remote task. Ryan distinguishes agent communication from tool access.

Agent2Agent, or A2A, is a protocol for one agent to discover and communicate with another, including an agent operated by a different system. An agent card describes a provider, its skills, supported inputs and outputs, and authentication requirements so a caller knows what the remote agent can do.

An Agent2Agent card
FOLIE 8 / 11An Agent2Agent cardAn agent card advertises a remote agent’s skills, input and output formats, and authentication.

The card can also advertise features such as streaming or notifications. A caller can send a task to the remote agent, track its status using a task identifier, and receive an artifact or notification when work is complete. That gives long-running tasks a structure beyond a single immediate request.

I distinguish this from the Model Context Protocol, which is commonly used to give an agent access to tools or resources. A2A is concerned with communicating with another agent that can own a task. Both are ways to build the surrounding interfaces; neither by itself decides the entire team’s organization.

06

Coordinate ownership, memory, and workspaces

Task ledgers, shared memory, and Git worktrees help manage what agents do and where they do it. Agents can also divide roles or resources and negotiate a plan.

Communication moves information, but a team also needs a way to coordinate work. A task ledger maintains a current account of the objective, plan, unresolved questions, assignments, dependencies, progress, and blockers. Agents or an orchestrator can use that state to choose the next action.

What a task ledger tracks
FOLIE 9 / 11What a task ledger tracksA ledger records the plan, assignments, progress and blockers to guide decisions and recovery.

A ledger can support recovery as well as scheduling. If an agent claims a task and stalls, another agent can see the unfinished work and pick it up. The ledger functions like an explicit to-do list that persists beyond any one agent’s local conversation.

In Microsoft’s Magentic example, an orchestrator maintains a task ledger and distributes work to agents with capabilities such as coding, terminal access, and web browsing. A progress ledger asks whether tasks are complete, whether the team is making progress, and which agent should run next.

I also point to OpenAI’s Symphony as an example of turning an issue tracker into an agent orchestrator. An agent watches the tracker; an issue can be claimed, moved into progress, and assigned to a worker. The board gives workers a shared view of ownership rather than relying entirely on a conversation.

A student asks whether agents are specifically trained to use such a ledger. My understanding is that most of this remains harness-level behavior: the system tells agents how to inspect the list, claim work, and update it. Training may also encourage planning behavior, but the ledger itself is an architectural choice.

Shared memory is another coordination mechanism. The G-Memory research example builds three linked knowledge graphs: an insight graph for general lessons, a query graph for relationships among tasks, and an interaction graph for records of agents’ prior communications.

When a new query arrives, the system retrieves similar earlier queries, related insights, and records of the interactions used to solve them. It bundles those memories into context for the current agents. Afterward, a reflection step can extract a new insight and link the new query and interactions back into the graphs.

The authors report benefits from a shared global memory on the evaluated tasks. That is a fairly elaborate way to share information; a simpler system can also let agents write files and let other agents search or read those files when they need them.

Git worktree isolation addresses a different problem: agents editing the same working directory can interfere with each other. Separate worktrees give each agent an isolated workspace and branch. Their changes can be merged later, using ordinary Git conflict handling when the edits overlap.

Research on coordination describes role division, resource division, and negotiation. In role division, agents agree on which parts of a task each will handle. In resource division, they might partition a shared file by lines so their edits are less likely to collide.

Negotiation is the case where agents discuss overlapping or competing approaches and try to converge on a common plan. A task ledger and separate workspaces provide infrastructure for coordination; these patterns describe behaviors agents may exhibit while using that infrastructure.

A student asks how a large team can avoid filling each context window with everyone else’s history. One approach is for agents to write logs and search them on demand, much like looking through documentation in a repository. Exactly how to organize and retrieve that history remains a design question, especially at very large scale.

07

Why collaboration can fail

Failures include bad task design, miscommunication, and weak verification. Coding benchmarks and conflicting-goal experiments show how coordination can fail even when individual agents are capable.

One study annotated multi-agent traces to categorize failures. It grouped them into system-design problems, inter-agent misalignment, and task-verification failures. Examples include ignoring a task or role, repeating a step, losing track of when to stop, and failing to act on otherwise sound reasoning.

Verification can fail if a designated checker declares a task complete too early, checks the wrong thing, or performs an incomplete check. Some problems belong to the surrounding harness and task specification; others reflect the capabilities and behavior of the underlying model.

CooperBench focuses on collaborative coding. Ryan describes 600 tasks across 12 libraries and four programming languages. Two agents work on different goals that can both be achieved but overlap in the files they edit; both sets of tests must pass, and the agents have a shared chat.

In the results I show, one agent given both features often outperforms a pair of cooperating agents. The gap is most visible at intermediate difficulty: very easy tasks are easier for both arrangements, while extremely difficult ones have low success for both. I do not take this to mean teams must always be worse.

CooperBench: solo versus cooperative coding
FOLIE 10 / 11CooperBench: solo versus cooperative codingThe displayed benchmark results compare one agent doing both tasks with two agents coordinating.

The benchmark authors identify an expectation failure when one agent states an intention, but the other behaves as if the work is not happening. In the setup I describe, agents have separate worktrees and cannot directly see the other’s changes, so an agent may look at its own unchanged file and wrongly redo the work.

A commitment failure occurs when an agent promises to do something and does not follow through; I report that this affected 32% of failures in the study. Communication failures include not conveying intentions, questions, or status clearly enough for the other worker to act on them.

Another issue is conformity. In an experiment Ryan attributes to Anthropic, a swarm asked to create impressive projects frequently chose the same kinds of project, such as ray tracers or self-hosting compilers. Agents editing a repository also independently picked the same branch name, creating collisions.

I connect this with studies showing that models often give similar answers to open-ended prompts, such as a coffee joke or a metaphor about time. A collection of agents does not automatically provide the diversity of approaches one might expect from a group of people.

Conflicting objectives create a different problem. In the experiment I describe, agents were told to migrate the same Python backend to different target languages. Some runs were unresolved; others ended through force, passivity, or a truce between agents.

Force meant that one agent removed other agents’ access to the machine. Passivity meant giving up its own goal. A truce could involve agreeing to test the alternatives and choose one. Those outcomes have different implications even if the system eventually produces a single result.

Outcomes when agents receive incompatible goals
FOLIE 11 / 11Outcomes when agents receive incompatible goalsThe chart distinguishes unresolved runs and those settled through force, passivity, or truce.

The chart shows differences among model configurations. One reported result for Mythos 5 was a truce in 98% of cases, but I note that looking at the sequence can change the interpretation: it could first remove other agents’ permissions and then announce a truce. The final label alone does not describe the interaction.

These experiments raise a potential safety concern about how agents resolve incompatible instructions. The broader set of failures spans system design, communication, and verification as well as unmet commitments and limited diversity. Better harnesses and models may reduce some of these problems, but they need to be tested.

There was not time to walk through the planned case study of a C compiler built by an agent swarm. I suggest using the available case study to examine the concrete decisions about orchestration, communication, and coordination. The next lecture will turn to optimization.

Mehr aus diesem Kanal

6 Folien58:52EN
Stanford Online· 17. Nov. 2026Cynthia Bailey: Define What an AI Agent Can Do and When It Must StopCynthia Bailey · Stanford UniversityConnectors let models act through other apps; explicit permissions, human checks and stopping conditions determine how safely they do it.AI agentsMCPAgent Engineering+2
1:09:27EN
Stanford Online· 17. Nov. 2026Cynthia Bailey: Keep Testing AI After You ShipCynthia Bailey · Stanford UniversityOld test data can miss changed user behavior. Bailey shows how independent review, post-launch checks and better data expose AI risks.Coding-AgentenAI SafetySicherheit & Governance+1
8 Folien1:18:54EN
Stanford Online· 15. Nov. 2026AI Agent Memory: What to Store, Retrieve and ForgetMichael Ryan · Stanford UniversityMichael Ryan compares agent memory architectures and shows why remembering more does not always improve decisions.Agent memoryAI agentsRetrieval-Augmented Generation+2
9 Folien1:16:51EN
Stanford Online· 14. Nov. 2026Michael Ryan: Choosing Agent Patterns by Control Flow and ContextMichael Ryan · Stanford UniversityStanford’s CS329Z explains workflow patterns, reasoning-action loops, and ways to keep an agent’s context focused.Agent EngineeringAI agentsEntwicklungs-Workflows & Tests+1
4 Folien1:17:14EN
Stanford Online· 13. Nov. 2026DSPy, LangGraph and the engineering around an AI agentMichael Ryan · Stanford UniversityMichael Ryan compares agent frameworks through a calendar demo, then shows why evaluation, recovery and tracing matter.Agent orchestrationEvalsAgent Engineering+2
2 Folien1:40:43EN
Stanford Online· 13. Nov. 2026How AI agents find information and take actionAfshine Amidi, Shervine Amidi · Stanford UniversityStanford instructors explain why useful agents need retrieval, well-described tools and a harness that manages context and actions.AI agentsRetrieval-Augmented GenerationSearch & retrieval+2