Building High-Quality AI Agent Systems: Best Practices

On this page

Multi-agent systems built with large language models (LLMs) split a complex task across specialized agents that plan, reason and act together. In practice, they often fail to beat a well-designed single agent. This post walks through why, using the failure taxonomy from the paper "Why Do Multi-Agent LLM Systems Fail?", and then lays out the design practices that address each failure: clear roles, structured communication, verification at every step, and starting with the simplest system that works.

The paper analyzed over 150 tasks across five popular multi-agent frameworks. It found that, despite the growing adoption of these frameworks, their performance gains on standard benchmarks are minimal compared to well-designed single-agent implementations. The authors identified 14 distinct failure modes that undermine reliability.

This matches what we at Pondhouse Data have seen in many of the multi-agent systems we have built for our clients. A simple and promising MVP with a single agent quickly grows into a complex, brittle system with multiple agents that fails to deliver.

The reason is that agents interact. Those interactions amplify the limits of each individual agent and produce failures that are hard to predict and diagnose. Better prompts alone don't fix them, because the problems sit in how agents communicate, how their reasoning lines up, and how the system is orchestrated.

Why multi-agent LLM systems fail

The paper by Mert Cemri and Melissa Z. Pan and Shuyi Yang and Lakshya A. Agrawal and Bhavya Chopra and Rishabh Tiwari and Kurt Keutzer and Aditya Parameswaran and Dan Klein and Kannan Ramchandran and Matei Zaharia and Joseph E. Gonzalez and Ion Stoica gives a structured taxonomy of the failure modes that show up across different multi-agent frameworks. It is a useful starting point for designing systems that avoid them.

How the study was done

The study "Why Do Multi-Agent LLM Systems Fail?" used a straightforward method to identify and categorize failure patterns:

• Evaluation of five popular open-source multi-agent frameworks (MetaGPT, ChatDev, HyperAgent, AppWorld, AG2)
• Analysis across 150+ tasks representative of what the systems are meant to do
• Tasks spanning software development, utility services, and complex reasoning problems
• Human expert annotation with a Cohen's Kappa score of 0.88, indicating high inter-rater reliability
• Validation through both manual inspection and automated LLM-as-a-Judge evaluation

The same failure patterns appeared across different architectures. That points to fundamental problems with multi-agent designs, not bugs in one particular framework.

Three levels of agent failure

To make the paper's failure modes easier to act on, we group them into three levels of failure (this grouping is ours; the paper itself uses the three categories described further below):

1. Single-agent failures: limits within individual LLM agents, including:

   • Prompt engineering issues (unclear instructions, sensitivity to phrasing)
   • Context handling problems (context length limits, hallucinations)
   • Reasoning failures (incorrect inferences, planning deficits)
   • Instruction following problems (not executing the specified actions)

2. Multi-agent interaction failures: problems that come from how agents work together:

   • Communication breakdowns (misread messages, inconsistent formats)
   • Collaboration problems (goal conflicts, redundant actions)
   • Resource inefficiency (excessive token consumption, high latency)

3. Compound system-level failures: failures that come from the system architecture:

   • Emergent failures (unpredictable errors from component interactions)
   • Cumulative failures (error propagation and amplification)
   • Human-agent interaction problems (task specification misalignment)

Multi-agent failure patterns found across frameworks

The 14 failure modes identified in the paper occur across multiple frameworks. They fall into these groups:

• Task and role specification violations (agents ignoring defined constraints)
• Context management issues (history loss, conversation resets)
• Information flow problems (withholding information, ignoring input)
• Verification deficiencies (incomplete or incorrect verification)
• Task progression errors (repetition, premature termination, derailment)

These failures are not random. They follow identifiable patterns, which means architectural changes can address them systematically.

Single-agent failure modes

Before optimizing how agents interact, fix the failures that happen inside each agent. Single-agent failures often travel through agent interactions and turn into larger, harder-to-trace problems.

Prompt engineering issues

Weak prompts are a primary source of individual agent failures, often before any multi-agent interaction happens.

Technical causes:

• Ambiguous instructions that lack specific constraints or acceptance criteria
• Over-constrained prompts that create contradictory objectives
• Sensitivity to prompt phrasing and formatting
• Missing contextual information required for task execution

Observed failures:

• "Disobey Task Spec" failure mode where agents ignore or misinterpret explicit requirements
• Task outputs that satisfy some constraints while violating others
• Inconsistent performance across similar tasks due to prompt wording variations

Detection approaches:

• Verification agents that validate outputs against explicit requirements
• Automated prompt variation testing to identify sensitivity to wording
• Rubric-based review of prompt completeness before implementation

Context handling failures

LLMs have inherent limits in managing context, and those limits make them less reliable in multi-agent systems.

Technical causes:

• Fixed context window size (token limits)
• Uneven attention to information within the context window
• Inability to track and update state accurately over long interactions
• Tendency to hallucinate or fabricate context when information is incomplete

Observed failures:

• "Loss of History" where agents forget previous conversation content or decisions
• "Conversation Reset" where agents restart interactions without maintaining continuity
• Information fabrication when working with partial data
• Inconsistent references to previously established facts

Detection approaches:

• Context window utilization monitoring
• Information persistence testing across conversation turns
• Contradiction detection between current and previous statements
• Reference tracing to source information

Reasoning limitations

Reasoning weaknesses in LLMs put a hard ceiling on what an agent can do.

Technical causes:

• Weak logical inference, particularly for multi-step reasoning
• Tendency to rely on associative rather than causal reasoning
• Limits in handling quantitative or mathematical operations
• Problems with temporal reasoning and sequencing

Observed failures:

• "Reasoning Mismatch" where actions don't logically follow from stated reasoning
• Incorrect logical deductions despite access to the correct information
• Task derailment when complex reasoning chains are required
• Inability to identify logical contradictions in generated outputs

Detection approaches:

• Reasoning trace validation through step-by-step verification
• Comparison of inference chains against established logical patterns
• Identification of non-sequiturs in agent reasoning
• Testing against adversarial reasoning problems with known solutions

Instruction following problems

LLMs often struggle to follow specific instructions exactly, particularly when the instructions involve structured outputs or procedural steps.

Technical causes:

• Tendency to fall back on common patterns instead of following exact instructions
• Difficulty keeping to instructions across long outputs
• Inconsistent application of constraints throughout task execution
• Limits in understanding and implementing formal specifications

Observed failures:

• "Step Repetition" where agents unnecessarily repeat previously completed actions
• Partial implementation of multi-part instructions
• Format violations in structured output requirements
• "Task Derailment" where agents gradually drift from the specified objective

Detection approaches:

• Automated validation of output against structural requirements
• Step tracking to identify repetition or omission
• Compliance scoring against explicit instruction sets
• Drift detection to measure deviation from original task objectives

Mitigating single-agent failures

Single-agent failures need systematic fixes in agent design:

1. Structured prompting techniques:

   • Include explicit verification criteria within prompts
   • Use chain-of-thought prompting for complex reasoning tasks
   • Use format templates with clear separation between response components
   • Include examples that demonstrate the expected reasoning

2. Context management improvements:

   • Summarize context to handle long interactions
   • Prioritize context so that critical information stays in the window
   • Use external memory structures for persistent information (see our post on adding memory to an AI agent)
   • Track state explicitly

3. Verification mechanisms:

   • Add self-verification steps before output submission
   • Break complex tasks into components that can be verified one by one
   • Validate the format of structured outputs
   • Check reasoning traces for logical consistency

Single-agent failures are often the precursors of the more complex multi-agent interaction problems described next.

Multi-agent interaction failures

When multiple LLM agents interact, new failure modes appear that go beyond the limits of each individual agent. These interaction failures hurt performance and reliability even when every agent works fine on its own.

Communication failures

Passing information between agents creates weak points that can break the whole system.

Technical causes:

• Inconsistent message formats and structures between agents
• Varying levels of detail and abstraction in agent communications
• Incomplete information transfer during agent handoffs
• Parallel conversations that fragment the context

Observed failures:

• "Withholding Info" where agents fail to share critical information
• Misread messages that lead to misaligned actions
• Information loss during sequential processing
• Communication protocol violations that break expected interaction patterns

Detection approaches:

• Information flow tracking across agent boundaries
• Communication protocol compliance monitoring
• Message completeness verification against task requirements
• Semantic analysis of inter-agent message coherence

Collaboration issues and conflicting goals

Coordination problems are common when multiple agents with specialized roles work toward a shared objective.

Technical causes:

• Incomplete or ambiguous role definitions that blur boundaries
• Misaligned optimization objectives between agents
• Poor task decomposition that leaves gaps in responsibility
• No precedence rules for conflicting decisions

Observed failures:

• "Disobey Role Spec" where agents act outside their defined responsibilities
• Redundant work across multiple agents addressing the same subtasks
• "Ignore Input" where agents disregard contributions from other agents
• Conflicting outputs that need reconciliation

Detection approaches:

• Role boundary analysis to identify scope violations
• Contribution redundancy detection across agent outputs
• Decision conflict identification in collaborative outputs
• Input utilization tracking to measure cross-agent influence

Inefficient interactions and resource consumption

Multi-agent architectures often add significant overhead, which hurts performance and raises operating costs.

Technical causes:

• Excessive message passing between agents
• Redundant context processing across multiple agents
• Unnecessary agent invocations for tasks a single agent could handle
• Synchronization delays in sequential processing pipelines

Observed failures:

• High token consumption relative to task complexity
• Increased latency due to sequential dependencies
• Computational inefficiency from repeated context loading
• Diminishing returns as agent count increases

Detection approaches:

• Token utilization analysis per agent and system-wide
• Latency profiling across agent interactions
• Value-add measurement for each agent intervention
• Comparison against single-agent baseline performance

Amplification of individual agent failures

Multi-agent interactions tend to magnify single-agent failures, and the errors cascade through the system.

Technical causes:

• Error propagation through sequential agent interactions
• Hallucinations or reasoning errors that compound across agents
• No error detection and correction between agents
• Context degradation through repeated summarization and transmission

Observed failures:

• "Task Derailment" accelerated by multi-agent interactions
• Confidence amplification in incorrect outputs through apparent consensus
• Reasoning errors that compound through agent specialization
• Information distortion through sequential transmission

Detection approaches:

• Error propagation tracing through interaction sequences
• Consistency validation across agent boundaries
• Fact verification at each agent handoff point
• Divergence measurement from initial task specifications

Mitigating multi-agent interaction failures

Multi-agent interaction failures need architectural fixes that manage communication and coordination:

1. Structured communication protocols:

   • Use standardized message formats with explicit schema validation
   • Design information exchange templates so critical data always gets passed on
   • Define formal handoff procedures with verification steps
   • Log all communication centrally for debugging

2. Role and responsibility frameworks:

   • Define explicit agent boundaries with clear decision authority
   • Add conflict resolution for overlapping responsibilities
   • Use hierarchical oversight for critical decisions
   • Manage context per role to minimize redundancy

3. Efficiency optimization:

   • Invoke agents dynamically based on task requirements
   • Use shared context repositories to reduce redundant processing
   • Run independent subtasks in parallel
   • Develop heuristics for the right number of agents per task type

4. Error management across agent boundaries:

   • Let agents cross-verify each other's work
   • Define explicit error detection and correction protocols
   • Add feedback loops for continual refinement
   • Score the confidence of agent outputs to flag potential errors

Compound system-level failures

Beyond individual agent limits and direct interaction failures, multi-agent systems show emergent behavior that leads to system-level failures. Simple detection methods often miss these, so they need analysis of the system as a whole.

Emergent failures

Emergent failures can't be attributed to any single component. They come from the way components interact across the architecture.

Technical causes:

• Non-linear interactions between multiple agents and components
• Feedback loops that amplify small errors into significant failures
• State inconsistencies across distributed system components
• Interaction patterns nobody anticipated in the system design

Observed failures:

• System oscillations where agents repeatedly reverse decisions
• Deadlock conditions where agents wait for each other's outputs
• Complexity drift where the system generates increasingly convoluted solutions
• Performance degradation that cannot be traced to specific components

