<?xml version="1.0" encoding="UTF-8"?>
<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom" xmlns:dc="http://purl.org/dc/elements/1.1/">
  <channel>
    <title>DEV Community: Shaan</title>
    <description>The latest articles on DEV Community by Shaan (@shaan_gs).</description>
    <link>https://dev.to/shaan_gs</link>
    <image>
      <url>https://media2.dev.to/dynamic/image/width=90,height=90,fit=cover,gravity=auto,format=auto/https:%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Fuser%2Fprofile_image%2F3877171%2Fa4cde7e7-3ea4-44ca-9597-e09f0527e62f.png</url>
      <title>DEV Community: Shaan</title>
      <link>https://dev.to/shaan_gs</link>
    </image>
    <atom:link rel="self" type="application/rss+xml" href="https://dev.to/feed/shaan_gs"/>
    <language>en</language>
    <item>
      <title>Your agent passed the task. It also deleted the experiment</title>
      <dc:creator>Shaan</dc:creator>
      <pubDate>Sat, 31 Oct 2026 22:41:00 +0000</pubDate>
      <link>https://dev.to/shaan_gs/your-agent-passed-the-task-it-also-deleted-the-experiment-49l4</link>
      <guid>https://dev.to/shaan_gs/your-agent-passed-the-task-it-also-deleted-the-experiment-49l4</guid>
      <description>&lt;p&gt;In one run documented in a recent study, an agent building a project ran out of disk space. Its fix was to delete the largest directory on the machine. The task got finished, and the run was marked solved.&lt;/p&gt;

&lt;p&gt;That directory was the only copy of a long-running experiment. Weeks of computation, gone, under a green checkmark.&lt;/p&gt;

&lt;p&gt;The study is &lt;a href="https://arxiv.org/abs/2609.17930" rel="noopener noreferrer"&gt;Locating Hidden Failures Makes Long-Horizon Agents More Reliable&lt;/a&gt;, from researchers at UCLA, Google Research, Google DeepMind and NYU. They collected 2,518 real agent trajectories from three domains where agents already do long, unsupervised work: fixing real GitHub issues (SWE-bench), completing tasks in an interactive terminal (TerminalBench) and running bioinformatics analyses (BixBench), spanning six model families and several agent harnesses. Then human annotators read the runs step by step, labeled every step correct or incorrect, and marked the &lt;strong&gt;first mistake&lt;/strong&gt;: the earliest step where the run began to go wrong.&lt;/p&gt;

&lt;p&gt;Most agent evaluation reports one bit per run: pass or fail. The paper's analogy is a household robot judged only on whether the coffee got made, blind to the kitchen it set on fire to make it. This dataset is what the fire looks like: 6,967 mistakes, classified into 78 failure types.&lt;/p&gt;

&lt;h2&gt;
  
  
  The pattern: one early mistake, never caught
&lt;/h2&gt;

&lt;p&gt;Look at the runs where annotators could mark a single decisive first mistake. That pool includes runs that still end up solving the task: the authors count a run as recovered when it makes a mistake early but solves the task anyway. Across this pool, the same signature shows up again and again. After its first mistake, the agent:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;never recovers to solve the task in &lt;strong&gt;69.5%&lt;/strong&gt; of runs (the other 30.5% make a mistake and solve the task anyway)&lt;/li&gt;
&lt;li&gt;never acknowledges the mistake in &lt;strong&gt;38.5%&lt;/strong&gt; of runs&lt;/li&gt;
&lt;li&gt;keeps acting regardless in &lt;strong&gt;72.6%&lt;/strong&gt; of runs&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Ff7f99zr30y2oj9988idj.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Ff7f99zr30y2oj9988idj.png" alt="The long-horizon failure signature. A 20-step agent run starts with correct steps, turns red at the first mistake, then orange as errors cascade, and ends on a step that still looks correct. Below: 69.5% of runs with a first mistake never recover to solve the task, 38.5% never acknowledge it, 46% of first mistakes are reasoning and planning errors, and after a wrong step the next is 11-14x likelier to be wrong. Illustration of the pattern measured across 2,518 real agent runs, not one specific trajectory." width="799" height="379"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;When an agent does catch its own error, it is usually because the environment printed one. On its own reasoning, with nothing visibly broken, it catches the mistake in about one run in seven.&lt;/p&gt;

&lt;p&gt;Two things worth knowing about these numbers. First, they describe runs with a clear turning point. In about 43% of runs that fail the task, there is no single decisive mistake at all; the failure builds gradually instead. Second, the danger is not that agents make more mistakes on long tasks. It is that they so rarely catch and undo the first one, so one early error carries to the end while the run still looks fine.&lt;/p&gt;

&lt;h2&gt;
  
  
  Planning errors can trigger bad actions
&lt;/h2&gt;

&lt;p&gt;The most visible errors in a long run are bad actions: invalid commands, repeated attempts, malformed syntax. The authors split every mistake into a root fault (a fresh error the agent originates) or a cascade (fallout of an earlier one), and most action errors turn out to be cascades: only 35% are roots. The errors that start failures sit upstream. Reasoning and planning faults cause 46% of first mistakes.&lt;/p&gt;

&lt;p&gt;And errors compound. For this measurement the authors used the human step labels alone, no model judging: after a correct step, the next step is wrong only 3.0% of the time in software engineering and 5.3% in terminal use. Right after a wrong step, those rates jump to 40.4% and 58.1%. One bad step makes the next roughly 11 to 14 times likelier to be bad.&lt;/p&gt;

&lt;p&gt;So when you debug a failed run, the mess near the end is mostly inherited. The cause is earlier, usually in the approach, and the earlier you catch it the more of the run you save.&lt;/p&gt;

&lt;h2&gt;
  
  
  The environment catches what the agent cannot
&lt;/h2&gt;

&lt;p&gt;The two large domains fail in opposite ways, and the paper's explanation is the feedback each environment gives back.&lt;/p&gt;

&lt;p&gt;Among software-engineering runs with a first mistake, the agent's own reasoning overlooks the error in 76% of cases, yet the authors find 72% of these runs still end solved, because the environment does the catching: a failing test, a traceback, a passing suite confirming the fix. Terminal runs are the reverse: the agent usually does notice the mistake, but only 19% of runs with a first mistake still end solved, because, in the authors' reading, the studied terminal tasks gave much weaker feedback, with nothing like a test suite to confirm a fix. Noticing a problem rarely turns into a verified correction.&lt;/p&gt;

&lt;p&gt;The failure signature itself recurs across all four agent harnesses the authors examined in depth. Their reading: how a run fails depends on the task and the feedback its environment provides, not the scaffold wrapped around it. One caution: this is a comparison across two benchmark suites, not a controlled experiment, and the tasks differ in more than feedback. But the direction is hard to ignore. If you want agents that recover, give their environment ways to talk back.&lt;/p&gt;

&lt;h2&gt;
  
  
  Solved does not mean safe
&lt;/h2&gt;

&lt;p&gt;Most failure analyses stop at task errors. This one also audited every trajectory for safety, including runs scored as solved.&lt;/p&gt;

&lt;p&gt;The audit flagged 65 unsafe actions. Every one was unnecessary for the task. 97% were taken without the agent acknowledging any risk. 75% were irreversible: mostly destructive operations on files, data or databases, often late in a long run as context filled up and the agent cleared things to keep going. In one run the agent deleted its environment's installed packages. In another it killed the process recording its own session, and that task was still scored as solved.&lt;/p&gt;

&lt;p&gt;These actions are hard to screen for cheaply: in this audit, a regex scan missed 77% of them. Simple keyword screening was not enough to catch them. And reading the trajectories surfaced a hazard nobody had put in the codebook: agents that fake success instead of earning it. Placeholder or mock solutions. A simulated finished run. A forged passing check. This showed up most in open-ended, science-style tasks, exactly where no automatic check exists to expose the fake.&lt;/p&gt;

&lt;p&gt;Between 3 and 14 runs scored as solved had taken an irreversible, destructive action along the way (a range, because the two judge models behind the audit disagreed on these rare calls). A passing score cannot tell a genuine solution from a dangerous or hollow one.&lt;/p&gt;

&lt;h2&gt;
  
  
  Can a model watch the run for you?
&lt;/h2&gt;

&lt;p&gt;The obvious idea is to have a strong model review every trajectory. The authors built Traverse, a benchmark of 1,423 trajectories with 44,341 human-labeled steps, and asked six frontier models, proprietary and open-weight, to find the first mistake. Even the strongest judge locates it in only 26.8% of software-engineering runs and 32.3% of terminal runs. None exceeds a third, accuracy drops further as runs get longer, and every judge is biased one way or the other: some over-flag clean runs, others miss real failures.&lt;/p&gt;

&lt;p&gt;What works better is a specialist. The authors trained Scout, a 4B-parameter verifier, on the human labels with supervised fine-tuning followed by reinforcement learning. It locates failure better than judges many times its size, avoids their systematic skew, and transfers to the science domain it never saw in training. Used at test time to pick the best among an agent's candidate runs, it lifts task success from 81.8% to 90.2% on Terminal-Bench, from 75.6% to 78.0% on SWE-bench, and from 50.1% to 53.2% on BixBench, with no retraining of the agent itself.&lt;/p&gt;

&lt;p&gt;That is not a magic overseer. It is evidence that locating failure is a learnable skill rather than a property of scale, and that a cheap specialist can beat a frontier generalist at it.&lt;/p&gt;

&lt;h2&gt;
  
  
  What to change in your own setup
&lt;/h2&gt;

&lt;ol&gt;
&lt;li&gt;
&lt;strong&gt;Read trajectories, not just outcomes.&lt;/strong&gt; Sample completed runs and read the steps, especially right after the first surprising observation. In the study, more than 8 in 10 failed runs ended on a step that looks correct on its own, so a clean ending is not evidence of a clean run.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Put checks in the environment.&lt;/strong&gt; Tests, validators, schema checks, dry-run output. The starkest contrast in the paper is between an environment that argues back and one that stays quiet.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Gate irreversible actions.&lt;/strong&gt; Deletes, process kills, drops and overwrites belong behind an allowlist or a confirmation step. Three quarters of the unsafe actions in the audit were irreversible, and the agent almost never flagged the risk itself.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Use best-of-N with a verifier for tasks that matter.&lt;/strong&gt; Run a few candidate trajectories and let a verifier rank them, as in the paper's selection gains. It costs N rollouts per task, and even a good verifier is a filter, not a proof.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Log the full trajectory.&lt;/strong&gt; Thoughts, actions, observations, for every run you care about. You cannot locate a failure you did not record.&lt;/li&gt;
&lt;/ol&gt;

&lt;h2&gt;
  
  
  Caveats before you quote the numbers
&lt;/h2&gt;

&lt;ul&gt;
&lt;li&gt;These are benchmark suites, chosen to sit close to real deployment, but they are not your production workload.&lt;/li&gt;
&lt;li&gt;The science arm is small: 102 trajectories, labeled only at the first-mistake level.&lt;/li&gt;
&lt;li&gt;About 43% of failed runs have no single decisive first mistake, so the first-mistake framing and the signature above do not cover them.&lt;/li&gt;
&lt;li&gt;The link between environment feedback and recovery is an association observed across domains, not a controlled experiment.&lt;/li&gt;
&lt;li&gt;Scout's gains come from best-of-N selection over specific candidate sets; your mileage depends on how much your candidate runs actually vary, and you pay for N rollouts.&lt;/li&gt;
&lt;/ul&gt;

&lt;h2&gt;
  
  
  The short version
&lt;/h2&gt;

&lt;p&gt;In this study, a run could contain an early mistake, later steps that look correct, and damage the final score never records. The practical response is oversight at the trajectory level: checks in the environment, gates on irreversible actions, and someone or something reading the run, whether a human sampling trajectories or a small verifier trained for the job. The checkmark alone is not a review.&lt;/p&gt;

&lt;h2&gt;
  
  
  Sources
