As more organizations explore the use of AI agents in software delivery and operational workflows, technical leaders are confronted with a growing set of architectural decisions: Should agents be orchestrated in parallel or sequence? How should context be preserved across agent boundaries? What coordination mechanisms are required to ensure consistency and reliability?
In a recent essay titled “Don’t Build Multi-Agents”, Cognition’s Walden Yan presents a concise critique of popular approaches to multi-agent design. The core argument is not an outright dismissal of multiple agents, but rather a caution against composing them without principled coordination, shared context, or explicit reconciliation. As engineering leaders seek to incorporate agentic systems into their delivery platforms, the observations in this post deserve careful consideration.
This article summarizes the key principles articulated by Cognition and offers alternative implementation strategies drawn from enterprise software use cases. Our aim is to make these concepts operational—not theoretical—for teams working within complex digital systems.
Original Principle
Sub-agents must be context-aware. When one agent operates without knowledge of previous actions or decisions, the result is incoherence. Providing the full trace of prior actions—both inputs and outputs—enables robust downstream reasoning.
Applied Example (Alternative Use Case)
In a claims automation system for health insurance, multiple agents may assess eligibility, verify prior authorization, and calculate reimbursement. If each agent works in isolation from the prior one, logic errors multiply. A more robust design would maintain a shared trace that includes user history, agent-generated decisions, and intermediate reasoning steps—so that, for example, a reimbursement agent can reason about prior denial decisions without conflicting with them.
Original Principle
Agent outputs are rarely atomic or neutral. They contain implicit decisions—about tone, timing, context, or business logic—that can conflict when combined. When multiple agents are composed without harmonization, these assumptions may contradict each other.
Applied Example (Alternative Use Case)
Consider an AI-driven financial planning tool. One agent proposes an investment strategy based on aggressive growth, while another independently allocates capital toward capital preservation. Absent a reconciliation step, the merged recommendation appears inconsistent to the end user. The correct pattern involves an explicit “alignment agent” that adjudicates conflicting priorities—just as a human advisor would synthesize client preferences into a coherent plan.
Original Principle
Multi-agent architectures often fragment state. A sequential, single-agent loop—augmented with context compression techniques—can outperform parallel agents in complex workflows by preserving coherence and reducing overhead.
Applied Example (Alternative Use Case)
In product content generation, a typical agent might draft a landing page in stages: messaging, design elements, and metadata. Instead of parallelizing each task, a single agent could proceed iteratively, compressing and summarizing prior outputs at each step. This structure maintains context fidelity and makes it easier to audit or debug misaligned messaging across sections.
The observations made in Cognition’s article echo long-standing architectural patterns from distributed systems. In monolithic systems, global state is easier to coordinate. In microservice or multi-agent designs, coordination becomes the challenge. The lesson here is not to reject modularity, but to treat agent composition as a stateful, deliberate engineering task—not a blind orchestration of capabilities.
In practice, the most robust architectures often follow a two-phase hybrid pattern:
Illustrative Example
A travel itinerary generator might dispatch agents to retrieve flights, hotels, and activities independently. After context compression, a single agent creates a cohesive plan, ensuring arrival times, accommodations, and events align. This hybrid model avoids premature commitment to decisions while preserving coherence in the final result.
Engineering leaders seeking to leverage multi-agent architectures must recognize the cost of fragmentation. As Cognition wisely points out, poor coordination results in brittle systems. By investing in explicit trace sharing, assumption resolution, and controlled context compression, we can design systems that reflect intentionality—not incidental complexity.
The future of agentic software will reward clarity of design and alignment of incentives—not merely the number of agents deployed.