Detection approaches:

• System-wide behavior monitoring for pattern recognition
• Statistical analysis of performance across different execution paths
• Simulation testing with controlled error injection
• Comparative analysis against reference implementations

Cumulative failures

Cumulative failures build up gradually from minor errors that compound over time or across many interaction steps.

Technical causes:

• No error correction, so small errors propagate
• Precision loss through sequential processing steps
• Gradual context drift across long agent interactions
• Incremental deviation from intended objectives across multiple decision points

Observed failures:

• Progressive degradation in output quality over multi-turn interactions
• Increasing divergence from task specifications across sequential subtasks
• Error amplification through repeated summarization or transformation
• Small reasoning flaws that add up to significantly wrong conclusions

Detection approaches:

• Longitudinal analysis of error rates across interaction sequences
• Checkpoint validation against ground truth at critical process stages
• Drift measurement from initial specifications throughout execution
• Quality comparison across the interaction timeline

Human-agent interaction problems

The interface between human operators and multi-agent systems adds more ways for the system to fail.

Technical causes:

• Misalignment between human intent and formal task specifications
• Ineffective human oversight of complex agent interactions
• Agent decisions that are hard to explain
• Mismatch between system capabilities and human expectations

Observed failures:

• "Fail Clarify" where agents don't request clarification for ambiguous instructions
• Misinterpretation of human feedback during interactive processes
• Too little transparency for humans to intervene effectively
• Failure to incorporate domain expertise from human operators

Detection approaches:

• Human satisfaction metrics for system outputs
• Intervention frequency analysis during system operation
• Clarification request tracking across interaction types
• Decision justification quality assessment

System design failures

Architectural choices in a multi-agent system can introduce structural weaknesses that affect overall performance.

Technical causes:

• Suboptimal agent topology that creates unnecessary dependencies
• Inadequate specialization leading to role confusion
• Excessive complexity without corresponding performance benefits
• Orchestration mechanisms that don't fit the task

Observed failures:

• Bottlenecks in sequential processing architectures
• Coordination overhead exceeding the benefits of agent specialization
• Rigid architectures that cannot adapt to varying task demands
• Orchestration failures in complex agent networks

Detection approaches:

• Architectural performance modeling and bottleneck identification
• Comparative testing of alternative agent topologies
• Value-add analysis for each architectural component
• Complexity/performance ratio assessment

Mitigating system-level failures

Compound system-level failures need architectural fixes that look at the behavior of the whole system:

1. System-level monitoring and analysis:

   • Add end-to-end telemetry to track performance across the whole system (tools like Langfuse trace every LLM call)
   • Use anomaly detection for emergent behavior patterns
   • Build simulation environments for controlled testing of edge cases
   • Benchmark against baseline implementations

2. Error correction and recovery mechanisms:

   • Validate against specifications at regular checkpoints
   • Design graceful degradation paths for partial system failures
   • Automate recovery for known failure patterns
   • Add feedback mechanisms that stop errors from accumulating

3. Human-in-the-loop integration:

   • Signal uncertainty explicitly so it can trigger human intervention
   • Make intermediate results visible for ongoing oversight
   • Add structured feedback channels for domain expert input
   • Explain system decisions

4. Architectural simplification:

   • Apply Occam's razor to system design to minimize unnecessary complexity
   • Build modular architectures that isolate failure domains
   • Scale complexity up only as the task requires it
   • Design for observability and testability from the start

System-level failures are the hardest part of multi-agent system design. They need both preventive architecture and solid detection. Monitoring, error correction and simpler architectures together make multi-agent systems more reliable and their performance more consistent.

Multi-agent failure categories from the paper

The paper groups its failure modes into three categories: specification and system design failures, inter-agent misalignment, and task verification and termination issues.

Specification and system design failures

Specification and system design failures concern how agents interpret and stick to the specifications defined for their tasks and roles.

Task specification disobedience

The agent produces outputs that violate explicit task requirements. This is the "Disobey Task Spec" failure mode, where agents ignore constraints or requirements. For example, in a code generation task with specific API requirements, the agent writes code that uses deprecated or unauthorized methods. The output looks functional but misses critical requirements, which causes integration problems downstream.