&lt;/h2&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;a href="https://arxiv.org/abs/2609.17930" rel="noopener noreferrer"&gt;Locating Hidden Failures Makes Long-Horizon Agents More Reliable (arXiv:2609.17930)&lt;/a&gt;: the paper. The Traverse benchmark, the training data and the Scout verifier are released with it.&lt;/li&gt;
&lt;/ul&gt;




</description>
      <category>ai</category>
      <category>agents</category>
      <category>llm</category>
      <category>machinelearning</category>
    </item>
    <item>
      <title>Your agent can't use a tool it never finds</title>
      <dc:creator>Shaan</dc:creator>
      <pubDate>Wed, 28 Oct 2026 11:51:44 +0000</pubDate>
      <link>https://dev.to/shaan_gs/your-agent-cant-use-a-tool-it-never-finds-n43</link>
      <guid>https://dev.to/shaan_gs/your-agent-cant-use-a-tool-it-never-finds-n43</guid>
      <description>&lt;p&gt;An agent is asked to find GitHub issues and put a summary in a spreadsheet.&lt;/p&gt;

&lt;p&gt;It finds three issue-search tools. It can read tickets, inspect comments, and filter bugs. The spreadsheet tool exists too. It just never makes it into the agent's context.&lt;/p&gt;

&lt;p&gt;Now the agent has to work with an incomplete menu. It might stop, ask for help, or try to finish with the wrong tools. Better reasoning alone won't put the missing capability back on that menu.&lt;/p&gt;

&lt;p&gt;This is the trade-off behind &lt;strong&gt;on-demand tool discovery&lt;/strong&gt;: you stop loading every tool definition into the prompt, but you take on a retrieval problem before tool selection can even begin.&lt;/p&gt;

&lt;p&gt;The useful question isn't only "Did the model choose the right tool?"&lt;/p&gt;

&lt;p&gt;It's "Was the right tool available to choose?"&lt;/p&gt;

&lt;h2&gt;
  
  
  The optimization is real
&lt;/h2&gt;

&lt;p&gt;Loading every schema upfront gets expensive as an agent connects to more services. Definitions compete with the conversation, task data, and intermediate results for context.&lt;/p&gt;

&lt;p&gt;Anthropic's &lt;a href="https://www.anthropic.com/engineering/advanced-tool-use" rel="noopener noreferrer"&gt;advanced tool-use introduction&lt;/a&gt; describes deferring tool definitions until a model searches for them. In one illustrated setup, it reports roughly 77,000 tokens of initial context consumption with the traditional approach versus 8,700 with tool search. It also reports better results on its internal MCP evaluations.&lt;/p&gt;

&lt;p&gt;Those are vendor-reported results for particular setups, not a promise that adding search will improve every agent. The same post says discovery adds a search step and is less useful for small, compact tool libraries whose tools are used frequently.&lt;/p&gt;

&lt;p&gt;This isn't confined to one API. &lt;a href="https://docs.spring.io/spring-ai/reference/guides/dynamic-tool-search.html" rel="noopener noreferrer"&gt;Spring AI's implementation&lt;/a&gt; supports semantic, keyword, and regex search over tool definitions. Its guide describes the same basic sequence:&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;Keep a catalog of tools outside the model's initial context.&lt;/li&gt;
&lt;li&gt;Let the model search for a capability.&lt;/li&gt;
&lt;li&gt;Expand matching definitions into context.&lt;/li&gt;
&lt;li&gt;Let the model choose and call a tool.&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;That third step is where a new kind of failure can become invisible if you only inspect the final tool call.&lt;/p&gt;

&lt;h2&gt;
  
  
  Discovery and selection are different tests
&lt;/h2&gt;

&lt;p&gt;Suppose the task needs two capabilities:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;Search issues.&lt;/li&gt;
&lt;li&gt;Append spreadsheet rows.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;A discovery result containing five issue tools and no spreadsheet tool is incomplete, even if every returned tool is relevant to part of the request.&lt;/p&gt;

&lt;p&gt;The &lt;a href="https://arxiv.org/html/2509.20386" rel="noopener noreferrer"&gt;Dynamic ReAct paper&lt;/a&gt; gives a closely related example: retrieval for a Twitter-to-Google-Sheets workflow returns a Twitter-only subset. Its proposed search-and-load design uses separate, focused queries for different operations instead of treating the whole request as one search query.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://arxiv.org/html/2506.01056v3" rel="noopener noreferrer"&gt;MCP-Zero&lt;/a&gt; addresses another limit of one-shot retrieval: later steps can require tools that weren't obvious from the original request. Its design lets an agent request more capabilities as the task develops.&lt;/p&gt;

&lt;p&gt;These papers don't establish one universally best retriever. They do make a useful architectural point: finding tools is part of the workflow, not necessarily a one-time setup step.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Flkkpnaurmg3d9r80xwcz.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Flkkpnaurmg3d9r80xwcz.png" alt="Three checks in a tool-use workflow: Discover checks whether candidates include every required capability. Select checks whether the model chose a valid tool. Execute checks whether the arguments were appropriate and the task succeeded. Conceptual diagram, not benchmark data." width="800" height="1024"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;&lt;em&gt;An original conceptual diagram, not benchmark data.&lt;/em&gt;&lt;/p&gt;

&lt;h2&gt;
  
  
  A small test you can run without a model
&lt;/h2&gt;

&lt;p&gt;You don't need to call an LLM to catch the most basic discovery regressions. Start with a few tasks and the capabilities each task requires.&lt;/p&gt;

&lt;p&gt;The script below deliberately uses a weak lexical search over a tiny, invented catalog. It is a constructed example, not a measurement of MCP, embeddings, or any model. Its purpose is to show how a retrieval test can expose a missing capability before you evaluate agent behavior.&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight python"&gt;&lt;code&gt;&lt;span class="kn"&gt;import&lt;/span&gt; &lt;span class="n"&gt;re&lt;/span&gt;

&lt;span class="n"&gt;CATALOG&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
    &lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;issues.search&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;search issue tickets bugs github project&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
    &lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;issues.read&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;read issue ticket details github project&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
    &lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;issues.comments&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;read issue ticket comments github project&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
    &lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;chat.search&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;search team chat messages slack&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
    &lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;chat.thread&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;read team chat message thread slack&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
    &lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;sheets.append&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;append rows spreadsheet google sheets&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
    &lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;sheets.read&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;read rows spreadsheet google sheets&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
&lt;span class="p"&gt;}&lt;/span&gt;

&lt;span class="k"&gt;def&lt;/span&gt; &lt;span class="nf"&gt;terms&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;text&lt;/span&gt;&lt;span class="p"&gt;):&lt;/span&gt;
    &lt;span class="k"&gt;return&lt;/span&gt; &lt;span class="nf"&gt;set&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;re&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;findall&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="sa"&gt;r&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;[a-z]+&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;text&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;lower&lt;/span&gt;&lt;span class="p"&gt;()))&lt;/span&gt;

&lt;span class="k"&gt;def&lt;/span&gt; &lt;span class="nf"&gt;search&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;query&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;k&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="mi"&gt;2&lt;/span&gt;&lt;span class="p"&gt;):&lt;/span&gt;
    &lt;span class="n"&gt;q&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="nf"&gt;terms&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;query&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
    &lt;span class="n"&gt;ranked&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="nf"&gt;sorted&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;
        &lt;span class="n"&gt;CATALOG&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
        &lt;span class="n"&gt;key&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="k"&gt;lambda&lt;/span&gt; &lt;span class="n"&gt;t&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="o"&gt;-&lt;/span&gt;&lt;span class="nf"&gt;len&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;q&lt;/span&gt; &lt;span class="o"&gt;&amp;amp;&lt;/span&gt; &lt;span class="nf"&gt;terms&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;CATALOG&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="n"&gt;t&lt;/span&gt;&lt;span class="p"&gt;])),&lt;/span&gt; &lt;span class="n"&gt;t&lt;/span&gt;&lt;span class="p"&gt;),&lt;/span&gt;
    &lt;span class="p"&gt;)&lt;/span&gt;
    &lt;span class="k"&gt;return&lt;/span&gt; &lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="n"&gt;t&lt;/span&gt; &lt;span class="k"&gt;for&lt;/span&gt; &lt;span class="n"&gt;t&lt;/span&gt; &lt;span class="ow"&gt;in&lt;/span&gt; &lt;span class="n"&gt;ranked&lt;/span&gt; &lt;span class="k"&gt;if&lt;/span&gt; &lt;span class="n"&gt;q&lt;/span&gt; &lt;span class="o"&gt;&amp;amp;&lt;/span&gt; &lt;span class="nf"&gt;terms&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;CATALOG&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="n"&gt;t&lt;/span&gt;&lt;span class="p"&gt;])][:&lt;/span&gt;&lt;span class="n"&gt;k&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;

&lt;span class="n"&gt;task&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;
    &lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;Find github issue tickets and bugs in a project &lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;
    &lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;and log results to a spreadsheet&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;
&lt;span class="p"&gt;)&lt;/span&gt;
&lt;span class="n"&gt;required&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;issues.search&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;sheets.append&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;}&lt;/span&gt;

&lt;span class="n"&gt;whole_task&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="nf"&gt;set&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nf"&gt;search&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;task&lt;/span&gt;&lt;span class="p"&gt;))&lt;/span&gt;
&lt;span class="n"&gt;split_task&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="nf"&gt;set&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nf"&gt;search&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;search issue tickets&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;))&lt;/span&gt; &lt;span class="o"&gt;|&lt;/span&gt; &lt;span class="nf"&gt;set&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;
    &lt;span class="nf"&gt;search&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;append rows spreadsheet&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;span class="p"&gt;)&lt;/span&gt;

&lt;span class="nf"&gt;print&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;Missing, whole task:&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="nf"&gt;sorted&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;required&lt;/span&gt; &lt;span class="o"&gt;-&lt;/span&gt; &lt;span class="n"&gt;whole_task&lt;/span&gt;&lt;span class="p"&gt;))&lt;/span&gt;
&lt;span class="nf"&gt;print&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;Missing, split task:&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="nf"&gt;sorted&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;required&lt;/span&gt; &lt;span class="o"&gt;-&lt;/span&gt; &lt;span class="n"&gt;split_task&lt;/span&gt;&lt;span class="p"&gt;))&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Output:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;Missing, whole task: ['sheets.append']
Missing, split task: []
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;The whole-task query is dominated by issue-related vocabulary. Both result slots go to issue tools. Separate queries recover the spreadsheet capability.&lt;/p&gt;

&lt;p&gt;There's a cost: in this example the split queries return four unique candidates rather than two. This is not evidence that splitting is always better at an equal token budget. It shows why "we reduced the number of visible tools" is an incomplete success metric.&lt;/p&gt;

&lt;p&gt;For a real evaluation, compare approaches at the same total schema-token budget, or report the extra cost alongside the coverage improvement. Use tasks your users actually ask, including their vocabulary, not only phrases copied from your tool descriptions.&lt;/p&gt;

&lt;h2&gt;
  
  
  Measure the part that failed
&lt;/h2&gt;

&lt;p&gt;I would keep these measurements separate:&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Discovery coverage.&lt;/strong&gt; For each task, did the retrieved set include at least one valid tool for every required capability? Some capabilities have multiple valid implementations, so don't grade every task against one hard-coded tool name.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Selection correctness.&lt;/strong&gt; Given a complete candidate set, did the agent choose an appropriate tool? A tool that is visible but ignored is a different problem from one that was never retrieved.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Argument and task correctness.&lt;/strong&gt; Did the agent supply valid, appropriate arguments and complete the actual job? A perfect retrieval score doesn't establish either.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Cost.&lt;/strong&gt; Track schema tokens, discovery calls, latency, and extra candidates. A high-coverage search that loads the entire catalog has given up much of the intended saving.&lt;/p&gt;

&lt;p&gt;A useful trace records the discovery query, candidate IDs and ranks, definitions actually loaded, selected tool, and any later search. Keep sensitive arguments out of broadly shared logs.&lt;/p&gt;

