{
  "@context": "https://schema.org",
  "@id": "https://aggr.aymericbeaumet.com/items/philschmid-de/2025-06-20-single-vs-multi-agent-system/#webpage",
  "@type": [
    "WebPage",
    "ArchiveComponent"
  ],
  "articleBody": "The debate on whats the right way to build Agents in the AI community heated up with Cognition's [\"Don't Build Multi-Agents\"](https://cognition.ai/blog/dont-build-multi-agents) and Anthropic's [\"How we built our multi-agent research system\"](https://www.anthropic.com/engineering/built-multi-agent-research-system). Despite their opposing titles both are surprisingly aligned. The choice between a single agent and a multi-agent system isn't about ideology, it is about picking the right tool for the right job.\n\nBefore we take a closer look, let's establish a simple definition.\n\n> AI agent is a system that uses a Large Language Model (LLM) as reasoning engine to decide the control flow of an application.\n\n## What Are Single Agents?\n\nA single-agent system operates as a “single process”. Think of it as one highly-focused worker tackling a task from start to finish. It maintains a continuous thread of thought (memory) and action (tools) to ensure that every step is informed by everything that came before it.\n\n![cognition-single-agent](https://www.philschmid.de/static/blog/single-vs-multi-agents/cognition.png)\n\n\\[Credits: [Cognition Don’t Build Multi-Agents](https://cognition.ai/blog/dont-build-multi-agents)\\]\n\n**Key characteristics:**\n\n- **Sequential:** Actions are performed one after another. The agent completes step A before moving to step B.\n- **Unified Contenxt:** Maintains a single, continuous history of the entire conversation. Every new step has access to all previous steps, thoughts, and tool outputs.\n- **Stateful:** Decisions made early on directly and fully inform later actions without the need for message passing.\n\n**Pros:**\n\n- **Context Continuity**: No information is lost between steps\n- **Simplicity**: Easier to debug, test, and maintain\n- **Transparency**: Clear execution path and decision trail\n\n**Cons:**\n\n- **Sequential Bottlenecks:** Slow for tasks where parts could be handled in parallel.\n- **Context Window Limitations**: Eventually exceed the (useful) context window, leading to errors and forgotten details.\n- **Inefficiency**: May waste tokens on repetitive context and are limited to single model capabilities/instructions\n\n## What Are Multi-Agent Systems?\n\nA multi-agent system is structured like a team. It typically involves an “lead agent\" that breaks down a goal into smaller subtasks, which it then delegates to multiple \"worker\" agents that can operate in parallel.\n\n![multi-agent](https://www.philschmid.de/static/blog/agentic-pattern/multi-agent.png)\n\n**Key characteristics:**\n\n- **Parallel Execution:** Subtasks can be handled simultaneously by multiple agents.\n- **Delegation:** A \"lead\" agent typically decomposes the main goal, delegates subtasks, and synthesizes the results from the worker agents.\n- **Distributed Context:** Each agent operates with its own context, which is often a subset of the total information.\n\n**Pros:**\n\n- **Parallelization**: Can explore multiple paths simultaneously, reducing latency.\n- **Specialization**: Each agent can be optimized and instructed for specific tasks\n- **Breadth**: Can solve complex, multi-faceted problems.\n\n**Cons:**\n\n- **Context**: Sharing the right context between agents is hard\n- **Coordination:** Agents may duplicate work or make conflicting decisions\n- **Cost:** Can be more token-intensive. (Anthropic: 15x more tokens compared to a standard chat interaction)\n\n***Note:*** It's worth mentioning other multi-agent pattern, e.g. swarm are not using a \"lead\" agent. Instead they collaborate in a more peer-to-peer fashion to solve a problem, which has both single agent and multi agent characteristics, e.g. Unified Context, but individual instructions but comes with its on challenges.\n\n## Comparison Single Agents vs Multi-Agent Systems\n\n| Aspect                 | Single Agent System                                  | Multi-Agent System                                                              |\n| ---------------------- | ---------------------------------------------------- | ------------------------------------------------------------------------------- |\n| **Context Management** | Continuous, no loss                                  | Complex sharing required                                                        |\n| **Execution Speed**    | Sequential                                           | Parallel                                                                        |\n| **Token usage**        | 4x chat tokens                                       | 15x chat tokens                                                                 |\n| **Reliability**        | High, predictable                                    | Lower, emergent behaviors                                                       |\n| **Debugging**          | Straightforward                                      | Complex, non-deterministic                                                      |\n| **Best For**           | Sequential, state-dependent tasks (\"write\" tasks).   | Parallelizable, exploratory tasks (\"read\" tasks).                               |\n| **Coordination**       | None needed                                          | Critical success factor                                                         |\n| **Example Use Case**   | Refactoring a codebase, writing a detailed document. | Researching a broad market trend, identifying all board members of the S&P 500. |\n| **Core Strength**      | Context Continuity & Reliability                     | Parallelism & Scalability                                                       |\n| **Primary Challenge**  | Context Window Limits & Sequential Speed             | Context Fragmentation & Coordination Complexity                                 |\n\n## The Universal Truths of Building Agents\n\nDespite their opposing common principles apply for building serious Agentic system.\n\n1. **Context Engineering is everything:** Architecting systems that dynamically maintain the right information at the right time for reliable decision-making is the key to success and reliability. This isn't just prompt engineering.\n2. **\"Read\" vs \"Write\" Agents:** Are important distinction isn't single vs multi-agent. it is whether your task primarily involves **reading** (research, analysis, information gathering) or **writing** (code generation, content creation, file editing).\n   - **Read tasks** are easier to parallelize and suite multi-agent better\n   - **Write tasks** create coordination problems when parallelized, favoring single agents\n   - **Mixed tasks** should separate read and write phases architecturally\n3. **Reliable Agents Need Different Tooling:** Building reliable agents requires more than a good model. It requires a robust infrastructure for durable execution to survive failures, observability to debug behavior, and evaluation to measure what actually matters.\n4. **Economic Viability and Model Improvements:** Models themselves are improving at an incredible rate. Don't over-engineer a solution for today that a much simpler can solve for you tomorrow.\n\n* * *\n\nThanks for reading! If you have any questions or feedback, please let me know on [Twitter](https://twitter.com/_philschmid) or [LinkedIn](https://www.linkedin.com/in/philipp-schmid-a6a2bb196/).\n",
  "authors": [],
  "captured_at": "2026-09-27T19:29:15.293681927+00:00",
  "category": "programming",
  "content_html": "<p>The debate on whats the right way to build Agents in the AI community heated up with Cognition's <a target=\"_blank\" rel=\"noopener noreferrer\" href=\"https://cognition.ai/blog/dont-build-multi-agents\">&quot;Don't Build Multi-Agents&quot;</a> and Anthropic's <a target=\"_blank\" rel=\"noopener noreferrer\" href=\"https://www.anthropic.com/engineering/built-multi-agent-research-system\">&quot;How we built our multi-agent research system&quot;</a>. Despite their opposing titles both are surprisingly aligned. The choice between a single agent and a multi-agent system isn't about ideology, it is about picking the right tool for the right job.</p>\n<p>Before we take a closer look, let's establish a simple definition.</p>\n<blockquote>\n<p>AI agent is a system that uses a Large Language Model (LLM) as reasoning engine to decide the control flow of an application.</p>\n</blockquote>\n<h2>What Are Single Agents?</h2>\n<p>A single-agent system operates as a “single process”. Think of it as one highly-focused worker tackling a task from start to finish. It maintains a continuous thread of thought (memory) and action (tools) to ensure that every step is informed by everything that came before it.</p>\n<p><picture class=\"article-picture article-picture-fallback\" style=\"--image-ratio:16 / 9\"><img src=\"https://www.philschmid.de/static/blog/single-vs-multi-agents/cognition.png\" alt=\"cognition-single-agent\" loading=\"eager\" decoding=\"async\" fetchpriority=\"high\" referrerpolicy=\"no-referrer\" class=\"progressive-image\"></picture></p>\n<p>[Credits: <a target=\"_blank\" rel=\"noopener noreferrer\" href=\"https://cognition.ai/blog/dont-build-multi-agents\">Cognition Don’t Build Multi-Agents</a>]</p>\n<p><strong>Key characteristics:</strong></p>\n<ul>\n<li><strong>Sequential:</strong> Actions are performed one after another. The agent completes step A before moving to step B.</li>\n<li><strong>Unified Contenxt:</strong> Maintains a single, continuous history of the entire conversation. Every new step has access to all previous steps, thoughts, and tool outputs.</li>\n<li><strong>Stateful:</strong> Decisions made early on directly and fully inform later actions without the need for message passing.</li>\n</ul>\n<p><strong>Pros:</strong></p>\n<ul>\n<li><strong>Context Continuity</strong>: No information is lost between steps</li>\n<li><strong>Simplicity</strong>: Easier to debug, test, and maintain</li>\n<li><strong>Transparency</strong>: Clear execution path and decision trail</li>\n</ul>\n<p><strong>Cons:</strong></p>\n<ul>\n<li><strong>Sequential Bottlenecks:</strong> Slow for tasks where parts could be handled in parallel.</li>\n<li><strong>Context Window Limitations</strong>: Eventually exceed the (useful) context window, leading to errors and forgotten details.</li>\n<li><strong>Inefficiency</strong>: May waste tokens on repetitive context and are limited to single model capabilities/instructions</li>\n</ul>\n<h2>What Are Multi-Agent Systems?</h2>\n<p>A multi-agent system is structured like a team. It typically involves an “lead agent&quot; that breaks down a goal into smaller subtasks, which it then delegates to multiple &quot;worker&quot; agents that can operate in parallel.</p>\n<p><picture class=\"article-picture article-picture-fallback\" style=\"--image-ratio:16 / 9\"><img src=\"https://www.philschmid.de/static/blog/agentic-pattern/multi-agent.png\" alt=\"multi-agent\" loading=\"lazy\" decoding=\"async\" fetchpriority=\"low\" referrerpolicy=\"no-referrer\" class=\"progressive-image\"></picture></p>\n<p><strong>Key characteristics:</strong></p>\n<ul>\n<li><strong>Parallel Execution:</strong> Subtasks can be handled simultaneously by multiple agents.</li>\n<li><strong>Delegation:</strong> A &quot;lead&quot; agent typically decomposes the main goal, delegates subtasks, and synthesizes the results from the worker agents.</li>\n<li><strong>Distributed Context:</strong> Each agent operates with its own context, which is often a subset of the total information.</li>\n</ul>\n<p><strong>Pros:</strong></p>\n<ul>\n<li><strong>Parallelization</strong>: Can explore multiple paths simultaneously, reducing latency.</li>\n<li><strong>Specialization</strong>: Each agent can be optimized and instructed for specific tasks</li>\n<li><strong>Breadth</strong>: Can solve complex, multi-faceted problems.</li>\n</ul>\n<p><strong>Cons:</strong></p>\n<ul>\n<li><strong>Context</strong>: Sharing the right context between agents is hard</li>\n<li><strong>Coordination:</strong> Agents may duplicate work or make conflicting decisions</li>\n<li><strong>Cost:</strong> Can be more token-intensive. (Anthropic: 15x more tokens compared to a standard chat interaction)</li>\n</ul>\n<p><em><strong>Note:</strong></em> It's worth mentioning other multi-agent pattern, e.g. swarm are not using a &quot;lead&quot; agent. Instead they collaborate in a more peer-to-peer fashion to solve a problem, which has both single agent and multi agent characteristics, e.g. Unified Context, but individual instructions but comes with its on challenges.</p>\n<h2>Comparison Single Agents vs Multi-Agent Systems</h2>\n<table>\n<thead>\n<tr>\n<th>Aspect</th>\n<th>Single Agent System</th>\n<th>Multi-Agent System</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td><strong>Context Management</strong></td>\n<td>Continuous, no loss</td>\n<td>Complex sharing required</td>\n</tr>\n<tr>\n<td><strong>Execution Speed</strong></td>\n<td>Sequential</td>\n<td>Parallel</td>\n</tr>\n<tr>\n<td><strong>Token usage</strong></td>\n<td>4x chat tokens</td>\n<td>15x chat tokens</td>\n</tr>\n<tr>\n<td><strong>Reliability</strong></td>\n<td>High, predictable</td>\n<td>Lower, emergent behaviors</td>\n</tr>\n<tr>\n<td><strong>Debugging</strong></td>\n<td>Straightforward</td>\n<td>Complex, non-deterministic</td>\n</tr>\n<tr>\n<td><strong>Best For</strong></td>\n<td>Sequential, state-dependent tasks (&quot;write&quot; tasks).</td>\n<td>Parallelizable, exploratory tasks (&quot;read&quot; tasks).</td>\n</tr>\n<tr>\n<td><strong>Coordination</strong></td>\n<td>None needed</td>\n<td>Critical success factor</td>\n</tr>\n<tr>\n<td><strong>Example Use Case</strong></td>\n<td>Refactoring a codebase, writing a detailed document.</td>\n<td>Researching a broad market trend, identifying all board members of the S&amp;P 500.</td>\n</tr>\n<tr>\n<td><strong>Core Strength</strong></td>\n<td>Context Continuity &amp; Reliability</td>\n<td>Parallelism &amp; Scalability</td>\n</tr>\n<tr>\n<td><strong>Primary Challenge</strong></td>\n<td>Context Window Limits &amp; Sequential Speed</td>\n<td>Context Fragmentation &amp; Coordination Complexity</td>\n</tr>\n</tbody>\n</table>\n<h2>The Universal Truths of Building Agents</h2>\n<p>Despite their opposing common principles apply for building serious Agentic system.</p>\n<ol>\n<li><strong>Context Engineering is everything:</strong> Architecting systems that dynamically maintain the right information at the right time for reliable decision-making is the key to success and reliability. This isn't just prompt engineering.</li>\n<li><strong>&quot;Read&quot; vs &quot;Write&quot; Agents:</strong> Are important distinction isn't single vs multi-agent. it is whether your task primarily involves <strong>reading</strong> (research, analysis, information gathering) or <strong>writing</strong> (code generation, content creation, file editing).\n<ul>\n<li><strong>Read tasks</strong> are easier to parallelize and suite multi-agent better</li>\n<li><strong>Write tasks</strong> create coordination problems when parallelized, favoring single agents</li>\n<li><strong>Mixed tasks</strong> should separate read and write phases architecturally</li>\n</ul>\n</li>\n<li><strong>Reliable Agents Need Different Tooling:</strong> Building reliable agents requires more than a good model. It requires a robust infrastructure for durable execution to survive failures, observability to debug behavior, and evaluation to measure what actually matters.</li>\n<li><strong>Economic Viability and Model Improvements:</strong> Models themselves are improving at an incredible rate. Don't over-engineer a solution for today that a much simpler can solve for you tomorrow.</li>\n</ol>\n<hr />\n<p>Thanks for reading! If you have any questions or feedback, please let me know on <a target=\"_blank\" rel=\"noopener noreferrer\" href=\"https://twitter.com/_philschmid\">Twitter</a> or <a target=\"_blank\" rel=\"noopener noreferrer\" href=\"https://www.linkedin.com/in/philipp-schmid-a6a2bb196/\">LinkedIn</a>.</p>\n",
  "content_markdown": "The debate on whats the right way to build Agents in the AI community heated up with Cognition's [\"Don't Build Multi-Agents\"](https://cognition.ai/blog/dont-build-multi-agents) and Anthropic's [\"How we built our multi-agent research system\"](https://www.anthropic.com/engineering/built-multi-agent-research-system). Despite their opposing titles both are surprisingly aligned. The choice between a single agent and a multi-agent system isn't about ideology, it is about picking the right tool for the right job.\n\nBefore we take a closer look, let's establish a simple definition.\n\n> AI agent is a system that uses a Large Language Model (LLM) as reasoning engine to decide the control flow of an application.\n\n## What Are Single Agents?\n\nA single-agent system operates as a “single process”. Think of it as one highly-focused worker tackling a task from start to finish. It maintains a continuous thread of thought (memory) and action (tools) to ensure that every step is informed by everything that came before it.\n\n![cognition-single-agent](https://www.philschmid.de/static/blog/single-vs-multi-agents/cognition.png)\n\n\\[Credits: [Cognition Don’t Build Multi-Agents](https://cognition.ai/blog/dont-build-multi-agents)\\]\n\n**Key characteristics:**\n\n- **Sequential:** Actions are performed one after another. The agent completes step A before moving to step B.\n- **Unified Contenxt:** Maintains a single, continuous history of the entire conversation. Every new step has access to all previous steps, thoughts, and tool outputs.\n- **Stateful:** Decisions made early on directly and fully inform later actions without the need for message passing.\n\n**Pros:**\n\n- **Context Continuity**: No information is lost between steps\n- **Simplicity**: Easier to debug, test, and maintain\n- **Transparency**: Clear execution path and decision trail\n\n**Cons:**\n\n- **Sequential Bottlenecks:** Slow for tasks where parts could be handled in parallel.\n- **Context Window Limitations**: Eventually exceed the (useful) context window, leading to errors and forgotten details.\n- **Inefficiency**: May waste tokens on repetitive context and are limited to single model capabilities/instructions\n\n## What Are Multi-Agent Systems?\n\nA multi-agent system is structured like a team. It typically involves an “lead agent\" that breaks down a goal into smaller subtasks, which it then delegates to multiple \"worker\" agents that can operate in parallel.\n\n![multi-agent](https://www.philschmid.de/static/blog/agentic-pattern/multi-agent.png)\n\n**Key characteristics:**\n\n- **Parallel Execution:** Subtasks can be handled simultaneously by multiple agents.\n- **Delegation:** A \"lead\" agent typically decomposes the main goal, delegates subtasks, and synthesizes the results from the worker agents.\n- **Distributed Context:** Each agent operates with its own context, which is often a subset of the total information.\n\n**Pros:**\n\n- **Parallelization**: Can explore multiple paths simultaneously, reducing latency.\n- **Specialization**: Each agent can be optimized and instructed for specific tasks\n- **Breadth**: Can solve complex, multi-faceted problems.\n\n**Cons:**\n\n- **Context**: Sharing the right context between agents is hard\n- **Coordination:** Agents may duplicate work or make conflicting decisions\n- **Cost:** Can be more token-intensive. (Anthropic: 15x more tokens compared to a standard chat interaction)\n\n***Note:*** It's worth mentioning other multi-agent pattern, e.g. swarm are not using a \"lead\" agent. Instead they collaborate in a more peer-to-peer fashion to solve a problem, which has both single agent and multi agent characteristics, e.g. Unified Context, but individual instructions but comes with its on challenges.\n\n## Comparison Single Agents vs Multi-Agent Systems\n\n| Aspect                 | Single Agent System                                  | Multi-Agent System                                                              |\n| ---------------------- | ---------------------------------------------------- | ------------------------------------------------------------------------------- |\n| **Context Management** | Continuous, no loss                                  | Complex sharing required                                                        |\n| **Execution Speed**    | Sequential                                           | Parallel                                                                        |\n| **Token usage**        | 4x chat tokens                                       | 15x chat tokens                                                                 |\n| **Reliability**        | High, predictable                                    | Lower, emergent behaviors                                                       |\n| **Debugging**          | Straightforward                                      | Complex, non-deterministic                                                      |\n| **Best For**           | Sequential, state-dependent tasks (\"write\" tasks).   | Parallelizable, exploratory tasks (\"read\" tasks).                               |\n| **Coordination**       | None needed                                          | Critical success factor                                                         |\n| **Example Use Case**   | Refactoring a codebase, writing a detailed document. | Researching a broad market trend, identifying all board members of the S&P 500. |\n| **Core Strength**      | Context Continuity & Reliability                     | Parallelism & Scalability                                                       |\n| **Primary Challenge**  | Context Window Limits & Sequential Speed             | Context Fragmentation & Coordination Complexity                                 |\n\n## The Universal Truths of Building Agents\n\nDespite their opposing common principles apply for building serious Agentic system.\n\n1. **Context Engineering is everything:** Architecting systems that dynamically maintain the right information at the right time for reliable decision-making is the key to success and reliability. This isn't just prompt engineering.\n2. **\"Read\" vs \"Write\" Agents:** Are important distinction isn't single vs multi-agent. it is whether your task primarily involves **reading** (research, analysis, information gathering) or **writing** (code generation, content creation, file editing).\n   - **Read tasks** are easier to parallelize and suite multi-agent better\n   - **Write tasks** create coordination problems when parallelized, favoring single agents\n   - **Mixed tasks** should separate read and write phases architecturally\n3. **Reliable Agents Need Different Tooling:** Building reliable agents requires more than a good model. It requires a robust infrastructure for durable execution to survive failures, observability to debug behavior, and evaluation to measure what actually matters.\n4. **Economic Viability and Model Improvements:** Models themselves are improving at an incredible rate. Don't over-engineer a solution for today that a much simpler can solve for you tomorrow.\n\n* * *\n\nThanks for reading! If you have any questions or feedback, please let me know on [Twitter](https://twitter.com/_philschmid) or [LinkedIn](https://www.linkedin.com/in/philipp-schmid-a6a2bb196/).\n",
  "dateCreated": "2026-09-27T19:29:15.293681927+00:00",
  "date_created": "2025-06-20T00:00:00+00:00",
  "date_modified": "2025-06-20T00:00:00+00:00",
  "date_published": "2025-06-20T00:00:00+00:00",
  "description": "Single vs. multi-agent? The real secret to building AI agents is 'read vs. write'. Learn which to use for your task and build reliable systems.",
  "external_url": "https://www.philschmid.de/single-vs-multi-agents",
  "git": {
    "commit": "ebb0941c5c06a2ab2377342d607535262a3e969e",
    "path": "items/philschmid-de/2025/06/2025-06-20-single-vs-multi-agent-system.md",
    "permalink": "https://github.com/aymericbeaumet/aggr-instance/blob/ebb0941c5c06a2ab2377342d607535262a3e969e/items/philschmid-de/2025/06/2025-06-20-single-vs-multi-agent-system.md"
  },
  "id": "urn:aggr:item:7aef1b5ef9a392f11826d9dc1785cf78ad452d5a",
  "isBasedOn": {
    "@id": "https://www.philschmid.de/single-vs-multi-agents"
  },
  "mainEntity": {
    "@id": "https://www.philschmid.de/single-vs-multi-agents",
    "@type": "CreativeWork",
    "archivedAt": {
      "@id": "https://aggr.aymericbeaumet.com/items/philschmid-de/2025-06-20-single-vs-multi-agent-system/#webpage"
    },
    "dateModified": "2025-06-20T00:00:00+00:00",
    "datePublished": "2025-06-20T00:00:00+00:00",
    "headline": "Single vs Multi-Agent System?",
    "timeRequired": "PT4M",
    "url": "https://www.philschmid.de/single-vs-multi-agents",
    "wordCount": 786
  },
  "name": "Archived snapshot: Single vs Multi-Agent System?",
  "preview": null,
  "reading_minutes": 4,
  "replicated_at": null,
  "source": "philschmid-de",
  "source_name": "philschmid.de - RSS feed",
  "summary": "Single vs. multi-agent? The real secret to building AI agents is 'read vs. write'. Learn which to use for your task and build reliable systems.",
  "tags": [],
  "temporalCoverage": "2026-09-27T19:29:15.293681927+00:00",
  "title": "Single vs Multi-Agent System?",
  "url": "https://aggr.aymericbeaumet.com/items/philschmid-de/2025-06-20-single-vs-multi-agent-system/",
  "word_count": 786
}