Most teams running agents in production can tell you exactly what went wrong last Tuesday. They have the trace in LangSmith or Langfuse, with every tool call and every token, timestamped. What they usually can’t tell you is why the agent made the same mistake again this Tuesday.
We built agentRTX for that second problem. This post covers how it works, where Anthropic’s idea of agent “dreaming” fits in, and what it did to our τ-bench numbers.
What observability tools actually store
A trace is a log of one run: the prompt, each tool call, what came back, the final answer. Collect enough of them and you have a detailed diary of everything your agents have ever done.
In memory terms, that diary is episodic memory, the kind that records specific events in the order they happened. People have it too. You can probably remember your first day at your job in some detail, but that isn’t the memory you use to do the job. For that you rely on procedural memory, the know-how you’ve built up and apply without replaying every day that taught it to you.
Agents today mostly have the diary and not the know-how. Nobody pastes a few hundred old transcripts into the prompt before each task (it would cost a fortune and bury the parts that matter), so the diary stays in a dashboard and the agent goes into every task cold.
How agentRTX turns traces into procedural memory
agentRTX reads each run alongside how it turned out. The outcome can be an eval score, a reviewer’s thumbs-down, or a signal from your own systems, like a support ticket reopened two days later. From that pair it writes a lesson a few lines long. For a support agent that refunded the same charge twice, the lesson might read:
Duplicate charge reported: check settlement status before refunding. A previous run refunded a charge that had already been reversed, and the customer was credited twice.
Each lesson also carries a utility score. If the agent used the lesson and the run passed, the score goes up; if the run failed, it goes down. When a new task arrives, lessons are ranked by a mix of how relevant they are and that score:
score = (1 − λ) × similarity + λ × utility
With λ at zero you get plain semantic search. Turn it up and the ranking leans on what has worked before. In practice, advice that sounded right but kept leading to failed runs drops out of view after a handful of runs, without anyone having to find it and delete it.
Corrections from people count for the most. When a manager rewrites a draft, or an approver rejects an action, we know which step was wrong and what right looked like. Those lessons start with more weight than ones inferred from a pass or fail score.
Dreaming: consolidating agent memory offline
Writing lessons one run at a time only gets you part of the way. You end up with near-duplicates, lessons that contradict each other, and patterns that only show up across dozens of runs. So agentRTX also runs a consolidation pass in the background, between sessions.
Anthropic calls this dreaming, after the way sleep turns a day’s experiences into long-term memory, and wrote it up well earlier this month. In their tests, a wiki maintained by the agent went from 13% to 48% of graded criteria over 128 dreaming sessions. Their summary of the job is hard to improve on: “Dreaming gives Claude a way to test its notes against the original transcripts”. (Anthropic on the components of agent memory.)
Their post is about the agent’s own notes. Our consolidation pass writes to three places.
The first is skills. If reviewers keep correcting the same step of the same task, that fix shouldn’t depend on retrieval happening to surface it. It belongs in the skill itself, as a written step that every run follows and that a person can read.
Then the knowledge base. A surprising share of corrections are about facts rather than process: a price went up, a policy changed, the contact for a supplier moved teams. Fixing those in the shared knowledge base means every agent gets the update, including the ones that never made the mistake.
And finally the model. Graded runs with corrections attached are good training data, so you can fine-tune or distill a smaller open-weight model on your own tasks. The benchmark below is a fair illustration of why that’s worth doing.
There’s a real risk here, and Anthropic names it: a wrong note gets trusted by every later session that reads it. Utility scoring catches part of that, since a bad lesson keeps turning up in failed runs and its score falls. For skills and the knowledge base we’d go further and have a person approve the change, because those reach every agent at once.
τ-bench results
τ-bench (also written TAU-Bench) tests customer service agents over multi-turn conversations. They have to use tools, follow company policy and deal with simulated customers. We compared a frontier model with no runtime memory against GLM, an open-weight model, running with agentRTX.
| Setup | Success rate | Cost per run |
|---|---|---|
| Frontier model, no runtime memory | 56% | $180 |
| GLM (open weights) with agentRTX | 80% | $10 |
On paper GLM is the weaker model. It finished 24 points ahead, at roughly 1/18th of the cost per run, because it started each task with lessons from the ones before.
We also followed a longer stretch of six months of production-style runs:
| Static agent | With agentRTX | |
|---|---|---|
| First-attempt success | 56%, flat | 77% |
| Same mistake repeated on a similar task | 38% | 12% |
| Tasks escalated to a person | Baseline | 41% fewer |
We pay the most attention to the middle row. Once an agent has been corrected on something, watching it make that mistake again is what makes people stop trusting it.
Using agentRTX with your existing stack
You don’t have to replace anything. agentRTX reads from the tracing you already run (LangSmith, Langfuse or OpenTelemetry) and takes outcomes from whatever grades your runs. It comes as a Python SDK and a REST API, hosted by us or self-hosted. If you already optimize prompts with DSPy, keep doing it: DSPy improves the agent’s first attempt, and agentRTX looks after the ones that follow.
Inside Pulsar, it’s how a correction one person makes becomes part of the team’s memory and skills. We wrote about that side in our comparison of Pulsar, Muse and Grok Bot.
If you’d like to see it on your own traces, book a demo, or read the docs on the agentRTX site.
Frequently asked questions
What is procedural memory in AI agents?
- Procedural memory is the know-how an agent applies to new tasks, such as the right order of steps for a refund or the format a particular client expects, learned from earlier runs. Episodic memory is the record of the runs themselves, which is what traces and logs store.
How is agentRTX different from LangSmith or Langfuse?
- LangSmith and Langfuse record what your agents did. agentRTX uses those records, together with how each run turned out, to change what the agent does next time. It works alongside your tracing tool rather than replacing it.
What is agent dreaming?
- Dreaming is an offline pass in which an agent reviews its past sessions and reorganizes what it learned: merging duplicates, correcting wrong notes against the original transcripts, and keeping what proved useful. Anthropic introduced the term. agentRTX applies the same pass to skills, the knowledge base and model training.
Do I need to fine-tune a model to use agentRTX?
- No. Lessons are retrieved at the start of each task and work with any model. Fine-tuning or distilling on graded runs is optional, for teams that want a smaller, cheaper model trained on their own work.