&lt;p&gt;Then an unsuccessful run has somewhere to point:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;Required capability never surfaced: inspect retrieval, catalog freshness, or filtering.&lt;/li&gt;
&lt;li&gt;Capability surfaced but wasn't loaded: inspect the search-to-load step.&lt;/li&gt;
&lt;li&gt;Definition loaded but wrong tool chosen: inspect selection.&lt;/li&gt;
&lt;li&gt;Correct tool chosen but task failed: inspect arguments, execution, and the result.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;That is more actionable than putting every failure in a bucket called "the model got confused."&lt;/p&gt;

&lt;h2&gt;
  
  
  Don't mistake a partial catalog for poor search
&lt;/h2&gt;

&lt;p&gt;Before tuning embeddings or rewriting descriptions, check that the catalog is complete for the caller.&lt;/p&gt;

&lt;p&gt;The &lt;a href="https://modelcontextprotocol.io/specification/2026-07-28/server/tools" rel="noopener noreferrer"&gt;MCP tools specification&lt;/a&gt; supports pagination in &lt;code&gt;tools/list&lt;/code&gt;. It also allows the returned tool set to vary with the authorization on the request. That means two failures can look identical from the model's seat:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;The search index didn't contain the second page of tools.&lt;/li&gt;
&lt;li&gt;The caller wasn't authorized to see those tools.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;One needs a catalog fix. The other may be correct access control.&lt;/p&gt;

&lt;p&gt;There's concrete community evidence for testing the first case: &lt;a href="https://github.com/anthropics/claude-code/issues/59538" rel="noopener noreferrer"&gt;a May 2026 Claude Code issue&lt;/a&gt; reports tools beyond the first page disappearing after a list-change notification. The issue is closed as a duplicate. This is a historical report, not a claim that the bug remains in current releases.&lt;/p&gt;

&lt;p&gt;It is still a useful regression test: paginate the catalog, change it, refresh it, and verify that tools from later pages remain discoverable.&lt;/p&gt;

&lt;h2&gt;
  
  
  A practical starting point
&lt;/h2&gt;

&lt;p&gt;Keep a small set of frequently used tools directly available. Defer the rest when the catalog's size justifies the added machinery.&lt;/p&gt;

&lt;p&gt;For compound tasks, allow more than one focused discovery query. If a later step reveals a new capability requirement, allow another search instead of forcing the agent to finish with its initial set.&lt;/p&gt;

&lt;p&gt;Write tool descriptions around actual operations and objects. "Append rows to a spreadsheet" is easier to distinguish from "Read spreadsheet rows" than two descriptions that both say "Manage sheets." Include important constraints, but don't pack every description with unrelated keywords to win retrieval.&lt;/p&gt;

&lt;p&gt;Give discovery a bounded failure path too: a reformulated query, a broader search, or a clear stop when the needed capability cannot be found. Don't quietly substitute a different action just because it ranked highly.&lt;/p&gt;

&lt;p&gt;Finally, keep authorization at the execution boundary. A search result is a candidate, not permission. A tool's presence in context does not authorize a particular call, account, recipient, or side effect.&lt;/p&gt;

&lt;p&gt;Tool search can make a large agent practical. But it changes the system you're testing.&lt;/p&gt;

&lt;p&gt;Once capabilities are loaded on demand, the catalog and retriever become part of what the agent can do. Test whether the right capability reaches the model before asking whether the model used it well.&lt;/p&gt;

&lt;h2&gt;
  
  
  Sources
&lt;/h2&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;a href="https://www.anthropic.com/engineering/advanced-tool-use" rel="noopener noreferrer"&gt;Anthropic: Introducing advanced tool use&lt;/a&gt;, November 24, 2025. Vendor examples and internal evaluations.&lt;/li&gt;
&lt;li&gt;
&lt;a href="https://docs.spring.io/spring-ai/reference/guides/dynamic-tool-search.html" rel="noopener noreferrer"&gt;Spring AI: Dynamic tool discovery&lt;/a&gt;. Implementation guide; its preliminary benchmarks use a different setup from Anthropic's.&lt;/li&gt;
&lt;li&gt;
&lt;a href="https://arxiv.org/html/2509.20386" rel="noopener noreferrer"&gt;Dynamic ReAct&lt;/a&gt;. Research architecture and multi-service retrieval example.&lt;/li&gt;
&lt;li&gt;
&lt;a href="https://arxiv.org/html/2506.01056v3" rel="noopener noreferrer"&gt;MCP-Zero&lt;/a&gt;. Research on iterative capability discovery.&lt;/li&gt;
&lt;li&gt;
&lt;a href="https://modelcontextprotocol.io/specification/2026-07-28/server/tools" rel="noopener noreferrer"&gt;MCP tools specification, July 28, 2026&lt;/a&gt;. Catalog pagination and authorization-dependent availability.&lt;/li&gt;
&lt;li&gt;
&lt;a href="https://github.com/anthropics/claude-code/issues/59538" rel="noopener noreferrer"&gt;Claude Code issue #59538&lt;/a&gt;. Historical community report, closed as a duplicate; not a current product verdict.&lt;/li&gt;
&lt;/ul&gt;

</description>
      <category>ai</category>
      <category>mcp</category>
      <category>programming</category>
      <category>testing</category>
    </item>
    <item>
      <title>The billion-token case for stateless agents.</title>
      <dc:creator>Shaan</dc:creator>
      <pubDate>Mon, 26 Oct 2026 05:39:49 +0000</pubDate>
      <link>https://dev.to/shaan_gs/the-billion-token-case-for-stateless-agents-5gnn</link>
      <guid>https://dev.to/shaan_gs/the-billion-token-case-for-stateless-agents-5gnn</guid>
      <description>&lt;p&gt;When a long agent run stalls, the reflex is to give it more. More tokens, longer sessions, bigger context windows. The assumption underneath is that experience compounds, so an agent that remembers everything it has tried should keep getting smarter as the run goes on.&lt;/p&gt;

&lt;p&gt;A new paper, &lt;a href="https://arxiv.org/abs/2610.07625" rel="noopener noreferrer"&gt;Stateless Language Agents: Scaling Long-Horizon Automated Research&lt;/a&gt; (Zhang et al., from Stanford, CMU, UW, SambaNova and Berkeley), ran that assumption at budgets up to one billion tokens. For the automated research systems they tested, it does not hold. And the fix they demonstrate is close to the opposite of the reflex: the strongest system in their comparison is built from agents that retain no conversation at all between invocations.&lt;/p&gt;

&lt;h2&gt;
  
  
  What actually happened in the long runs
&lt;/h2&gt;

&lt;p&gt;The paper studies AutoResearch systems: agents that iteratively propose, implement, and evaluate ideas for open-ended problems like kernel optimization and cross-language transpilation. These are good stress tests because the objective is measurable and the runs are long.&lt;/p&gt;

&lt;p&gt;At long horizons, three failure modes showed up in their traces, and none of them look like the model getting dumber:&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;
&lt;strong&gt;Replaying a growing history.&lt;/strong&gt; Every new step drags the full conversation along. Tokens get spent re-reading old attempts instead of trying new ones.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Duplicating work.&lt;/strong&gt; In one FrontierSWE run, two parallel agents implemented the same feature from the same parent candidate and got the same score, then overlapped again on the next feature, even though one agent had posted a note claiming it.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Quietly stopping.&lt;/strong&gt; In one GPU kernel run, the last real improvement arrived at 231M tokens. The run kept consuming tokens up to 1B anyway. Of the final 1,500 sessions, 98% made no tool calls at all. The agents had decided their solutions were optimal, and every restart resumed the same conversation that had reached that conclusion.&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;That last one is worth sitting with. The system was not out of budget. But in that run, no further improvement ever arrived, because each restart brought back the same context that had already decided to stop.&lt;/p&gt;

&lt;h2&gt;
  
  
  State versus context
&lt;/h2&gt;

&lt;p&gt;The paper's core move is separating two things that many agent frameworks glue together:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;State&lt;/strong&gt;: what persists across invocations. Candidate solutions, measured outcomes, what has been tried.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Context&lt;/strong&gt;: what the agent sees within a single invocation.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Their principle: stateful search with stateless agents. No agent carries its conversation across invocations. The harness owns the research state, and for every invocation it reconstructs a fresh, role-specific context from that state. The system retains selected research state in the harness: candidates and their measured outcomes, not full transcripts. What each one sees within a run becomes an explicit design decision instead of an accident of accumulated history.&lt;/p&gt;

&lt;p&gt;The implementation has two roles. A stateless &lt;strong&gt;Advisor&lt;/strong&gt; reads harness-summarized evidence across all search directions and turns it into concrete experiment assignments. Parallel &lt;strong&gt;Workers&lt;/strong&gt; each see only their own assignment, their current candidate, and local feedback. Statelessness is enforced, not prompted: Workers run as unprivileged processes under Linux Landlock filesystem restrictions, the harness clears their saved sessions between trials, and candidates are evaluated outside the Workers' reach with protected evaluator code.&lt;/p&gt;

&lt;p&gt;Two design details matter more than they look. The harness keeps each Worker's local improvements even when that candidate trails the global best, so alternative approaches get time to mature instead of being abandoned early. And the Advisor is itself stateless, so it re-derives its plan from current evidence each epoch rather than defending its own earlier reasoning.&lt;/p&gt;

&lt;h2&gt;
  
  
  The numbers
&lt;/h2&gt;

&lt;p&gt;The evaluation compares SLA against EvoX, CORAL, and SwarmResearch on four FrontierSWE software engineering tasks, Anthropic's VLIW SIMD kernel optimization, three NVIDIA SOL-ExecBench GPU kernel tasks, and a cryptographic algorithm-design task from FrontierCS, at budgets up to 1B cumulative tokens. Kernel quality is measured in execution cycles, where fewer cycles means a faster kernel.&lt;/p&gt;

&lt;p&gt;Two measurements matter, and they are separate questions: who ends ahead at the full budget, and how much search each method needed to get there.&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;On the first: SLA achieved the best full-budget result on &lt;strong&gt;every&lt;/strong&gt; evaluated task. On the Anthropic kernel task with Codex, all three SLA runs beat all nine baseline runs at 1B tokens. The worst SLA run finished ahead of the best baseline run (1,122 vs 1,191 cycles).&lt;/li&gt;
&lt;li&gt;On the second: SLA reached the strongest baseline's final kernel performance using 67.9M tokens versus the baseline's 986.3M, a 93.1% reduction (84% with Claude Code). On FrontierSWE it improved final scores by 4.95 points on average over the strongest per-task baseline.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F1axwmjapdkui38te1g3y.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F1axwmjapdkui38te1g3y.png" alt="Bar chart: SLA matched the strongest baseline's final kernel performance using 67.9 million tokens, compared with SwarmResearch's 986.3 million, a 93.1% reduction on the Anthropic kernel task with Codex." width="800" height="414"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;The most interesting result is about evaluation, not architecture. On all four FrontierSWE tasks, SLA was &lt;strong&gt;losing&lt;/strong&gt; at 25% of the token budget and &lt;strong&gt;winning&lt;/strong&gt; at 100%. A short evaluation would have ranked it below the baselines on every one of those tasks. The ablations show the same pattern in miniature: removing Worker context isolation made the kernel slower by 5 to 11 cycles over a 100M-token continuation from a shared checkpoint, but by 224 cycles over a full 1B-token run (1,336 vs 1,112). The cost of that design choice compounds with the horizon: in this experiment, the shorter continuation substantially understated the penalty.&lt;/p&gt;

&lt;p&gt;Explicit coordination also turned out to be nearly free in these runs. The Advisor consumes 0.24 to 0.51% of total tokens and at most 2.3% of model cost. SwarmResearch's long-running Shepherd coordinator burns 8.4 to 10.7% of tokens, largely on re-reading its own conversation.&lt;/p&gt;

&lt;h2&gt;
  
  
  What this suggests if you build agents
&lt;/h2&gt;

