Back to Blog
AI Agents10 min read

Methods for Monitoring and Diagnosing Errors in Complex Multi-Agent AI Systems

How to observe multi-agent AI systems: tracing, metrics, quality evaluation, identifying the agent that caused a failure, and EU AI Act logging requirements.

O

Oleksandr Ivanchuk

Software Developer

A multi-agent system can run without a single technical error and still produce an incorrect result. Classical monitoring tools will not notice this. In this article we examine how observing agentic systems differs from monitoring conventional software, which levels of observability are needed, why finding the agent that caused a failure is harder than it seems, and what follows from this for an industrial enterprise.

Introduction

When a single agent operates in a system, investigating an error comes down to reviewing one dialogue. When there are several agents, and each of them calls tools, passes assignments to others, and makes intermediate decisions, one user request generates dozens or hundreds of steps. An error made at the third step may surface at the thirtieth, in the form of an entirely plausible but incorrect answer.

We wrote about the principles of organizing agent collaboration in the article on multi-agent orchestration. Here we examine the next question, which inevitably arises after launch: how to find out that the system is working incorrectly, and how to find the cause.

In our practice, it is the absence of observation tools, not the quality of the models, that most often halts the transition of agentic solutions from pilot to continuous operation. An enterprise is not prepared to admit into its production processes a system whose behavior cannot be explained, and this is a well-founded position.

Why Classical Monitoring Is Not Enough

Established engineering practice for observing distributed systems relies on four "golden signals": latency, traffic, errors, and saturation [5]. For agentic systems these indicators remain necessary but cease to be sufficient, for several reasons.

A failure does not look like a failure. An agent that has misunderstood the task returns a correctly formed answer without any error code. From the infrastructure's point of view, the request was completed successfully.

Behavior is non-deterministic. The same request with the same data can take different paths. It is not always possible to reproduce a problem by running it again. Anthropic's engineers, describing their experience of operating their own multi-agent system, note that this makes debugging substantially harder than with conventional software [4].

Errors compound. Agents maintain state across many steps, so a minor deviation at the beginning changes the entire subsequent trajectory. What would be a local fault in a conventional program turns here into a systematic deviation from the goal [4].

Cause and manifestation are spread across agents. The incorrect result is produced by one agent, while the cause is an incomplete assignment received from another.

Hence the main difference: in agentic systems the object of observation is not only the state of the infrastructure but also the quality of decisions.

Three Levels of Observability

Based on deployment experience, we divide observation tools into three levels, each of which answers its own set of questions.

LevelWhat is recordedWhich questions it answers
TracingThe full chain of steps: calls to models and tools, handovers between agents, the input and output data of each stepWhat exactly happened? Which agent received what, and what did it return?
MetricsExecution time, token consumption, the number of steps and tool calls, the share of technical errors, the cost of a taskHas the system's behavior changed? Where are the bottlenecks and cost overruns?
Quality evaluationConformity of the result to the task, completeness, factual accuracy, compliance with constraintsIs the result correct? Is quality degrading over time?

Tracing is the foundation for everything else. Without a record of the full trajectory, no further analysis is possible. It is worth noting here the emergence of an industry standard: the OpenTelemetry project is developing semantic conventions for generative AI that unify the description of model calls, agent operations, and tool execution [3]. For an enterprise this means the ability to collect data on agent operation with the same tools used for the rest of its IT systems, and not to depend on the format of an individual vendor.

Metrics in agentic systems have their own specifics. In our practice, the most telling are not absolute values but deviations from the usual profile: a sharp rise in the number of steps per task, repeated calls to the same tool with the same parameters, an increase in token consumption with no change in the type of requests. Such signs usually point to looping, or to the agent being unable to obtain the data it needs and trying to compensate with repeated attempts.

Quality evaluation is a level that classical monitoring does not have at all. It involves regular review of a sample of real results: automated, using a separate evaluator model with clear criteria, and human, to calibrate the automated one. We examined approaches to constructing such criteria in detail in the article on evaluating the quality of AI agents.

Failure Classification as the Basis of Diagnostics

Diagnostics begins with the language in which problems are described. Without a shared classification, every incident is investigated as a unique one, and patterns go unnoticed.

The most thorough taxonomy was proposed by researchers at the University of California, Berkeley. Based on an analysis of more than 1,600 annotated traces from seven multi-agent frameworks, they identified 14 failure types in three categories: system design issues, inter-agent misalignment, and task verification and termination [1]. Typical examples include an agent overstepping the boundaries of its role, loss of conversation context, ignoring data received from another agent, premature termination of work, and perfunctory verification of the result.

The practical value of such a classification is that each category has its own means of remediation. Problems of the first category are corrected by changing roles and instructions. Problems of the second, by changing the format of exchange between agents. Problems of the third, by adding independent verification. If incidents are not classified, however, the typical reaction becomes replacing the model with a more powerful one, which, according to the authors' conclusions, does not eliminate a significant share of such failures [1].

Who Is to Blame: The Failure Attribution Problem

The most difficult diagnostic task is establishing exactly which agent caused the failure and at which step. Intuitively it seems that this could be delegated to the language model itself: give it the trace and ask. Research shows that such automation is still far from reliable.