Role specification violations

The agent operates outside its defined role. In the "Disobey Role Spec" failure mode, agents perform actions assigned to other agents, such as a research agent making implementation decisions that a development agent should handle. The result is role confusion, inconsistent decisions and gaps in responsibility.

Redundant processing issues

The agent repeats work that is already done. The "Step Repetition" failure mode showed up across multiple agent frameworks, for example a planning agent regenerating plans although there is no new information or requirement. This wastes tokens, makes the system slower, and can produce inconsistencies between iterations.

Inter-agent misalignment problems

Inter-agent misalignment covers breakdowns in how agents share information and coordinate their work.

Context loss and memory issues

Agents fail to keep a consistent context across interactions. These are the "Loss of History" and "Conversation Reset" failure modes. An agent forgets key decisions from earlier in the conversation or restarts a task midway. The consequences are inconsistent decisions, repetitive questions, and an inability to build on previous work.

Information sharing failures

Critical information doesn't get from one agent to another. The "Withholding Info" and "Ignore Input" failure modes describe this, for example a data analysis agent that doesn't pass important findings on to a reporting agent. The outcome is incomplete analysis, duplicated work, and outputs based on partial information.

Reasoning inconsistencies

An agent's actions don't follow from its own reasoning. In the "Reasoning Mismatch" failure mode, conclusions don't follow from premises: an agent correctly identifies a problem but proposes an unrelated or contradictory solution. System behavior becomes unpredictable, and outputs can't be traced back to a logical line of reasoning.

Task trajectory problems

Agents gradually drift away from the intended objective. In the "Task Derailment" failure mode, a planning agent might slowly shift its focus to side issues and lose sight of the main goal. Resources go into non-critical paths, and the core task doesn't get done.

Task verification and termination issues

Task verification and termination issues concern how agents evaluate their own work and decide when it is finished.

Premature task termination

Agents finish tasks before the requirements are fully met. The "Premature Stop" failure mode was observed across frameworks, for example a code generation agent delivering a partial implementation while marking the task as complete. The deliverable looks final but is incomplete, and a human has to step in.

Completion recognition problems

Agents don't recognize when they have reached the objective. In the "Unaware Stop" failure mode, agents keep going unnecessarily, such as a research agent that keeps gathering information after all information requirements are satisfied. This wastes resources, adds complexity, and can introduce errors into work that was already complete.

Verification deficiencies

Outputs are not properly checked against requirements. These are the "No Verification" and "Incorrect Verification" failure modes, for example a QA agent that misses clear errors or approves incorrect outputs. Errors then reach downstream processes or end users with false confidence attached.

Clarification request failures

Agents go ahead with ambiguous instructions without asking for clarification. The "Fail Clarify" failure mode appears across multiple frameworks: an agent makes assumptions about ambiguous requirements instead of asking for specific guidance. The output technically satisfies the agent's interpretation of the requirements but misses what was actually meant.

Patterns across the failure categories

In the first version of the paper, the failures split across the three categories as follows:

• Specification and system design failures: 37.2%
• Inter-agent misalignment: 31.4%
• Task verification and termination: 31.4%

No single category dominates, so fixing only one kind of problem won't make a multi-agent system reliable.

The categories are also connected. A violated role specification can lead to an information sharing failure, lost context can lead to inconsistent reasoning, and weak verification lets almost every other failure reach the final output.

How to build reliable AI agent systems

The failure taxonomy above translates into a practical framework for designing, implementing and improving multi-agent systems. The following practices are a good starting point.

Agent design fundamentals

Clear task and role specification

The research shows that role ambiguity contributes significantly to agent failures. These practices make specifications clearer:

• Define each agent's boundaries explicitly: its responsibilities, its authority and its limitations within the system.

1AGENT ROLE: Code Reviewer
2PRIMARY RESPONSIBILITY: Evaluate code for security vulnerabilities and logic errors
3AUTHORITY: Can request code revisions but cannot modify code directly
4LIMITATIONS: Should not suggest feature enhancements or architectural changes