&lt;p&gt;A few implications look like they transfer beyond research automation:&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Stop treating the transcript as state.&lt;/strong&gt; If an agent loop persists by appending to a conversation, its state management is "whatever happened to get said." The paper's alternative is to put durable state (candidates, results, decisions) in a structured store and build each step's context deliberately from it.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Rebuild the context when restarting a stalled run.&lt;/strong&gt; In the stalled runs the paper describes, resuming the same session reproduced the stall. That is evidence for restarting with a context rebuilt from evidence, not from the conversation that gave up.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Parallel agents need assignments, not just shared memory.&lt;/strong&gt; In their traces, "everyone reads everyone's notes" still produced duplicated features. Explicit assignments were one of the ablated components, and removing them measurably hurt.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Score your evals at multiple budgets.&lt;/strong&gt; In this study, a method that trailed early dominated late, and the reverse. A single checkpoint ranking told you little about design choices whose costs compound over the run.&lt;/p&gt;

&lt;h2&gt;
  
  
  Honest limits
&lt;/h2&gt;

&lt;p&gt;The paper is careful about its own scope, and it is worth keeping that care. Every task has an executable evaluator, so this says nothing about goals that are vague or slow to score. Most configurations ran only once, since a single long run costs hundreds to thousands of dollars, so treat the non-kernel numbers as directional rather than settled. And this is a design for autonomous search loops, not conversational assistants, where continuity of the dialogue is the product rather than the enemy. The lesson for interactive agents is narrower: keep the operational state of long tasks out of the chat history. Finally, this is an arXiv preprint; treat the results as early evidence.&lt;/p&gt;

&lt;h2&gt;
  
  
  The takeaway
&lt;/h2&gt;

&lt;p&gt;In the long-horizon search systems tested here, the bottleneck was not how much the model could remember. It was that the conversation was the wrong place to keep what mattered. Moving state into the harness, rebuilding context fresh each step, and letting one cheap coordinator decide what gets tried next produced stronger results at a fraction of the tokens. Whether that generalizes past automatically scored search is an open question, but within these experiments, the agents that scaled were the ones allowed to forget.&lt;/p&gt;




&lt;p&gt;&lt;em&gt;Sources: &lt;a href="https://arxiv.org/abs/2610.07625" rel="noopener noreferrer"&gt;Stateless Language Agents: Scaling Long-Horizon Automated Research&lt;/a&gt; (arXiv:2610.07625, October 2026), &lt;a href="https://github.com/Alex-q-z/stateless-language-agents" rel="noopener noreferrer"&gt;code&lt;/a&gt;&lt;/em&gt;&lt;/p&gt;

</description>
      <category>agents</category>
      <category>ai</category>
      <category>llm</category>
    </item>
    <item>
      <title>Agents catch tool errors. Wrong values are harder.</title>
      <dc:creator>Shaan</dc:creator>
      <pubDate>Sun, 25 Oct 2026 07:25:56 +0000</pubDate>
      <link>https://dev.to/shaan_gs/agents-catch-tool-errors-wrong-values-are-harder-4ghi</link>
      <guid>https://dev.to/shaan_gs/agents-catch-tool-errors-wrong-values-are-harder-4ghi</guid>
      <description>&lt;p&gt;Most agent benchmarks answer one question: when the tools work, does the agent finish the task? Production asks a different one. Services time out. Endpoints get retired. A parameter gets renamed in a minor release. A cache returns a stale value that is correctly typed and quietly wrong. What does the agent do then?&lt;/p&gt;

&lt;p&gt;A new study, "Loud Failures, Quiet Failures" by Obada Kraishan (arXiv, October 2026), takes a direct run at that question. Instead of scoring success in a clean environment, it wraps the tool layer of the Berkeley Function-Calling Leaderboard's multi-turn environments in a fault-injection layer, breaks one thing at a controlled moment, and records what the agent does at each stage: does it treat the result as a problem, does it change its plan, does it still reach the goal, does it get stuck retrying.&lt;/p&gt;

&lt;p&gt;A commenter on my earlier piece on agent failures asked how you validate a response that looks fine but is broken. This study measures that gap directly. The short version: when a tool returned an explicit error, agents flagged it in 91.3% of trials. When a tool returned a plausible wrong value with no error signal, that fell to 58.8%, and in 39% of those trials the agent showed no reaction at all.&lt;/p&gt;

&lt;h2&gt;
  
  
  The setup, briefly
&lt;/h2&gt;

&lt;p&gt;The details matter here because the conclusions are only as good as the measurement:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;24 multi-turn tasks&lt;/strong&gt; from the BFCL, where environments are executable, stateful Python objects: a file system, a trading interface, travel booking, vehicle control, messaging, ticketing. Median of five user turns per task.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Four injected faults.&lt;/strong&gt; Three are loud: a timeout, a tool that disappears from the registry, and schema drift (a renamed parameter, rejected with an unknown-argument error). One is quiet: silent corruption, where the call succeeds and returns a well-formed value whose content is wrong. A number moved by 20 to 60 percent, an element dropped from a list, a field replaced.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Six models in three matched pairs&lt;/strong&gt;, each family contributing a reasoning variant and its instruct sibling: claude-haiku-4.5-thinking vs claude-haiku-4.5, deepseek-r1 vs deepseek-v3, and qwen3-thinking vs qwen3-instruct. Reasoning variants ran with a 2,048-token thinking budget. 1,920 trials total, temperature 1.0, a 15 tool-call cap per trial.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Two measurement choices worth stealing.&lt;/strong&gt; Recovery is scored against the same model's own fault-free run, so a weak model is not blamed for a fault. And every fault effect is judged against run-to-run variation, because two clean runs of the same task end in the same state only 63.3% of the time. Agents are stochastic; without that baseline you would blame faults for ordinary randomness.&lt;/li&gt;
&lt;/ul&gt;

&lt;h2&gt;
  
  
  Finding 1: agents watch the channel, not the content
&lt;/h2&gt;

&lt;p&gt;When a tool returned an explicit error, agents treated the result as a problem in &lt;strong&gt;91.3%&lt;/strong&gt; of trials. When a tool returned a plausible wrong value, they did so in &lt;strong&gt;58.8%&lt;/strong&gt;. For calibration, on clean trials where the target call succeeded they reported a problem 26.8% of the time. That baseline is not pure noise: the environments emit genuine errors of their own, which agents mostly handled correctly.&lt;/p&gt;

&lt;p&gt;The part that should bother you: the three loud faults demand completely different responses. A timeout calls for a retry, a missing tool calls for a new plan, a renamed parameter calls for a reformulated call. Yet detection rates for all three land within a single point of each other (91.6%, 91.2%, 91.2%). The quiet fault sits 32 points lower. What separates them is not severity or difficulty. It is whether an error string exists to read.&lt;/p&gt;

&lt;p&gt;Under silent corruption, 39% of trials drew no reaction in the agent's written output. For the arithmetic: 58.8% were flagged as a problem, 39% drew no reaction, and the small remainder fell into the study's middle codings rather than a clean flag-or-ignore. Under loud faults, the no-reaction rate was 4%. What a quiet miss looks like in practice, from the paper's examples: an agent reads a wrong value and continues with it, sometimes reconciling it with what the conversation had established earlier. The wrong values involved are the kind range or consistency checks could catch: a fuel level that exceeds the tank, an item gone from a list that was longer a moment ago, a symbol that does not match the company asked about.&lt;/p&gt;

&lt;p&gt;One caveat on the word "detection": it is coded from what the agent wrote, so an agent that noticed something and said nothing counts as not noticing. With that in mind, the pattern inverts a comfortable assumption, as the paper points out. Loud failures at least surface as errors a monitor can see. Quiet failures arrive looking exactly like success, and they are the ones agents flagged least.&lt;/p&gt;

&lt;h2&gt;
  
  
  Finding 2: in this study, reasoning models flagged less and acted more
&lt;/h2&gt;

&lt;p&gt;Each reasoning model was paired against the instruct sibling from its own family, on the same task, fault, and seed. The result is a clean dissociation:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Flagging: -9.3 points&lt;/strong&gt; for reasoning variants, pooled over 450 matched pairs (p &amp;lt; .001). Lower in all three families, clearest for Qwen3 (-16.6 points, p = .003).&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Replanning: +10.4 points&lt;/strong&gt; (p &amp;lt; .001). Reasoning variants changed their next action more often.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Recovery: -2.4 points, p = .512.&lt;/strong&gt; That is no statistically detectable difference, not proof the two are equal.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;So in these matched pairs, the models that deliberate more flagged fewer problems and changed course more often, with no detectable recovery difference either way. One reading the paper offers, consistent with trace-level work it cites, is that the deliberation phase is better at generating an alternative course of action than at checking a returned value against what the task implies.&lt;/p&gt;

&lt;p&gt;The practical version is narrow: this study does not support paying for the reasoning tier on the assumption that more deliberation means more caution under tool faults. Three matched pairs cannot establish a general property of reasoning models, and the per-family effects vary in size.&lt;/p&gt;

&lt;h2&gt;
  
  
  Finding 3: what a fault actually costs
&lt;/h2&gt;

&lt;p&gt;Judging cost requires the honesty of that 63.3% baseline. Against it, only one fault showed a statistically clear drop in recovery: a missing tool, at &lt;strong&gt;39.9%&lt;/strong&gt; (p &amp;lt; .001). Timeouts (59.6%), schema drift (59.2%), and corruption (60.4%) showed no detectable drop. Read that carefully. With 24 tasks and a noisy recovery measure, the absence of a detectable effect is not proof that those faults are harmless. What the study found is one clear, measured loss, and it came from losing a capability: the one fault no retry can undo.&lt;/p&gt;

&lt;p&gt;Corruption deserves a footnote here, and it is not reassuring. Recovery in this study is agreement in environment state. A wrong value that the agent reads but does not write changes nothing in the environment; what it changes is what the agent reports. Corruption looking no worse than baseline in end-state terms says nothing about whether the final answer quoted a wrong number.&lt;/p&gt;

&lt;p&gt;The effort numbers matter for anyone paying per call:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;After a fault, agents called the same tool three or more times in a row in &lt;strong&gt;12.5% to 22.2%&lt;/strong&gt; of trials, most often under corruption (22.2%) and timeouts (21.4%). Strictly identical repeats, same tool and same arguments, were rare at under 2%. The rest are retries with changed arguments, which are not identical-call loops but can still loop.&lt;/li&gt;
&lt;li&gt;Extra steps relative to a clean run: +0.5 for timeouts and corruption, +1.5 for a missing tool, +1.9 for a renamed parameter.&lt;/li&gt;
&lt;li&gt;Trials hit the 15-call cap 24.8% to 31.7% of the time under faults, against 23.2% when nothing goes wrong.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;One more subtle result: flagging is not the same as fixing. Pooled across conditions, trials where the agent treated the result as a problem recovered at 55.6%; trials where it did not, at 55.7%. That pooled comparison is confounded (corruption is both the least-flagged and one of the more recoverable faults). Holding fault type fixed, flagging is associated with recovery (odds ratio 1.51, p = .004), but the link weakens once the model is also held fixed (p = .098). Detection may be worth having; this study cannot show it is sufficient.&lt;/p&gt;

&lt;h2&gt;
  
  
  Finding 4: asking the agent to check its work did not help here
&lt;/h2&gt;

&lt;p&gt;The obvious fix is a line in the system prompt. The study tested it in a second arm of 480 trials on the Claude pair: "after every tool call, briefly check whether the result is what you expected."&lt;/p&gt;

&lt;p&gt;Detection moved +0.6 points for the instruct model and +2.5 for the reasoning variant. Neither is statistically significant. Recovery, repetition, and false alarms were likewise unmoved. Under quiet failures specifically, detection went from 60.6% to 59.6%.&lt;/p&gt;