The authors of a paper presented at the ICML 2025 conference assembled a set of failure logs from 127 multi-agent systems with manual annotation of the responsible agent and the decisive step. The best of the automated methods correctly identified the agent at fault in 53.5% of cases, and the specific step in only 14.2% [2].

In practical terms this means that fully automated incident investigation is not possible today. Automated tools are useful for the preliminary selection of suspicious traces and for narrowing the search, but the final conclusion is made by a specialist. Accordingly, the observation system must be designed so that a person can walk through the trajectory quickly: see what each agent knew at the moment a decision was made, and compare it with what the agent should have known.

Methods That Work in Practice

Summarizing the experience of our own projects and published practices [4], I will single out the approaches that deliver the greatest effect.

Checkpoints between agents. At the boundaries where work is handed over, the result is checked for formal completeness and conformity to the expected format. This turns a hidden failure into an explicit one and localizes it where it arose.

A regression task set. A fixed list of typical and problematic requests against which the system is checked after every change to instructions, tools, or the model. Every investigated incident adds to this set.

Trajectory comparison. Successful and failed executions of tasks of the same type are compared with one another: at which step they diverge. This often leads to the cause faster than analyzing a single failed trace.

Budget limits. Threshold values for the number of steps, time, and cost per task. Exceeding them is both a protective mechanism and a diagnostic signal.

Observing patterns without viewing content. Analyzing the structure of interactions (who called whom, how many times, with what result) makes it possible to detect anomalies without exposing the content of user requests. This is essential for systems that work with confidential data [4].

Gradual rollout of changes. Since agents may perform long-running tasks, replacing the version for all requests at once creates a risk of failure in the middle of execution. The new version is brought into operation gradually, in parallel with the old one [4].

The Regulatory Dimension

Logging the operation of AI systems is ceasing to be merely an engineering practice. The EU Artificial Intelligence Act requires that high-risk systems technically allow for the automatic recording of events throughout their entire lifecycle, and that providers of such systems establish post-market monitoring [7]. The AI Risk Management Framework developed by NIST singles out the measurement and continuous tracking of system behavior as separate functions alongside the governance and mapping of risks [6].

For industrial enterprises that operate in the EU market or plan to enter it, a practical conclusion follows: it is advisable to design observation tools from the outset with regard to the requirements for log retention, integrity, and availability, rather than adding them after the first audit findings. We examined the broader context in the article on the responsible use of AI in the enterprise.

Author's Assessment and Conclusions

Observability is a condition of operation, not an additional feature. An agentic system without full tracing can be neither improved nor used responsibly. I believe that observation tools should appear in a project earlier than the second agent.

Technical health does not equal correctness. Monitoring that is limited to response time and error rate creates a false sense of control. Evaluation of the quality of results must be a continuous process with a designated owner.

Classifying incidents is more valuable than eliminating them one by one. A shared failure taxonomy makes it possible to see patterns and direct effort to where it produces a systemic effect [1].

Automated diagnostics cannot yet be trusted with the final conclusion. The research data is unambiguous: even the best methods err in identifying the cause of a failure more often than is acceptable in practice [2]. The role of the specialist in an investigation remains decisive.

Logging requirements should be taken into account in advance. Regulatory expectations regarding the traceability of AI system decisions are growing, and it is cheaper to build them into the architecture than to implement them retroactively [6][7].

The complexity of multi-agent systems is not in itself an obstacle to industrial use. The obstacle is opacity. An enterprise can entrust agents with critical tasks to the extent that it is able to see and explain what exactly they are doing.

References

  1. Cemri M., Pan M. Z., Yang S. et al. "Why Do Multi-Agent LLM Systems Fail?" arXiv:2503.13657, 2025. https://arxiv.org/abs/2503.13657
  2. Zhang S., Yin M., Zhang J. et al. "Which Agent Causes Task Failures and When? On Automated Failure Attribution of LLM Multi-Agent Systems." arXiv:2505.00212, 2025. https://arxiv.org/abs/2505.00212
  3. OpenTelemetry. "Semantic Conventions for Generative AI Systems." https://opentelemetry.io/docs/specs/semconv/gen-ai/
  4. Anthropic. "How We Built Our Multi-Agent Research System." 2025. https://www.anthropic.com/engineering/multi-agent-research-system
  5. Beyer B., Jones C., Petoff J., Murphy N. R. (eds.). "Site Reliability Engineering: Monitoring Distributed Systems." Google, 2016. https://sre.google/sre-book/monitoring-distributed-systems/
  6. NIST. "Artificial Intelligence Risk Management Framework (AI RMF 1.0)." 2023. https://www.nist.gov/itl/ai-risk-management-framework
  7. European Parliament and Council. "Regulation (EU) 2024/1689 (Artificial Intelligence Act)." 2024. https://eur-lex.europa.eu/eli/reg/2024/1689/oj
multi-agent systemsai monitoringproduction monitoringerror diagnosticsobservabilityagent tracingopentelemetryai agentsai agent evaluationllm agentseu ai actai safety

AQTeck solutions on this topic

We design and implement these systems at industrial enterprises in Ukraine and the EU.

Related Articles

Need a consultation?

Contact us for a free consultation.