Your Agent Fix Just Broke Something Else - Sofia Jakovcevic, Arize AI
This talk highlights the critical shift in agent observability, moving beyond human-centric debugging to automated, self-improving AI systems. It introduces a 5-step regression loop for agents, starting from real production traces, implementing evaluators for quantitative scoring, running experiments, and integrating them into a CI/CD pipeline. The core idea is that every failure should become a test, making the agent continuously stronger and reducing the manual bottleneck in development.
read more
Sofia Jakovljevic, a Forward Deployed Engineer at Arize, presents a live demo on Agent Observability & Experimentation, emphasizing how an agent fix can inadvertently break other functionalities. Arize aims to make AI work by providing an observability backend that sheds light into the often-opaque nature of AI agents, which can be challenging to understand, predict, and debug.
Building AI systems, especially those with abstracted low-level programming managed by an agent, can be intuitive. However, this abstraction can lead to a 'black box' problem, making it difficult to understand and debug agent behavior. Observability is crucial here, allowing developers to understand step-by-step what their systems are doing, evaluate performance with metrics, and iterate for improvement.
The talk focuses on transforming agent observability into a robust regression loop that automatically tests every agent change before deployment. This proactive approach aims to prevent fixes from breaking other parts of the system. The presentation is structured into three parts:
1. Agents fail at runtime: Unlike traditional software where code changes have local effects, AI agent changes can reshape the entire execution path at runtime. A small, one-line policy edit can have widespread behavioral consequences that aren't apparent from static code review. The diff tells you what changed, but the trace tells you what it did. Production behavior, captured through traces, becomes the new source of truth for understanding how agents operate, especially in detecting silent failures—issues that only emerge during runtime and are difficult to anticipate or debug through code alone.
2. Build the regression loop: This is a 5-step process designed to move from production traces to a gate in CI/CD: Step 1: Select a dataset. Pull real inputs, tool calls, and outcomes directly from production traces. This dataset should include common workflows (representative behavior), known failures, edge cases, and crucially, successful workflows that must be protected from regression. Production behavior effectively becomes the regression suite. Step 2: Add evaluators. To move beyond 'coding on vibes' and gain quantitative insights, evaluators are used to score different dimensions of agent performance. These can include LLM-as-a-judge evaluators for subjective metrics like hallucination or factual correctness, and code-based evaluators for deterministic checks (e.g., valid tool arguments, adherence to schemas). The goal is to convert subjective qualities into numeric scores (e.g., 0-1 or 0-5), providing quantifiable metrics for task completion, action safety, and other critical dimensions. Step 3: Run the baseline experiment. The current agent is run against the selected dataset with no changes, establishing a baseline performance across all defined evaluators. This provides a control against which all future candidate changes will be compared. Arize's SDK allows for easy experiment execution, passing in the dataset, agent, and evaluators. Step 4: Make one change and rerun. Developers can now make a specific change (e.g., adjust a prompt, swap a model, modify a tool, or update a policy) and rerun the exact same experiment. The iterative process of adjust, rerun, compare allows developers to understand the impact of changes and make informed trade-offs based on the quantitative scores. This can be done for multiple changes or models, with all results tracked in Arize. * Step 5: Put the experiment in CI. The entire regression experiment is automated and integrated into the CI/CD pipeline (e.g., GitHub Actions). Every prompt, model, tool, or skill change automatically runs against the regression dataset and evaluators before it merges. Regression criteria are set on each critical dimension (e.g., 'No drop over 0.02 vs. baseline' for task completion, 'Stay at or above 0.95' for action safety). The PR will not merge until it meets these criteria. This ensures that every deployment maintains or improves performance across key metrics, fostering confidence in deployment.
3. Closing the loop at agent speed: The ultimate vision is a paradigm shift where agents themselves close the loop. Currently, human engineers are the bottleneck, manually investigating dashboards, triaging issues, and shipping fixes. The future of observability moves from helping humans debug agents to giving agents the feedback loop to continuously improve themselves. Agents will read production traces directly, self-correct, and turn failures into improvement evidence. This signifies a move towards self-improving and accountable agents that can see, evaluate, and improve their own behavior without constant human intervention.