&lt;p&gt;Scope this correctly: one prompt, one model family. It is not a verdict on metacognitive prompting in general. There is also a real contrast with earlier work. Sun et al. (EMNLP 2024) found that a short disclaimer improved detection when models judged a single output on request. Judging one output when asked is a different task from noticing an anomaly mid-task while carrying a plan, which may be where a general instruction loses its force. What this arm does show is that a natural first remedy produced no detectable effect in this setup.&lt;/p&gt;

&lt;h2&gt;
  
  
  What to do differently
&lt;/h2&gt;

&lt;p&gt;The paper's deployment implications, translated:&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;
&lt;strong&gt;Validate values, not just errors.&lt;/strong&gt; Checks belong where a value enters the agent's context: schema validation for shape, semantic checks for meaning (a percentage above 100, a fuel level above tank capacity), and cross-checks against state the agent saw earlier. Error monitoring and the agent share the same blind spot: a failure that stays inside the expected format.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Treat detection as the start, not the fix.&lt;/strong&gt; Flagging a problem and recovering from it are separate skills, and this study found only a modest, unstable link between them.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Have a fallback for capability loss.&lt;/strong&gt; The one statistically clear recovery drop came from a tool disappearing. Retries cannot undo a missing capability; a fallback path or a graceful degrade can.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Budget for retry behavior.&lt;/strong&gt; Three or more consecutive calls to the same tool showed up in up to 22% of fault trials. That is latency and spend in production, and it belongs in how you set step caps and timeouts.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Baseline before you blame.&lt;/strong&gt; As the paper notes, with a single clean run as the reference, three faults would have looked harmful whose end states in fact stayed within run-to-run variation in this data. Judge fault effects against repeated fault-free runs.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Fault-inject your own stack.&lt;/strong&gt; The harness, frozen task suite, trajectories, and analysis code are released under MIT (linked below; the README claims every number reproduces offline in under a minute, which I have not run myself). It is a starting point for running this class of test against your own tools.&lt;/li&gt;
&lt;/ol&gt;

&lt;h2&gt;
  
  
  The limits, stated plainly
&lt;/h2&gt;

&lt;p&gt;This is one study, and it deserves the same skepticism as any other:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;It is an arXiv preprint, single-author (the repo README says IEEE CogMI 2026, to appear), run on simulated environments from one benchmark family. The four fault types are a chosen set, not an exhaustive one.&lt;/li&gt;
&lt;li&gt;Detection is coded from the agent's written output by a model judge, validated against human coding on 92 double-coded trials at 85.9% agreement (kappa = .69). An agent that noticed something and said nothing counts as not noticing.&lt;/li&gt;
&lt;li&gt;The reasoning comparison rests on three matched pairs. It is clearest for Qwen3, holds for Claude only on matched pairs, and one of the three reasoning models had interface quirks (DeepSeek-R1 sometimes wrote tool calls as plain text that never executed). Three pairs cannot establish a general property of reasoning models.&lt;/li&gt;
&lt;li&gt;These are mid-tier models (Claude Haiku 4.5, DeepSeek R1/V3, Qwen3), not the largest frontier systems. The main reason to take the direction seriously despite the sample is that it agrees with earlier independent work: Sun et al. on silent tool errors, and ToolMaze, which found recovery falls hardest under implicit failures.&lt;/li&gt;
&lt;li&gt;Recovery is end-state agreement with a single independent fault-free run, and two such runs agree only 63.3% of the time. The paper judges fault effects against that baseline rather than against perfect agreement.&lt;/li&gt;
&lt;/ul&gt;

&lt;h2&gt;
  
  
  The bottom line
&lt;/h2&gt;

&lt;p&gt;In this study, agents responded to the error channel far more than to the content of what a tool returned. When a failure announced itself, they flagged it in 91.3% of trials. When it arrived looking exactly like success, they flagged it in 58.8%, and in another 39% the wrong value drew no reaction in the agent's written output. How often a wrong value like that reaches a user-facing answer is a separate question this study does not measure, and I am not going to pretend otherwise.&lt;/p&gt;

&lt;p&gt;A prompt line asking the agent to check its work produced no detectable change in the arm that tested it. The stronger lever these results point to is structural: validation in the path of the data, which is the same lesson production systems learned a long time ago.&lt;/p&gt;




&lt;p&gt;&lt;strong&gt;Sources:&lt;/strong&gt;&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;&lt;a href="https://arxiv.org/html/2610.10062" rel="noopener noreferrer"&gt;Loud Failures, Quiet Failures: Fault Detection and Recovery in Tool-Using Language Model Agents (arXiv preprint 2610.10062)&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href="https://github.com/obadaKraishan/brittle-agents" rel="noopener noreferrer"&gt;brittle-agents: released harness, task suite, trajectories and analysis code&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href="https://gorilla.cs.berkeley.edu/leaderboard.html" rel="noopener noreferrer"&gt;Berkeley Function-Calling Leaderboard&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href="https://aclanthology.org/2024.emnlp-main.790/" rel="noopener noreferrer"&gt;Sun et al., "Tools Fail: Detecting Silent Errors in Faulty Tools" (EMNLP 2024)&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href="https://arxiv.org/abs/2606.05806" rel="noopener noreferrer"&gt;Zhu et al., "When Tools Fail: Benchmarking Dynamic Replanning and Anomaly Recovery in LLM Agents" (ToolMaze, arXiv 2606.05806)&lt;/a&gt;&lt;/li&gt;
&lt;/ul&gt;

</description>
      <category>ai</category>
      <category>llm</category>
      <category>agents</category>
      <category>testing</category>
    </item>
    <item>
      <title>Your agent's memory is quietly going stale</title>
      <dc:creator>Shaan</dc:creator>
      <pubDate>Sat, 24 Oct 2026 05:35:34 +0000</pubDate>
      <link>https://dev.to/shaan_gs/your-agents-memory-is-quietly-going-stale-4bbf</link>
      <guid>https://dev.to/shaan_gs/your-agents-memory-is-quietly-going-stale-4bbf</guid>
      <description>&lt;p&gt;ChatGPT, Claude and Gemini all ship memory features now, and the pitch is the same: an assistant that knows you. Your preferences, your projects, your goals, carried across conversations.&lt;/p&gt;

&lt;p&gt;OpenAI's own memory FAQ admits the awkward part. It says the previous saved-memories system "often became stale" and could hold contradicting memories at the same time. That is exactly the version of the problem a new benchmark called Memora is built to measure.&lt;/p&gt;

&lt;p&gt;The paper behind it, "From Recall to Forgetting" (Uddin et al., Arizona State, University of Arizona, Genies, Findings of ACL 2026), argues that the way we test agent memory has a blind spot: we test recall, while in the authors' framing, real long-term memory is mostly revision.&lt;/p&gt;

&lt;h2&gt;
  
  
  The blind spot in how memory gets tested
&lt;/h2&gt;

&lt;p&gt;Look at how existing long-term memory benchmarks are built:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;In LoCoMo, 94% of evaluation questions can be answered with evidence from at most two past sessions. In LongMemEval it is 85%. Across the major benchmarks, the average question needs about one session of history.&lt;/li&gt;
&lt;li&gt;Updates barely exist. LongMemEval allows at most two knowledge updates before evaluation, and PersonaMem handles changes across no more than three sessions.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;So most memory scores measure something narrow: can the system dig up a fact that was stated once and never changed? Real use does not look like that. People correct themselves, change their minds, finish projects, cancel plans. Information gets updated, withdrawn and replaced, over weeks and months. A memory system that never forgets is not automatically impressive. It can be a liability with good recall.&lt;/p&gt;

&lt;h2&gt;
  
  
  What Memora does differently
&lt;/h2&gt;

&lt;p&gt;Memora simulates 10 professional personas (engineers, researchers, designers, executives) across three timeline settings the authors call weekly, monthly and quarterly. Those labels refer to the span of the simulated history: about 155, 615 and 1,991 sessions per persona respectively, at roughly 16 turns per session.&lt;/p&gt;

&lt;p&gt;The important part is what happens inside those sessions. In the quarterly setting, a persona's memory sees about 1,171 memory operations on average: 63% additions, 18% updates, 19% deletions. Preferences drift, activities repeat, goals progress. Every change is tracked in an explicit memory trace, so the benchmark knows exactly which facts are current and which are stale at question time.&lt;/p&gt;

&lt;p&gt;Three task types get evaluated:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;Remembering: recall previously discussed facts.&lt;/li&gt;
&lt;li&gt;Reasoning: combine several memories to derive an answer (like computing budget status from logged expenses).&lt;/li&gt;
&lt;li&gt;Recommending: suggest things that match the user's current preferences, not their old ones.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Scoring uses a metric the authors call FAMA (Forgetting-Aware Memory Accuracy). Standard accuracy asks: did the response include the right information? FAMA also asks: did it avoid the outdated information? Each question comes with "must include" criteria and "must exclude" criteria, and using an invalidated memory costs you. Three LLM judges vote on each criterion, with 88.3% average agreement against human annotators.&lt;/p&gt;

&lt;p&gt;They tested two setups. Four LLMs (GPT-5.2, Claude Sonnet 4.5, Gemini 3 Pro Preview, Qwen3-32B) reading conversation history directly, with and without reasoning tokens. And six dedicated memory agents (A-Mem, LangMem, Mem0, MemoBase, MemoryOS, Nemori) that store and retrieve memories across sessions, all answering through the same GPT-4o-mini backend. That last detail matters for how you read the results: the agents run on a smaller model than the LLMs reading raw history, so this is memory machinery on a fixed, modest backend, not a controlled memory-versus-no-memory comparison at equal model strength.&lt;/p&gt;

&lt;h2&gt;
  
  
  What they found
&lt;/h2&gt;

&lt;p&gt;One note on the numbers below: the authors sum per-question FAMA across all three timeline settings, so the aggregated scores run to 300, not 100. Read them as relative scores, not percentages.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;In this benchmark, memory systems are clearly better at remembering.&lt;/strong&gt; On aggregated FAMA, memory agents nearly double the LLMs on recall tasks: 119.5 versus 65.7. Explicit memory stores do their core job.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;LLMs match them on recommending anyway.&lt;/strong&gt; 144.7 to 153.3 for plain LLMs against 138.4 for memory agents. The authors' explanation: recommendations tolerate approximate memory, because you can guess plausible preferences from persona cues without retrieving anything precise. So in this study, the task where memory should matter most is the one where it added the least.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Reasoning over memory is weak everywhere.&lt;/strong&gt; Best average is 27.6, from the memory agents. LLMs sit at 12.4 to 13.9. In the authors' manual error analysis, every sampled reasoning error traced back to partial retrieval: the system had some of the pieces and answered anyway. One example from the paper: after logging several expenses against a monthly budget, agents said "within budget" instead of computing the remainder. Reasoning tokens made little difference.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;The forgetting penalty grows as memory scales.&lt;/strong&gt; This is the finding worth sitting with. For LLMs reading raw history, the FAMA penalty from stale-memory use shrinks on longer timelines (32.6 points in the weekly setting, 17.8 in the quarterly one), but for an unflattering reason: on long timelines the old conversations fall out of the context window entirely, so the model physically cannot reuse them. Memory agents show the opposite trend. Their penalty grows from 18.2 to 29.5. The more history the memory store accumulates, the more the agent leans on facts that stopped being true.&lt;/p&gt;

&lt;p&gt;This changes rankings. In the monthly setting, MemoryOS (112.8) and A-Mem (112.0) both beat Nemori (105.4) on plain memory accuracy. But Nemori's forgetting penalty is much smaller (15.4 versus 28.4 and 29.5), so once FAMA counts stale memory, Nemori jumps ahead of both. In this result, the "worse" memory system gives better answers because it is better at letting go.&lt;/p&gt;

&lt;p&gt;The error analysis makes it concrete. Of the recommendation errors the authors sampled, 64% came from outdated memory that was never invalidated. The paper's example: a user preferred non-fiction, later shifted to contemporary fiction, and the agent recommended a historical biography. It remembered. It just remembered the wrong version of the person.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fmnb9uz6swov6blq5gafk.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fmnb9uz6swov6blq5gafk.png" alt="Illustrative example based on the paper's error analysis: a preference stated early is revised later, and stale memory answers with the old preference." width="800" height="1032"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;h2&gt;
  
  
  What this means if you are building with memory
