Agents That Self Improve While You Sleep

Fuad Ali, Arize AI53:05 · Oct 2026 · 6,710 views
Thumbnail for Agents That Self Improve While You Sleep Watch on YouTube
TL;DR
  1. 1

    A self-improvement loop connects traces, Signal issue detection, datasets, evals, experiments, and human review.

  2. 2

    Production failures should become living regression fixtures that grow as agents encounter new failure modes.

  3. 3

    Humans should focus on eval design, dataset curation, fix review, and low-confidence cases instead of reading every trace.

Summary

Fuad Ali presents a workflow for improving agents from evidence gathered in production. The process starts with tracing agent behavior, then uses Signal, an always-on agent, to read traces, cluster repeated failures, deduplicate issues, inspect source code, and propose fixes. Failures can become dataset entries and regression evals. Experiments replay those cases against a proposed version and check that the fix works without breaking other behavior. Ali keeps people involved where judgment matters: deciding what belongs in a dataset, defining what good output means, reviewing evals, and approving code changes. The workshop uses a toy-shopping agent with a casing bug that causes redundant searches and high latency. In the questions, Ali explains why qualitative evals need many examples, annotations, and user-session signals, and why production sampling and development checks should be balanced against evaluation cost.

Key ideas
06:00

Tracing gives the team evidence about how an agent fails

Ali starts the maturity curve with tracing. A trace shows the full interaction path, including model calls, tool calls, inputs, results, latency, token counts, metadata, and the stage of the agent graph. In the Wonder Toys demo, a request such as "Show me toys for 9-year-olds" passes through the agent, a model, and product-search tools. Arize's instrumentation creates spans for tool calls and model calls, and groups multiple exchanges into sessions. This evidence is useful for debugging, but Ali says a person cannot read thousands of traces, especially at 4:00 a.m. The next step is to let an agent inspect that evidence.

07:42

The improvement loop turns production evidence into tested fixes

Ali describes the loop as trace, Signal, eval, experiment, and fix. Signal reads traces, creates a dataset from failures, proposes an eval, and can prepare a code change. The team then reviews the fix, decides whether to merge it, and feeds the result back into the system. Each stage adds context for future failures. This lets a team move away from humans reading every trace while keeping human decisions at the points where judgment matters. The loop also connects reliability work with future product changes, since new features create new traces, failure cases, and regression checks.

12:15

Signal groups repeated failures and can investigate their cause

Signal is an always-on agent that reads a project's traces on a schedule, with a default interval of every six hours. It clusters related issues and keeps one ticket per problem instead of creating many reports from the same evidence. In the demo, a planted bug causes redundant product-search retries. Signal sees repeated searches, three sequential model calls, and high latency. It examines the traces and source repository, then finds that product categories use lowercase hyphenated slugs while the filter passes title-case names with spaces. The mismatch produces no results, so the agent searches again. Signal can connect to GitHub to open an issue or propose a pull request.

18:31

Failed cases become living fixtures for regression testing

Ali describes adding a failure case to a dataset as one of the most important parts of continuous improvement. A dataset records what failed and protects against the same failure returning later. Unlike a fixed test suite created once, a living fixture grows as the agent encounters new use cases and failure modes in production. In the demo, the redundant-search examples can be saved as regression cases. The team can then run the agent against those cases after a code or prompt change. This gives the system a growing definition of failure based on actual behavior rather than a single snapshot of what the team expected at the beginning.

20:32

Different eval types trade precision, flexibility, and cost

Ali separates evaluators into several types. Code checks handle deterministic rules such as valid JSON, required fields, correct filter application, and correct tool arguments. An LLM judge handles qualitative or less precise questions, though it adds another model call and should usually use sampling rather than run on every trace. An agent judge can decide its own criteria for more open-ended goals, but it costs more. Decision models provide typed outputs such as yes, no, or a score at lower cost than a classic LLM. The right choice depends on what the team needs to measure and how much evaluation spend the use case can support.

24:48

An issue can generate an eval that watches for the same failure

From the Signal issue, Ali creates an evaluator with one click. The generated check inspects the complete trajectory and looks for redundant product-search retries. It returns a classification when the search tool is called more than once, then attaches the score and classification to the trace. The team can run that evaluator on incoming traces, graph its results, create alerts, and track its cost. Over time, the check may move into development as a regression test. If it becomes unnecessary or too expensive to run on production traffic, the team can retire it. The issue therefore becomes both a code change and a reusable test.

27:09

Experiments test the proposed fix against old failures and other checks

After a fix is proposed, the team needs evidence that it works and has not caused a new problem. An experiment reruns the agent on the living fixture, scores the results with the relevant evals, and compares them with a threshold chosen by the team. In Ali's example, a score of 88.9% was enough for him to accept the result. The experiment also checks other evals so that a prompt or tool change does not fix one path while breaking another. These tests can run through the AX CLI or inside CI/CD, but Ali warns that model choice, sampling rate, and experiment frequency affect cost.

31:12

Humans should decide what counts as good evidence and a safe fix

Ali leaves several decisions with people. Someone should decide whether a Signal finding is real, whether a failure belongs in the dataset, what the desired behavior means, and whether a proposed pull request should merge. In high-stakes settings, a person may need to read every PR. Annotations on experiment outputs let reviewers record their judgment and give the next run more context. Decision models can also return confidence scores, allowing low-confidence cases to go into a human annotation queue. Ali does not recommend a universal confidence threshold. The right threshold depends on the use case and the cost of missing a failure.

"The flow generally goes trace signal, which is our out-of-the-box kind of SRE agent, which I'll show you guys in the platform."07:42
Who should watch
  • You are operating agents in production and need a way to turn recurring failures into regression tests.
  • Your team has traces and evals but still spends too much time reviewing raw agent sessions.
  • You need to design an improvement workflow that uses coding agents while retaining human approval for datasets, evals, and fixes.