Source-linked AI summary
Observability and Fault Injection for LLM-Based Multi-Agent Systems in Software Engineering
Zahra Seyedghorban, Egor Klimov, Arie van Deursen, Annibale Panichella, Burcu Kulahcioglu Ozkan
TL;DR
LLM-based multi-agent systems are difficult to inspect, debug, and evaluate under controlled failures because their distributed, stochastic executions can diverge across runs. llmmas-otel combines framework-agnostic distributed tracing with targeted fault injection around existing workflows. Initial validation on a minimal workflow and ChatDev shows measurable slowdown, including higher amplification for communication delays and substantially larger effects in the richer system.
Problem
Distributed, stochastic LLM-based multi-agent workflows lack reusable ways to capture comparable executions and study controlled faults across agents, communications, tools, and model calls.
Method
llmmas-otel wraps existing workflows with trace-aligned instrumentation and configurable fault injection at selected interaction boundaries.
Results
Initial validation found demo amplification of 1.295 mean for a2a.delay versus 1.053 for llm.delay, while ChatDev reached 59.2 mean for inter-agent delay versus 48.1 for LLM delay.
Takeaways & Limitations
Aligned baseline and faulty traces provide a practical foundation for controlled stress testing and systematic inspection of multi-agent workflow effects.
Takeaways & Limitations
The current implementation supports three runtime boundaries and does not yet provide paired-run differencing, trace summarization, root-cause ranking, or automated debugging reports.
Abstract
from arXiv · showhide
Large Language Model-based multi-agent systems are increasingly explored for software engineering tasks, but they remain difficult to inspect, debug, and evaluate under controlled failures. We present llmmas-otel, a lightweight and framework-agnostic tool that combines OpenTelemetry-based distributed tracing with fault injection for LLM-based multi-agent systems in software engineering workflows. The tool instruments agent executions with trace-aligned telemetry across workflow phases, agent steps, inter-agent communication, tool calls, and LLM invocations, and supports targeted fault injection at selected interaction points. This makes it possible to compare baseline and faulty executions in a reproducible way and inspect the effects through aligned traces and run artifacts. We describe the motivation, architecture, implementation, current capabilities, and initial validation of the tool on a minimal demo workflow and a real LLM-based multi-agent system for software development.
I. INTRODUCTION
LLM-based multi-agent systems support complex software engineering workflows but remain stochastic, failure-prone, and difficult to inspect or compare under controlled failures. llmmas-otel addresses this gap with framework-agnostic observability and fault injection aligned to shared execution boundaries.
- LLM-based multi-agent systems distribute software engineering work across specialized agents that communicate, coordinate, and use external tools.
- Failures can originate early in a workflow, including missed constraints, weak handoffs, tool errors, or misleading model responses.
- Stochastic multi-step executions make simple logs and final success rates insufficient for principled comparison of normal and faulty runs.
- llmmas-otel provides structured, comparable execution capture and controlled fault injection across workflow phases, agents, tool calls, and LLM calls.
- The tool wraps existing LLM-based multi-agent systems with limited code changes instead of replacing their orchestration framework.
- The paper describes a consistent trace model and initial validation on both a minimal demo workflow and a real LLM-based multi-agent system.
A. Overview
llmmas-otel wraps an existing LLM-based multi-agent workflow, optionally perturbs configured boundaries, and exports aligned artifacts for baseline and faulty-run analysis. The Planner→Coder demo illustrates this process through planning, handoff, and coding phases.
- llmmas-otel observes and perturbs existing LLM-based multi-agent systems without replacing their task-execution workflow.
- The tool accepts an existing system, a task, and an optional fault specification, then produces structured traces and optional message records.
- Users mark selected workflow boundaries, run an unperturbed baseline, and optionally re-execute the same task with configured faults for an aligned faulty run.
- The demo sends a Planner-generated implementation plan to a Coder, with one LLM call in each agent’s phase.
B. Observability Layer
The observability layer represents multi-agent executions as consistent, queryable traces spanning sessions, phases, agent steps, model calls, and communication events. Lightweight instrumentation preserves the host workflow while making handoffs explicit and comparable.
- Consistent span attributes provide stable semantic names and meanings, enabling systematic comparison and querying across runs and workflows.
- The trace hierarchy records a session, phase segment, agent step, LLM call, and Planner-to-Coder communication spans in the running example.
- Thin decorators and context managers let users annotate a few boundaries while lower layers create spans, propagate context, and export telemetry.
- The public API stays close to the host workflow rather than forcing users into a new orchestration model.
- Explicit send and receive tracing preserves communication context and records relationships between inter-agent events.
C. Fault Injection Layer
The fault injection layer applies configurable perturbations at the same runtime boundaries used for tracing, while preserving the shared execution structure. This alignment supports targeted stress testing and inspection of downstream effects.
- Configured rules can inject actions at LLM calls, tool invocations, A2A sends, and A2A receives without modifying core workflow logic.
- Fault specifications target boundary types and execution metadata such as phase, agent, source and target agents, or message channel.
- Injected faults remain represented by the same operational span types, with fault-specific attributes and events recording the perturbation and triggering rule.
- A delayed Planner-to-Coder handoff retains the baseline a2a_send span position while adding fault metadata before message continuation.
- Observability and fault injection together support questions about sensitive boundaries, localized versus cascading effects, and workflow robustness.
III. VALIDATION
The validation applies controlled delay faults to a minimal Planner→Coder workflow and ChatDev, showing measurable slowdown in both settings and much larger amplification in the richer system.
- Experimental setup: The study compares fault-free runs with 1000 ms delays at the first planning LLM call and at the Planner→Coder handoff across two target systems.Each benchmark task is executed five times per condition using the 30-task ProgramDev benchmark.
- Minimal demo workflow: The demo workflow shows mean amplification of 1.053 for the planning-phase LLM delay and 1.295 for the Planner→Coder handoff delay.The corresponding medians are 1.036 and 1.390, respectively.
- ChatDev validation: ChatDev includes design, coding, and testing phases with multiple collaborating agents communicating through language-based messages.It serves as a richer validation target than the minimal demo while remaining focused on software engineering.
- ChatDev validation: ChatDev records mean amplification of 48.1 for a single LLM delay and 59.2 for an inter-agent message delay.The reported medians are 13.9 and 6.6, respectively.
- Validation outcome: The tracing-and-injection setup makes runtime amplification from localized delays visible and quantifiable in a trace-aligned manner.The reported effects are especially pronounced in the multi-phase, message-heavy ChatDev workflow.
IV. RELATED WORK
Related work provides failure taxonomies, attribution methods, and observability proposals, but the paper identifies a gap in lightweight infrastructure combining these capabilities for controlled experiments on existing LLM-MAS.
- Failure understanding: MAST and AgentFail classify failures across specification, coordination, verification, agent, workflow, and platform levels.AgentFail also releases a benchmark for diagnosis.
- Fault injection: AEGIS and AgenTracer use controlled or synthetic perturbations to generate faulty trajectories and identify decisive faulty steps.Their primary focus is dataset construction and failure attribution rather than reusable runtime engineering evaluation.
- Observability: Observability work emphasizes monitoring agent behavior and capturing lifecycle artifacts beyond final outputs.Examples include security- and reliability-relevant phenomena and telemetry across the agent lifecycle.
- Identified gap: Existing work does not couple observability with controlled perturbation as a reusable runtime tool for existing LLM-based multi-agent systems.The paper positions llmmas-otel as infrastructure for repeatable baseline and fault-injected executions.
- Paper positioning: llmmas-otel brings together repeatable execution, a shared trace model, and inspection of fault propagation across phases, agents, and interaction boundaries.This target is especially framed around software engineering workflows.
V. LIMITATIONS AND FUTURE WORK
The current tool supports aligned tracing and runtime perturbation at several boundaries, while broader fault surfaces and higher-level automated analysis remain future work.
- Current capabilities: The current implementation injects faults at agent-to-agent communication, LLM calls, and tool calls while preserving aligned traces for baseline and injected runs.These boundaries enable controlled perturbation of important runtime interactions.
- Future fault coverage: Future work extends injection toward higher-level workflow, memory-related, and coordination faults.The paper describes these as additional fault types and broader injection surfaces.
- Analysis limitations: The current version does not provide paired-run differencing, trace summarization, root-cause ranking, or automated debugging reports.Users currently inspect traces and run artifacts directly.
- Future analysis: The next planned step is to build analysis support on top of the existing observability layer.The stated focus is higher-level analysis of the produced traces and artifacts.
VI. TOOL AVAILABILITY
llmmas-otel is publicly available on GitHub with a sample demo, ChatDev instrumentation, and detailed usage instructions.
- Availability: The public release includes a sample demo, ChatDev instrumentation, and detailed instructions.The paper directs users to GitHub for access.
VII. CONCLUSION
llmmas-otel combines structured observability with fault injection for LLM-based multi-agent software-engineering systems. Shared trace alignment supports controlled stress testing and systematic inspection of fault effects.
- llmmas-otel combines structured observability and fault injection in one lightweight, framework-agnostic tool.
- Shared trace alignment keeps baseline and injected executions comparable across multi-agent workflows.
- The tool supports controlled stress testing and systematic inspection of how faults affect multi-agent workflows.