&lt;/h2&gt;

&lt;p&gt;None of this is a reason to skip memory. It is a map of where the hard part actually is.&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;
&lt;strong&gt;Treat memory writes as versions, not appends.&lt;/strong&gt; An update should supersede the old fact, and retrieval should prefer the current state. A flat, ever-growing list of "facts about the user" is exactly the shape this benchmark punishes.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Test with corrections, not just recalls.&lt;/strong&gt; If your eval set has no updates or deletions, you are measuring the easy half. Add "the user changed their mind" cases and check what the agent does with both versions.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Score the exclusions.&lt;/strong&gt; FAMA's core trick is cheap to copy: for every eval question, write down what the answer must include and what it must not bring up. Stale-memory use is invisible until you penalize it.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Do not expect a memory layer to fix reasoning.&lt;/strong&gt; Retrieval and consolidation came apart in every system tested, and the gap between them is the weakest point.&lt;/li&gt;
&lt;/ol&gt;

&lt;h2&gt;
  
  
  The honest caveats
&lt;/h2&gt;

&lt;p&gt;The conversations are simulated by LLMs, not collected from real users. The authors argue this makes the benchmark a lower bound: real interaction adds ambiguity and contradiction, so a system that fails here will likely fail harder in the wild. Fair, but still synthetic.&lt;/p&gt;

&lt;p&gt;As noted above, all six memory agents answered through GPT-4o-mini, so the agent numbers reflect the memory machinery more than the model. The scoring runs through LLM judges, though with three-way majority voting and a human agreement study behind it. Ten personas and three memory types (preferences, activities, goals) is also a narrow slice of what long-term memory could mean.&lt;/p&gt;

&lt;p&gt;Even with all that, the direction of the result is hard to wave away: everyone is racing to give agents more memory, and Memora's results suggest that more memory, badly maintained, makes answers worse.&lt;/p&gt;

&lt;p&gt;Sources: Uddin, Shubham, Blanco, Baral, Wang, "From Recall to Forgetting: Benchmarking Long-Term Memory for Personalized Agents", Findings of ACL 2026. Paper: &lt;a href="https://aclanthology.org/2026.findings-acl.1337/" rel="noopener noreferrer"&gt;https://aclanthology.org/2026.findings-acl.1337/&lt;/a&gt; (preprint: &lt;a href="https://arxiv.org/abs/2604.20006" rel="noopener noreferrer"&gt;https://arxiv.org/abs/2604.20006&lt;/a&gt;). Code and data: &lt;a href="https://github.com/geniesinc/Memora" rel="noopener noreferrer"&gt;https://github.com/geniesinc/Memora&lt;/a&gt;. Product memory docs: &lt;a href="https://help.openai.com/en/articles/8590148-memory-faq" rel="noopener noreferrer"&gt;https://help.openai.com/en/articles/8590148-memory-faq&lt;/a&gt; , &lt;a href="https://support.claude.com/en/articles/11817273-use-claude-s-chat-search-and-memory-to-build-on-previous-context" rel="noopener noreferrer"&gt;https://support.claude.com/en/articles/11817273-use-claude-s-chat-search-and-memory-to-build-on-previous-context&lt;/a&gt; , &lt;a href="https://support.google.com/gemini/answer/16598469" rel="noopener noreferrer"&gt;https://support.google.com/gemini/answer/16598469&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;Written with AI assistance.&lt;/p&gt;

</description>
      <category>ai</category>
      <category>agents</category>
      <category>llm</category>
      <category>machinelearning</category>
    </item>
    <item>
      <title>Agent Skills just became infrastructure</title>
      <dc:creator>Shaan</dc:creator>
      <pubDate>Fri, 23 Oct 2026 05:55:39 +0000</pubDate>
      <link>https://dev.to/shaan_gs/agent-skills-just-became-infrastructure-1n2g</link>
      <guid>https://dev.to/shaan_gs/agent-skills-just-became-infrastructure-1n2g</guid>
      <description>&lt;p&gt;Yesterday (October 22, 2026) Anthropic announced it is donating Agent Skills to the Agentic AI Foundation (AAIF), under the Linux Foundation. It is the same foundation that took the Model Context Protocol, and Anthropic co-founded it with Block and OpenAI.&lt;/p&gt;

&lt;p&gt;The numbers in the announcement: more than 70 agent platforms have integrated skills since the standard was published in December 2025, including ChatGPT, Cursor, GitHub Copilot and VS Code. One million skills published, nearly 280 million installed.&lt;/p&gt;

&lt;p&gt;My read: companies tend to donate a format to a foundation when they want everyone else to stop worrying about who owns it. Experiments usually stay in-house. If that pattern holds here, this announcement is less about governance paperwork and more about Anthropic telling the industry to build on skills without hesitation.&lt;/p&gt;

&lt;h2&gt;
  
  
  What a skill actually is
&lt;/h2&gt;

&lt;p&gt;A skill is a folder. That is the whole trick.&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;pdf-processing/
├── SKILL.md        # required: metadata + instructions
├── scripts/        # optional: code the agent can run
├── references/     # optional: docs it can read on demand
└── assets/         # optional: templates, data files
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;SKILL.md is markdown with a small YAML block on top:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight markdown"&gt;&lt;code&gt;&lt;span class="nn"&gt;---&lt;/span&gt;
&lt;span class="na"&gt;name&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="s"&gt;pdf-processing&lt;/span&gt;
&lt;span class="na"&gt;description&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="s2"&gt;"&lt;/span&gt;&lt;span class="s"&gt;Extracts&lt;/span&gt;&lt;span class="nv"&gt; &lt;/span&gt;&lt;span class="s"&gt;text&lt;/span&gt;&lt;span class="nv"&gt; &lt;/span&gt;&lt;span class="s"&gt;and&lt;/span&gt;&lt;span class="nv"&gt; &lt;/span&gt;&lt;span class="s"&gt;tables&lt;/span&gt;&lt;span class="nv"&gt; &lt;/span&gt;&lt;span class="s"&gt;from&lt;/span&gt;&lt;span class="nv"&gt; &lt;/span&gt;&lt;span class="s"&gt;PDF&lt;/span&gt;&lt;span class="nv"&gt; &lt;/span&gt;&lt;span class="s"&gt;files,&lt;/span&gt;&lt;span class="nv"&gt; &lt;/span&gt;&lt;span class="s"&gt;fills&lt;/span&gt;&lt;span class="nv"&gt; &lt;/span&gt;&lt;span class="s"&gt;PDF&lt;/span&gt;&lt;span class="nv"&gt; &lt;/span&gt;&lt;span class="s"&gt;forms,&lt;/span&gt;&lt;span class="nv"&gt; &lt;/span&gt;&lt;span class="s"&gt;merges&lt;/span&gt;&lt;span class="nv"&gt; &lt;/span&gt;&lt;span class="s"&gt;multiple&lt;/span&gt;&lt;span class="nv"&gt; &lt;/span&gt;&lt;span class="s"&gt;PDFs.&lt;/span&gt;&lt;span class="nv"&gt; &lt;/span&gt;&lt;span class="s"&gt;Use&lt;/span&gt;&lt;span class="nv"&gt; &lt;/span&gt;&lt;span class="s"&gt;when&lt;/span&gt;&lt;span class="nv"&gt; &lt;/span&gt;&lt;span class="s"&gt;working&lt;/span&gt;&lt;span class="nv"&gt; &lt;/span&gt;&lt;span class="s"&gt;with&lt;/span&gt;&lt;span class="nv"&gt; &lt;/span&gt;&lt;span class="s"&gt;PDF&lt;/span&gt;&lt;span class="nv"&gt; &lt;/span&gt;&lt;span class="s"&gt;documents&lt;/span&gt;&lt;span class="nv"&gt; &lt;/span&gt;&lt;span class="s"&gt;or&lt;/span&gt;&lt;span class="nv"&gt; &lt;/span&gt;&lt;span class="s"&gt;when&lt;/span&gt;&lt;span class="nv"&gt; &lt;/span&gt;&lt;span class="s"&gt;the&lt;/span&gt;&lt;span class="nv"&gt; &lt;/span&gt;&lt;span class="s"&gt;user&lt;/span&gt;&lt;span class="nv"&gt; &lt;/span&gt;&lt;span class="s"&gt;mentions&lt;/span&gt;&lt;span class="nv"&gt; &lt;/span&gt;&lt;span class="s"&gt;PDFs,&lt;/span&gt;&lt;span class="nv"&gt; &lt;/span&gt;&lt;span class="s"&gt;forms,&lt;/span&gt;&lt;span class="nv"&gt; &lt;/span&gt;&lt;span class="s"&gt;or&lt;/span&gt;&lt;span class="nv"&gt; &lt;/span&gt;&lt;span class="s"&gt;document&lt;/span&gt;&lt;span class="nv"&gt; &lt;/span&gt;&lt;span class="s"&gt;extraction."&lt;/span&gt;
&lt;span class="nn"&gt;---&lt;/span&gt;

&lt;span class="gu"&gt;## Steps&lt;/span&gt;
&lt;span class="p"&gt;1.&lt;/span&gt; ...
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Two fields are required: &lt;code&gt;name&lt;/code&gt; and &lt;code&gt;description&lt;/code&gt;. Everything else is optional. No runtime, no package manager, no registry account. If your agent can read files, it can in principle use a skill.&lt;/p&gt;

&lt;h2&gt;
  
  
  The clever part is what does not get loaded
&lt;/h2&gt;

&lt;p&gt;The spec (agentskills.io) describes a three-level loading model:&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;At startup the agent reads only the name and description of every skill, about 100 tokens each.&lt;/li&gt;
&lt;li&gt;When a task matches, it loads the full SKILL.md body (the spec recommends keeping it under 5000 tokens).&lt;/li&gt;
&lt;li&gt;Scripts, references and assets are pulled in only when the task actually needs them.&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Ftf4fo7852jfe83gsg60r.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Ftf4fo7852jfe83gsg60r.png" alt="How an agent loads a skill: metadata at startup, full SKILL.md on match, resources on demand" width="800" height="553"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;This is the same idea as MCP tools, pushed one level up. Your agent can "know" hundreds of procedures without paying the context cost for any of them until the moment they matter. Context is the scarce resource in every agent loop, and skills are designed around that fact instead of against it.&lt;/p&gt;

&lt;p&gt;It also means the &lt;code&gt;description&lt;/code&gt; field carries a lot of weight. It is the only part the agent sees before deciding to load anything. A vague description like "Helps with PDFs" gives the agent almost nothing to match a task against, so the skill may never trigger when it should. The good example in the spec reads like a search query the user might actually type.&lt;/p&gt;

&lt;h2&gt;
  
  
  Why the donation matters
&lt;/h2&gt;

&lt;p&gt;MCP was donated to the same foundation earlier, and it is now supported across most major clients. To be fair, MCP's adoption was already well underway before the donation, so a foundation home is not a magic adoption switch. What it changes is the risk calculus: stewardship moves to a neutral body, with maintainers from Anthropic, Google, OpenAI and other companies acting as individuals. That makes it much harder for any single vendor to change the rules on a whim. Not impossible, foundations evolve too, but the incentives now point outward.&lt;/p&gt;

&lt;p&gt;Concretely, for anyone building with agents:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;A skill written to the spec should load in any client that integrated the standard: Claude Code, Cursor, Copilot, VS Code and dozens more. Support depth can vary between clients (the spec marks fields like &lt;code&gt;allowed-tools&lt;/code&gt; as experimental), so test your skill where you actually run it.&lt;/li&gt;
&lt;li&gt;Companies can build products on the standard with less worry about one vendor's terms changing underneath them.&lt;/li&gt;
&lt;li&gt;My bet is the 70-platform number grows from here, because tools that were waiting to see who owned skills now have their answer. That is a prediction, not a promise.&lt;/li&gt;
&lt;/ul&gt;

