WikiTrace Links AI Agent Lessons to Their Source to Cut Errors

A new memory system for AI agents could stop them from being tripped up by their own stored experience, according to a paper posted to arXiv by researchers at KAIST and DeepAuto.ai. The study targets what the authors call memory-induced degradation — cases where an agent that would solve a task unaided fails once it relies on lessons distilled from earlier runs — and reports that tying each lesson to its source reduces those failures.

What is memory-induced degradation?

Many AI agents now improve without being retrained. Instead of updating their parameters, they keep an external memory: a store of concise lessons distilled from the sequences of actions and observations, called trajectories, that they produced on past tasks. Those lessons let an agent skip repeated exploration and reuse procedures that worked before.

The problem, according to the paper, is that memory does not always help. An agent can end up failing a task it would have solved with no memory at all, because it follows a lesson that is wrong, or misreads or misapplies a correct one. Average accuracy hides this, the authors argue, because it blends two different effects. They measure them separately: Gain, the rate at which memory turns failures into successes, and Regression, the rate at which it turns successes into failures. Figure 1(a) illustrates the failure mode — an agent solves a task on its own but fails when memory hands it a wrong insight. By this measure, the paper reports, existing memory methods show Regression comparable to, or even higher than, simply rerunning the agent without any memory.

Why does memory make agents worse?

To understand the failures, the researchers examined tasks that an agent consistently solved without memory but failed with it. They found that 52% of those failures traced back to a memory item the agent had followed — most often an incorrect one.

The root cause is how lessons are made. A trajectory arrives with a single label: the task either succeeded or failed. That label does not reveal which of the trajectory's many actions produced the outcome. So any method that distills a lesson has to guess which steps mattered and under what conditions, and every wrong guess becomes a lesson that misleads the agent later. Compounding this, existing approaches hand the agent a lesson without the trajectory it came from, leaving it no way to check the advice — even though, the authors note, the evidence needed to catch a bad lesson often still sits in that original trajectory.

How does WikiTrace fix it?

The paper's answer is WikiTrace, an evidence-linked memory system that keeps every lesson connected to a path back to its source. It organizes memory into three linked layers. Each lesson is stored as a concise insight; that insight links down to a compilation, a short diagnosis of why its trajectory succeeded or failed; and that in turn links down to the raw trajectory itself. The design keeps both things an agent needs within reach: a lesson briefly says what to do, while the trajectory faithfully records what actually happened but is usually too long to reread for every decision.

At task time, the agent starts from all of its insights. When an insight lacks the detail needed to act, conflicts with another insight, or comes from a failed run, the agent "descends" through the links using terminal tools to recover the missing detail or revise the lesson before it acts. Figure 2 lays out the full pipeline: a compiler turns each past run into a compilation and a set of insights, all layers stay linked, and the agent descends under those specific conditions. Figure 1(b) shows the payoff — the agent follows a wrong insight's links to its source run, corrects it, and then solves the task.

How well does WikiTrace work?

The team validated the approach on five agentic benchmarks made up of eight suites, spanning simulated text worlds such as ALFWorld and ScienceWorld and tool-use environments such as AppWorld and τ³-bench. According to the paper, WikiTrace posted the best result on every suite. On average it improved over an agent with no memory by 10.7 points and beat a baseline that was given the same insights alone by 3.2 points, while cutting Regression from 6.5% to 4.5%.

The analyses add texture. The agent consulted its linked evidence more often on harder tasks, which is where its advantage was largest, and it gained the most when the evidence actually changed its plan. The improvements held when the researchers swapped in a different underlying model. The paper was submitted to the ACL Rolling Review in the October 2026 cycle and is under review, and the authors released their code on GitHub.

What does this mean for people building agents?

The practical lesson is that agent memory needs provenance. If a system is going to learn from experience, keeping each lesson tethered to the evidence behind it gives the agent a way to audit its own advice rather than trusting a summary blindly. That is a design pattern developers can adopt in agent projects of any size.

Two Grafy tools map onto this work directly. You can drop the arXiv paper into Reader to search it, question its claims and pull out the exact numbers behind the method. And if you want to build or experiment with an evidence-linked memory yourself, Grafy Code is an AI coding studio where you can implement the pattern and run your code, using the authors' released implementation as a starting point. For a broader view of the reliability problem, Grafy News has also covered FGSE's call for verifier approval before agent memory is used, a complementary take on keeping stored experience trustworthy.

Frequently asked questions

Does WikiTrace reduce memory-induced degradation?

Yes. According to the paper, WikiTrace cut Regression — the rate at which memory turns successes into failures — from 6.5% to 4.5% across the tested benchmarks, while also improving overall performance. It does this by letting the agent check each lesson against the trajectory it came from before acting, so a wrong or misread lesson can be caught and corrected rather than followed.

Why do agents fail more with memory than without it?

Because lessons are distilled from trajectories labeled only as success or failure, which does not show which actions caused the outcome. The paper found that 52% of the failures on tasks the agent otherwise solved traced to a memory item it followed, most often a wrong one. Without the source trajectory to check against, the agent had no way to catch the bad lesson before acting on it.

How does WikiTrace store and use its lessons?

Each lesson is kept as a concise insight linked to a compilation summarizing why its trajectory succeeded or failed, and to the raw trajectory itself. On a new task the agent starts from all insights and, when one lacks detail, conflicts with another, or came from a failed run, it descends those links with terminal tools to recover details or correct the lesson before acting.

---

Source: Grafy Research Lab — Don't Just Trust Your Memory: Evidence-Linked Memory Reduces Memory-Induced Degradation in LLM Agents