• Write down in a responsibility matrix which agent owns each subtask, decision type and verification step.

• State explicitly what the agent should not do. This addresses the "Disobey Role Spec" failure mode.

• Add concrete examples of correct and incorrect agent behavior to the specification.

Prompt engineering for reliability

Prompt design has a large effect on agent reliability. These practices are backed by the research:

• Use the same prompt structure across agents, so their behavior is predictable.

• Include self-verification steps in prompts to address reasoning failures:

1Before submitting your response, verify that:
21. Your analysis directly addresses the specific question asked
32. Your reasoning is supported by the provided information
43. You have not introduced unsupported assumptions
54. Your conclusion logically follows from your analysis

• Add explicit instructions for keeping track of context, addressing the "Loss of History" failure mode:

1Important: Maintain awareness of key decisions from our conversation:
2- Selected database: PostgreSQL
3- Authentication method: OAuth2
4- Deployment environment: Kubernetes

• Ask agents to show their reasoning step by step, so errors are easier to spot.

Modular agent architecture

Research shows that overly complex agent roles contribute to system failures. These architectural principles help:

• Give each agent a single, well-defined purpose instead of combining multiple roles.

• Use consistent input and output formats between agents to reduce communication failures.

• Start with generalist agents and split them into specialists as the system requirements become clearer.

• Put high-risk operations (verification, security checks) into dedicated agents with simple prompts.

Interaction and communication design

Structured conversation flows

The research identifies unstructured conversations as a cause of task derailment. These interaction patterns help:

• Define specific formats for requests, responses and handoffs between agents.

• Split complex tasks into discrete phases with explicit criteria for moving from one phase to the next.

• Use categorical message types (for example query, response, verification, clarification) so interactions are predictable.

• Define how a conversation starts, progresses and ends, which addresses the "Conversation Reset" failure mode.

Verification mechanisms

Verification deficiencies are a critical failure category across frameworks. These verification strategies help:

• Set up cross-verification loops where one agent checks another's output before the workflow continues:

1VERIFICATION WORKFLOW:
21. Agent A generates solution
32. Agent B evaluates solution against requirements
43. If approved, proceed; if rejected, return to Agent A with specific feedback
54. Limit iterations to prevent infinite loops

• Create dedicated verification agents that do nothing but quality assurance, with explicit verification criteria.

• Validate outputs against predefined schemas to catch format violations.

• Add verification checkpoints throughout multi-step processes, not only at the end.

Clarification protocols

The "Fail Clarify" failure mode appears consistently across frameworks. These clarification strategies help:

• Instruct agents to ask for clarification when their confidence falls below a defined threshold.

• Prompt agents to identify and flag ambiguous instructions:

1If the requirements contain any of these ambiguity indicators:
2- Multiple possible interpretations
3- Undefined technical terms
4- Conflicting constraints
5- Unclear priorities
6Then: Request specific clarification before proceeding

• Define a format for clarification questions that pinpoints the ambiguity.

• When an agent proceeds without clarification, require it to document its assumptions explicitly.

System architecture and orchestration

Topology design

System design failures are a significant category of multi-agent issues. These architectural principles help:

• Use supervisor agents that coordinate specialized worker agents. This addresses the "Task Derailment" failure mode.

• Build feedback loops in which outputs are refined iteratively:

1REFINEMENT CYCLE:
21. Draft generation
32. Critical evaluation
43. Targeted improvement
54. Re-evaluation against acceptance criteria
65. Finalization or return to step 2

• Use multiple verification paths to catch different types of errors.

• Split generation and evaluation between different agents. Errors are easier to detect when the agent that checks the work didn't produce it.

Workflow optimization

Inefficient interactions are a significant failure category. These optimization strategies help:

• Cache context in shared repositories to reduce redundant information transfer between agents.

• Give agents information only when it is relevant to their current task, to keep their context clean.

• Invoke specialized agents only when needed instead of keeping all agents active throughout the process.

• Process independent subtasks in parallel to reduce end-to-end latency.

Error handling and recovery

The research shows that error propagation leads to cumulative system failures. These recovery mechanisms help:

• Define clear error types and a recovery action for each.

• Design the system to keep running with reduced functionality when components fail.

• Make it possible to roll back to a known-good state when an error is detected.

• Define specific conditions that automatically escalate to a human operator.

Implementation and testing strategy

Incremental development

Research indicates that system complexity correlates with failure rates. This development approach keeps complexity in check:

1. Start with minimal viable agents: begin with the simplest system that can accomplish the core task (our guide to building AI agents without frameworks shows how small that can be).

2. Test-driven expansion: add agents or capabilities only after the baseline is reliable.

3. Controlled complexity: introduce one new interaction pattern at a time and test it thoroughly.

4. Comparative evaluation: keep comparing multi-agent performance against single-agent baselines to justify the added complexity.

Systematic testing methods

The range of failure modes in the research calls for thorough testing:

• Deliberately test each failure mode in the taxonomy.

• Create challenging edge cases designed to trigger specific failure patterns.

• Evaluate system performance over long interaction sequences to detect cumulative failures.

• Evaluate individual agents in isolation before integration to establish their baseline capabilities.

Continuous improvement process

Research shows that failure patterns change as systems develop. This iterative improvement process keeps up with them:

1. Failure categorization: classify observed failures according to the taxonomy.

2. Root cause analysis: trace failures to specific architectural or prompt design elements.

3. Targeted interventions: make focused improvements that address the root causes.

4. Verification testing: confirm that the changes resolve the specific failure modes without introducing new ones.

Example: a collaborative document creation system

To illustrate these principles, consider a system for collaborative document creation.

Initial flawed design:

• Single agent handling both content generation and editing
• Unstructured conversation flow
• No explicit verification mechanisms
• No termination criteria

Improved design applying best practices:

1. Modular agent specialization:

   • Research Agent: Information gathering and fact verification
   • Content Generation Agent: Initial draft creation
   • Editor Agent: Stylistic and structural improvements
   • Quality Assurance Agent: Final verification against requirements

2. Structured workflow:

   • Clear phase transitions with verification gates
   • Explicit handoff protocols between agents
   • Defined criteria for process completion

3. Verification mechanisms:

   • Cross-agent verification of factual accuracy
   • Requirement adherence checklist
   • Explicit output validation against format specifications

4. Error handling:

   • Clear resolution protocols for inter-agent disagreements
   • Human escalation path for irreconcilable issues
   • Context preservation throughout the workflow

The improved design addresses the major failure modes identified in the research while keeping the system efficient.

Core principles for reliable AI agent systems

The research and our practical experience come down to five principles:

1. Clarity trumps complexity: systems with clear, simple agent roles outperform more sophisticated architectures with ambiguous responsibilities.

2. Verification is not optional: every agent output must be verified, through self-verification, cross-verification or dedicated verification agents.

3. Conversation structure creates reliability: explicit conversation protocols significantly reduce derailment and context loss.

4. Modularity enables resilience: specialized agents with focused responsibilities make targeted improvements and debugging easier.

5. Incremental complexity: start with minimal viable architectures and add complexity only when measurable performance improvements justify it.

If you are about to build a multi-agent system, start with a single agent, measure it, and add a second agent only when it beats that baseline and comes with its own verification step.

Interested in building high-quality AI agent systems?

We prepared a comprehensive guide based on cutting-edge research for how to build robust, reliable AI agent systems that actually work in production. This guide covers:

• Understanding the 14 systematic failure modes in multi-agent systems
• Evidence-based best practices for agent design
• Structured communication protocols and verification mechanisms

Further reading

• Advanced Self-Made Agent: Building a Smarter, Multi-Step AI Agent
• How to Build AI Agents Without Frameworks: A Step-by-Step Guide
• DSPy: Build Better AI Systems with Automated Prompt Optimization
• How to: RAG with Azure AI Search

About the author

Andreas Nigg

Co-Founder, Pondhouse Data

Andreas has spent more than eight years building data applications. At Pondhouse Data he designs and ships AI systems and integrates them into complex, real-world environments.

Talk to Andreas about your projectFollow on LinkedIn