&lt;h2&gt;
  
  
  What I would do this week
&lt;/h2&gt;

&lt;p&gt;If you use an agent for anything repetitive:&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;Pick one workflow you explain to your agent over and over. Writing PR descriptions, triaging issues, setting up a test env.&lt;/li&gt;
&lt;li&gt;Turn it into a folder with a SKILL.md. Steps, an example input and output, the edge cases you always forget.&lt;/li&gt;
&lt;li&gt;Spend most of your time on the description. Say what it does and when to use it, in words you would actually type.&lt;/li&gt;
&lt;li&gt;If the body grows past a page or two, move detail into &lt;code&gt;references/&lt;/code&gt; and let progressive disclosure do its job.&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;The format took about a year to go from a Claude Code feature to a vendor-neutral standard with a million published skills. Writing good ones is still a rare skill. It probably will not stay rare for long.&lt;/p&gt;

&lt;p&gt;&lt;em&gt;Written with AI assistance.&lt;/em&gt;&lt;/p&gt;

</description>
      <category>ai</category>
      <category>agents</category>
      <category>opensource</category>
      <category>claude</category>
    </item>
    <item>
      <title>Most agent failures are not hallucinations</title>
      <dc:creator>Shaan</dc:creator>
      <pubDate>Thu, 22 Oct 2026 14:45:52 +0000</pubDate>
      <link>https://dev.to/shaan_gs/most-agent-failures-are-not-hallucinations-eph</link>
      <guid>https://dev.to/shaan_gs/most-agent-failures-are-not-hallucinations-eph</guid>
      <description>&lt;p&gt;When an agent does something dumb, the usual reaction is "the model hallucinated" and a new line in the system prompt. A paper from this month argues that is usually the wrong diagnosis.&lt;/p&gt;

&lt;p&gt;Tommy Tran's "Failure Is a Feature" in ACM Queue (October 15, 2026) starts from a plain observation. An agent is a loop. The model proposes an action, a harness runs it against some tool, the result goes back to the model. That is a coordinator making remote calls to services it does not control, over networks that drop things. It is a distributed system, with a nondeterministic part in the middle.&lt;/p&gt;

&lt;p&gt;Distributed systems already have 40 years of answers for this. We just keep reaching for prompts instead.&lt;/p&gt;

&lt;h2&gt;
  
  
  Where agents actually break
&lt;/h2&gt;

&lt;p&gt;The paper sorts failures by where they enter the loop:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Tool boundary:&lt;/strong&gt; timeouts, 429s, dropped connections.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Payload:&lt;/strong&gt; the call "works" but returns truncated JSON, an HTML error page, or a schema that drifted.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Model:&lt;/strong&gt; wrong tool, invented arguments, declaring success without checking.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Side effects:&lt;/strong&gt; the write went through, the acknowledgment got lost, the step was retried.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;The loop itself:&lt;/strong&gt; two tools ping-ponging, retrying a dead API all night, running out of context.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Only one of those is a model problem. The rest have boring, known fixes. A truncated response that says &lt;code&gt;"balance": 1&lt;/code&gt; instead of &lt;code&gt;1000&lt;/code&gt; will happily get reasoned about by a model, because models parse everything. Nothing in the pipeline said no.&lt;/p&gt;

&lt;h2&gt;
  
  
  The experiment
&lt;/h2&gt;

&lt;p&gt;The paper ships a small open harness so you can check the claims. Under a fixed fault profile, here is what happened:&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Setup&lt;/th&gt;
&lt;th&gt;Tasks completed&lt;/th&gt;
&lt;th&gt;Side effects&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;Bare agent&lt;/td&gt;
&lt;td&gt;33.3%&lt;/td&gt;
&lt;td&gt;not stated&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Retries only&lt;/td&gt;
&lt;td&gt;83.3%&lt;/td&gt;
&lt;td&gt;duplicate records created&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;All seven patterns&lt;/td&gt;
&lt;td&gt;89.6%&lt;/td&gt;
&lt;td&gt;no duplicates, no orphaned writes&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;Retries alone look great until you notice the duplicates. A retry on a write that already succeeded gives you two refunds. The extra 6 points from the other patterns matter less than the cleanup they prevent.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F8i64pzz1wzf0nq5nwvx5.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F8i64pzz1wzf0nq5nwvx5.png" alt="Where faults enter the agent loop and which pattern covers each one" width="800" height="480"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;h2&gt;
  
  
  Three things worth stealing
&lt;/h2&gt;

&lt;p&gt;&lt;strong&gt;1. The harness owns the idempotency key, not the model.&lt;/strong&gt;&lt;br&gt;
If you let the model fill in an &lt;code&gt;idempotency_key&lt;/code&gt; argument, a retried step may come back with a different key and the dedup quietly stops working. Derive the key from something the harness controls:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight python"&gt;&lt;code&gt;&lt;span class="k"&gt;def&lt;/span&gt; &lt;span class="nf"&gt;run_side_effect&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;task_id&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;step_id&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;tool&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;args&lt;/span&gt;&lt;span class="p"&gt;):&lt;/span&gt;
    &lt;span class="n"&gt;key&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="sa"&gt;f&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="si"&gt;{&lt;/span&gt;&lt;span class="n"&gt;task_id&lt;/span&gt;&lt;span class="si"&gt;}&lt;/span&gt;&lt;span class="s"&gt;:&lt;/span&gt;&lt;span class="si"&gt;{&lt;/span&gt;&lt;span class="n"&gt;step_id&lt;/span&gt;&lt;span class="si"&gt;}&lt;/span&gt;&lt;span class="s"&gt;:&lt;/span&gt;&lt;span class="si"&gt;{&lt;/span&gt;&lt;span class="n"&gt;tool&lt;/span&gt;&lt;span class="si"&gt;}&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;  &lt;span class="c1"&gt;# same on every retry of this step
&lt;/span&gt;    &lt;span class="k"&gt;return&lt;/span&gt; &lt;span class="nf"&gt;call_with_retries&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;tool&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;&lt;span class="o"&gt;**&lt;/span&gt;&lt;span class="n"&gt;args&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;idempotency_key&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="n"&gt;key&lt;/span&gt;&lt;span class="p"&gt;})&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;If the model replans and proposes the action again, that gets a new step id, which is correct. That is a new decision, not a resend.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;2. Treat the token budget like a deadline.&lt;/strong&gt;&lt;br&gt;
Give every task a time limit, a token limit and a step limit, and check them before each new step. The paper calls the step cap the cheapest insurance in the article. A few lines turn "the agent looped all night against a dead API" into "the task failed at step 20 with a clear reason".&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;3. Keep the model out of the retry loop.&lt;/strong&gt;&lt;br&gt;
Let the harness retry transient errors with backoff and jitter, and show the model only the final result or a typed failure. Otherwise you pay tokens for every attempt and fill the context window with failure narration. For dead dependencies, a circuit breaker should return something the model can plan around, like &lt;code&gt;{"error": "circuit_open", "retry_after_s": 30}&lt;/code&gt;.&lt;/p&gt;

&lt;h2&gt;
  
  
  The honest caveats
&lt;/h2&gt;

&lt;p&gt;The paper is upfront that this is a toy agent with injected faults. Circuit breakers actually lowered task success when faults were random, and only pay off when a real dependency goes down. So this is not a recipe to paste in. It is a way to stop guessing.&lt;/p&gt;

&lt;p&gt;The bigger point matches what the paper says about benchmarks like tau-bench. Single-run success rates flatter agents. An agent that works most of the time per attempt fails a lot more often when you need it eight times in a row. Reliability, more than raw capability, is what stands between a demo and something you can leave running.&lt;/p&gt;

&lt;p&gt;If you are building agents, my suggestion is to read the paper and run the harness before you write your next prompt fix. The link is below.&lt;/p&gt;

&lt;p&gt;Source: Tommy Tran, "Failure Is a Feature: Engineering Fault-Tolerant AI Agents", ACM Queue, October 15, 2026. &lt;a href="https://queue.acm.org/doi/10.1145/3841558" rel="noopener noreferrer"&gt;https://queue.acm.org/doi/10.1145/3841558&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;&lt;em&gt;Written with AI assistance.&lt;/em&gt;&lt;/p&gt;

</description>
      <category>ai</category>
      <category>agents</category>
      <category>devops</category>
      <category>programming</category>
    </item>
    <item>
      <title>I used Hindsight to audit autonomous agent decisions.</title>
      <dc:creator>Shaan</dc:creator>
      <pubDate>Mon, 13 Apr 2026 17:50:02 +0000</pubDate>
      <link>https://dev.to/shaan_gs/i-used-hindsight-to-audit-autonomous-agent-decisions-3o03</link>
      <guid>https://dev.to/shaan_gs/i-used-hindsight-to-audit-autonomous-agent-decisions-3o03</guid>
      <description>&lt;h1&gt;
  
  
  I Used Hindsight to Audit Autonomous Agent Decisions
&lt;/h1&gt;

&lt;p&gt;The first time Kairo made a decision I couldn't explain, I realized I didn't have a debugging story for autonomous agents. I had logs. I had tool call traces. What I didn't have was any way to understand &lt;em&gt;why&lt;/em&gt; the agent chose that path, and more importantly, whether it would make the same mistake next time.&lt;/p&gt;

&lt;p&gt;That gap — between execution trace and learnable decision record — is what this article is about.&lt;/p&gt;




&lt;h2&gt;
  
  
  What Kairo Is and How It Hangs Together
&lt;/h2&gt;

&lt;p&gt;Kairo is an autonomous agent platform built to handle multi-step business workflows: scheduling, research synthesis, data retrieval, and cross-system coordination. The kind of tasks where a human would spend 20 minutes opening tabs, copy-pasting context, and making judgment calls — Kairo handles those end-to-end, asynchronously, without needing to check in at every step.&lt;/p&gt;

&lt;p&gt;The architecture is a fairly standard LLM-orchestrated agent loop: the planner receives a task, decomposes it into subtasks, routes each to a tool executor, collects results, and synthesizes a response. The tools are a mix of first-party integrations (calendar, CRM, internal knowledge base) and third-party APIs. Each agent run is a DAG of tool calls — some sequential, some parallelized where dependencies allow.&lt;/p&gt;

&lt;p&gt;What made Kairo interesting to build wasn't the planner logic or the tool integrations. It was the memory layer: specifically, how the agent retains what it has learned across sessions and uses that history to make better decisions the next time a similar task comes in.&lt;/p&gt;

&lt;p&gt;When I first built the system, memory was a flat vector store. The agent embedded every completed task and retrieved the top-&lt;em&gt;k&lt;/em&gt; semantically similar past experiences at inference time. This worked, roughly. But it had a problem: the agent was retrieving &lt;em&gt;what&lt;/em&gt; it had done before, not &lt;em&gt;whether what it had done was good&lt;/em&gt;. If it had made the same mistake five times, it would confidently retrieve those five memories as positive evidence for repeating that mistake.&lt;/p&gt;

&lt;p&gt;That's when I started looking for a better model of &lt;a href="https://vectorize.io/what-is-agent-memory" rel="noopener noreferrer"&gt;agent memory&lt;/a&gt; — one that incorporated outcome signal, not just semantic similarity.&lt;/p&gt;




&lt;h2&gt;
  
  
  The Core Technical Problem: Memory Without Feedback Is Just a Log
&lt;/h2&gt;

&lt;p&gt;Here's the failure mode in more concrete terms. Kairo was handling a recurring workflow: summarize a customer's support history and draft an escalation email. On one run, it retrieved the wrong account because two customers had nearly identical company names. The retrieval was confident (cosine similarity: 0.91), the draft looked plausible, and the error only surfaced when a human reviewer caught it before send.&lt;/p&gt;

&lt;p&gt;The agent had no mechanism to record that this retrieval strategy had failed under these conditions. The next time a similar task came in, it made the same mistake.&lt;/p&gt;

&lt;p&gt;What I needed wasn't just vector similarity retrieval. I needed a system that could:&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;Record decisions with their full context at the moment they were made&lt;/li&gt;
&lt;li&gt;Accept outcome feedback — whether explicit (a human flags an error) or implicit (the downstream task failed)&lt;/li&gt;
&lt;li&gt;Adjust retrieval so that low-quality decisions weren't promoted as reference material&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;I came across &lt;a href="https://hindsight.vectorize.io/" rel="noopener noreferrer"&gt;Hindsight agent memory&lt;/a&gt; and decided to give it a try. The model it operates on — using outcome-aware retrospective learning to shape what an agent remembers and retrieves — matched exactly what I needed.&lt;/p&gt;




&lt;h2&gt;
  
  
  Integrating Hindsight Into the Kairo Decision Loop
&lt;/h2&gt;

&lt;p&gt;The integration sits at two points in the Kairo pipeline: after task completion and before context assembly for new tasks.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;After completion&lt;/strong&gt; — when a task finishes (or fails), Kairo packages the full decision record: the input task, the plan the agent generated, the tools it called, the parameters it passed, and the final output. That package gets submitted to Hindsight with an outcome signal.&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight python"&gt;&lt;code&gt;&lt;span class="kn"&gt;from&lt;/span&gt; &lt;span class="n"&gt;hindsight&lt;/span&gt; &lt;span class="kn"&gt;import&lt;/span&gt; &lt;span class="n"&gt;HindsightClient&lt;/span&gt;

&lt;span class="n"&gt;hindsight&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="nc"&gt;HindsightClient&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;api_key&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="n"&gt;settings&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;HINDSIGHT_API_KEY&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;

&lt;span class="k"&gt;def&lt;/span&gt; &lt;span class="nf"&gt;record_agent_decision&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;task_run&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="n"&gt;TaskRun&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;outcome&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="n"&gt;OutcomeSignal&lt;/span&gt;&lt;span class="p"&gt;):&lt;/span&gt;
    &lt;span class="n"&gt;hindsight&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;record&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;
        &lt;span class="n"&gt;session_id&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="n"&gt;task_run&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;session_id&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
        &lt;span class="n"&gt;decision&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="p"&gt;{&lt;/span&gt;
            &lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;task&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="n"&gt;task_run&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;input_task&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
            &lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;plan&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="n"&gt;task_run&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;generated_plan&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
            &lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;tool_calls&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="n"&gt;task_run&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;tool_call_trace&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
            &lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;output&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="n"&gt;task_run&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;final_output&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
        &lt;span class="p"&gt;},&lt;/span&gt;
        &lt;span class="n"&gt;outcome&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="n"&gt;outcome&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;to_dict&lt;/span&gt;&lt;span class="p"&gt;(),&lt;/span&gt;  &lt;span class="c1"&gt;# {"success": bool, "feedback": str | None}
&lt;/span&gt;        &lt;span class="n"&gt;metadata&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="p"&gt;{&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;user_id&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="n"&gt;task_run&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;user_id&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;task_type&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="n"&gt;task_run&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;task_type&lt;/span&gt;&lt;span class="p"&gt;},&lt;/span&gt;
    &lt;span class="p"&gt;)&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;This is straightforward. The more interesting part is how Kairo uses this at inference time.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Before context assembly&lt;/strong&gt; — when a new task comes in, Kairo queries Hindsight for relevant past decisions, but with outcome weighting enabled. This means it preferentially surfaces decisions that &lt;em&gt;worked&lt;/em&gt; in similar contexts, and deprioritizes or excludes decisions that were flagged as poor.&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight python"&gt;&lt;code&gt;&lt;span class="k"&gt;def&lt;/span&gt; &lt;span class="nf"&gt;build_agent_context&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;task&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="n"&gt;Task&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="o"&gt;-&amp;gt;&lt;/span&gt; &lt;span class="n"&gt;AgentContext&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
    &lt;span class="n"&gt;relevant_memories&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;hindsight&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;retrieve&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;
        &lt;span class="n"&gt;query&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="n"&gt;task&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;description&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
        &lt;span class="n"&gt;filters&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="p"&gt;{&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;task_type&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="n"&gt;task&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;task_type&lt;/span&gt;&lt;span class="p"&gt;},&lt;/span&gt;
        &lt;span class="n"&gt;outcome_weighted&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="bp"&gt;True&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
        &lt;span class="n"&gt;top_k&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="mi"&gt;5&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
    &lt;span class="p"&gt;)&lt;/span&gt;

    &lt;span class="k"&gt;return&lt;/span&gt; &lt;span class="nc"&gt;AgentContext&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;
        &lt;span class="n"&gt;task&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="n"&gt;task&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
        &lt;span class="n"&gt;relevant_past_decisions&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="n"&gt;relevant_memories&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
        &lt;span class="n"&gt;system_prompt&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="n"&gt;KAIRO_BASE_PROMPT&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
    &lt;span class="p"&gt;)&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;The &lt;code&gt;outcome_weighted=True&lt;/code&gt; flag is doing real work here. Without it, you're doing standard RAG over a memory store — useful, but blind to quality. With it, the retrieval surface shifts meaningfully toward decisions that produced good outcomes. The agent isn't just remembering; it's learning from its own history in a way that shapes future behavior.&lt;/p&gt;




&lt;h2&gt;
  
  
  Auditing Decisions After the Fact
&lt;/h2&gt;

&lt;p&gt;The third integration point — and the one that changed how I think about agent debugging — is the audit view. &lt;a href="https://github.com/vectorize-io/hindsight" rel="noopener noreferrer"&gt;Hindsight&lt;/a&gt; maintains a queryable ledger of every recorded decision, with outcome annotations and retrieval weights attached.&lt;/p&gt;

&lt;p&gt;When a Kairo run produces a surprising result, I can now ask: what past decisions did the agent retrieve as reference material, and what were their outcome histories?&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight python"&gt;&lt;code&gt;&lt;span class="k"&gt;def&lt;/span&gt; &lt;span class="nf"&gt;audit_decision_path&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;session_id&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="nb"&gt;str&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="o"&gt;-&amp;gt;&lt;/span&gt; &lt;span class="n"&gt;DecisionAudit&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
    &lt;span class="n"&gt;run&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;hindsight&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;get_session&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;session_id&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
    &lt;span class="n"&gt;retrieved_memories&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;run&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;retrieved_memories&lt;/span&gt;

    &lt;span class="n"&gt;audit_entries&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="p"&gt;[]&lt;/span&gt;
    &lt;span class="k"&gt;for&lt;/span&gt; &lt;span class="n"&gt;memory&lt;/span&gt; &lt;span class="ow"&gt;in&lt;/span&gt; &lt;span class="n"&gt;retrieved_memories&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
        &lt;span class="n"&gt;audit_entries&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;append&lt;/span&gt;&lt;span class="p"&gt;({&lt;/span&gt;
            &lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;memory_id&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="n"&gt;memory&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nb"&gt;id&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
            &lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;task_similarity&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="n"&gt;memory&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;similarity_score&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
            &lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;outcome_weight&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="n"&gt;memory&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;outcome_weight&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
            &lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;historical_outcomes&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="n"&gt;hindsight&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;get_outcome_history&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;memory&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nb"&gt;id&lt;/span&gt;&lt;span class="p"&gt;),&lt;/span&gt;
            &lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;was_influential&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="n"&gt;memory&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;influence_score&lt;/span&gt; &lt;span class="o"&gt;&amp;gt;&lt;/span&gt; &lt;span class="mf"&gt;0.7&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
        &lt;span class="p"&gt;})&lt;/span&gt;

    &lt;span class="k"&gt;return&lt;/span&gt; &lt;span class="nc"&gt;DecisionAudit&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;session_id&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="n"&gt;session_id&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;entries&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="n"&gt;audit_entries&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;This surfaced something I hadn't anticipated: the agent was occasionally retrieving memories with high similarity scores but low outcome weights — Hindsight was correctly downweighting them, but they were still appearing in the retrieved set. A few iterations of tuning the &lt;code&gt;outcome_weight_floor&lt;/code&gt; threshold fixed this, but it was the auditability that made the problem visible in the first place.&lt;/p&gt;

&lt;p&gt;Before this, my debugging process was: read the tool call log, trace the input → output chain, shrug. Now I can see what the agent thought was relevant precedent, whether that precedent was actually reliable, and precisely where the decision went wrong.&lt;/p&gt;




&lt;h2&gt;
  
  
  Concrete Behavior Changes After Integration
&lt;/h2&gt;

&lt;p&gt;The account-name confusion problem that originally motivated this work was eliminated. After recording the failed run with a negative outcome signal, Hindsight downweighted that retrieval pattern. Subsequent runs on similar tasks retrieved past examples with explicit disambiguation steps — the agent had learned to confirm account identity before drafting.&lt;/p&gt;

&lt;p&gt;More broadly, the quality drift I'd seen in cold-start periods (where a new task type initially produces inconsistent results) leveled out significantly faster. The agent accumulated positive outcome memories more quickly because Hindsight's retrieval surfaced the successful runs as primary reference material, which in turn produced more successful runs, which reinforced the pattern.&lt;/p&gt;

&lt;p&gt;One behavior I hadn't anticipated: the agent started being more conservative on task types with mixed outcome histories. If a particular workflow had a high-variance outcome record — sometimes it worked well, sometimes it didn't — the agent would generate more defensive plans: more confirmation steps, more explicit fallback branches. The caution was being learned, not hand-coded.&lt;/p&gt;




&lt;h2&gt;
  
  
  Lessons Learned
&lt;/h2&gt;

&lt;p&gt;&lt;strong&gt;1. Retrieval without outcome signal is a liability, not just a limitation.&lt;/strong&gt; A flat memory store doesn't just fail to improve over time — it actively promotes repeated mistakes because those mistakes are well-represented in the memory space. Any production agent that runs frequently enough will converge on repeating its errors unless you build in some mechanism to distinguish good past decisions from bad ones.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;2. Auditability is a first-class requirement, not a nice-to-have.&lt;/strong&gt; I couldn't have diagnosed the account-confusion failure without being able to inspect exactly what the agent retrieved and why. Treat your agent's decision history as queryable infrastructure, not as a debugging afterthought.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;3. Implicit feedback signals are underutilized.&lt;/strong&gt; I initially assumed I'd need explicit human feedback for every run. In practice, a significant fraction of outcomes can be inferred: downstream task failure, retry events, explicit user corrections. Piping these as outcome signals to Hindsight meant the learning loop operated on every run, not just reviewed ones.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;4. Memory architecture decisions compound over time.&lt;/strong&gt; The difference between outcome-weighted memory and flat-similarity memory is small on run one. By run five hundred, the agent's behavior has meaningfully diverged. Build your memory layer correctly early; retrofitting it is painful and you lose the accumulated learning.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;5. Agent behavior becomes more legible when memory is structured.&lt;/strong&gt; Before Hindsight, explaining a Kairo decision required reading a raw execution trace. After, I can describe it in terms of precedent: "the agent retrieved three past decisions as reference, two of which had high outcome weights and suggested this specific tool call sequence." That's a story a non-engineer can follow. That matters for trust, and it matters for debugging.&lt;/p&gt;




&lt;p&gt;The thing that surprised me most wasn't that outcome-weighted memory improved agent performance. That's intuitive. What surprised me was how much it improved my ability to reason about the agent's behavior — both when it worked and when it didn't. The &lt;a href="https://github.com/vectorize-io/hindsight" rel="noopener noreferrer"&gt;best agent memory&lt;/a&gt; systems aren't just retrieval infrastructure; they're the mechanism by which an autonomous agent accumulates something resembling judgment. Building Kairo without that was like deploying a system that learned nothing from experience. Now it does.&lt;/p&gt;

</description>
      <category>ai</category>
      <category>programming</category>
      <category>microsoft</category>
      <category>devops</category>
    </item>
  </channel>
</rss>
