{"id":"c958ece9-8f5f-455b-bc39-c10483ba3fad","arxiv_id":"2610.02994","paper_version":1,"verdict":"CONDITIONAL","confidence":"MODERATE","novelty_score":6.0,"correctness_risk":"medium","formal_verification":"none","parameter_count":4,"one_line_summary":"Recovery lessons for LLM agents help only when surfaced at the moment of a matching failure rather than kept always in context, and a failure-manager built on this principle beats both intervention and context-evolution baselines.","lead":"This paper builds a 'Sentry' failure-manager that watches an LLM agent mid-task and, only when it detects a specific kind of failure, retrieves a few matching repair lessons from an external playbook that never sits in the agent's context. Across four agent benchmarks it reports clear gains over both runtime-intervention and context-evolution baselines, and controlled tests suggest that permanently exposing recovery lessons actually hurts performance.","discovery_kind":"new_method","skeptic_critique":{"model":"deepseek/deepseek-v4-flash","headline":"The verifier gating every playbook admission is the same 9B model whose repairs it judges; its only check, 81.8% human agreement on 99 same-team soft-repair windows ([b109]), never measures error direction, so a false-'resolved' bias would pollute the playbook behind the 81.7% recovery rate and…","rationale":"The reader's weakest assumption — that the shared-model reward-free verifier's resolved/unresolved judgment is a valid recovery proxy — is also the single most load-bearing point in the paper, and I agree with it. My formulation adds one sharpening: since the verifier shares weights with both the detector and the task agent whose continuation it judges, the verdict is a self-consistency check with a built-in prior that the model's own guidance worked; agreement on 99 same-team windows and κ statistics do not measure the error direction, which is exactly what would decide whether over-attribution pollutes the playbook. I considered two alternative concerns and found them secondary. (a) The persistent-exposure control (Table 4) confounds lesson content with added context length; but the retrieval ablations (§5.3, Table 14) hold the number of injected entries fixed while varying content (label-filtered 0.50/0.73 vs. random 0.33/0.55) and the w/o-intervention-need ablation shows timing alone can take WebShop below the base agent (0.136 vs. 0.170), so conditional exposure has independent, length-free support. (b) The '37%' aggregation is dominated by WebShop's +77% and SWE-bench rests on roughly a 3-resolved-task difference on a fixed 50-task set, so magnitude statements deserve caution, but the direction is positive on all four benchmarks and on the two-model GPT-OSS check. Credit where due: the internal arithmetic of Tables 1–3 and §5.3 all checks; every component ablation reduces performance; the paired-fork experiment compares objective final scores (74 wins vs. 25 losses); the human audit is two-annotator, blinded to verdicts, with κ=0.82–0.89; and the authors explicitly flag the shared-model design ([b149]) and Mind2Web score non-comparability ([b78]). None of this removes the over-attribution risk — it only narrows it. The stated fix (decoupled verifier plus, per my test, an outcome-calibration audit of existing logs) is cheap and decisive, so the reader's CONDITIONAL verdict stands as is.","tokens_in":26059,"tokens_out":19546,"duration_ms":219391,"concrete_test":"On the stored trajectories from the 939 detected failures, compute the eventual true task outcome (final WebShop reward, AppWorld pass rate, SWE-bench patch resolution, Mind2Web completion) per soft repair — using outcome labels never visible to the verifier — and compare, within benchmark and failure type, outcomes for episodes judged resolved versus unresolved. If judged-resolved episodes do not show materially better true outcomes than judged-unresolved ones, the verifier's gate carries no objective recovery signal and the playbook is polluted; also report the false-resolved versus false-unresolved split from a larger (≥300-window) annotation by annotators external to the project to confirm error direction. A cross-model swap (GPT-OSS-120B verifier with Qwen3.5-9B agent, rebuilt playbook, held-out evaluation) would independently pin the cause on same-model verification.","verdict_should_be":"UNCHANGED","load_bearing_attack":"Every playbook entry and every 'recovered' count in §5.2 (81.7% of 939 detected failures) is gated by Sentry's reward-free verifier (§3.3, Appendix A.8.3). The verifier is Qwen3.5-9B at temperature 0 — the same weights as the detector that diagnosed the failure and the task agent that produced the post-repair trajectory being judged. Its resolved/unresolved verdict, 'stops the diagnosed failure pattern and resumes task-relevant, observation-grounded progress' ([b71], Appendix A.8.3), is therefore a self-consistency check on the model's own repair, not an independent recovery signal; the model can be expected to recognize its own guidance in the continuation regardless of whether the task actually advances. The human audit (§5.2, Appendix A.7) mitigates this: two annotators, verdicts withheld, Cohen's κ=0.82–0.89, 81.8% agreement over 99 soft-repair windows. It does not settle it: the sample is small, the annotators are the research team that designed the verifier rubric, and only the agreement rate is reported — not the error direction. If the 18% disagreements skew toward false 'resolved,' a nontrivial fraction of admitted lessons come from episodes that did not genuinely recover, which is precisely the 'lesson from a failed repair misfires later' failure mode §2 motivates the design against; those junk lessons then enter the frozen playbook in Table 4 and the held-out transfer results. The w/o-verification ablation (20% drop, Table 3) shows gating matters, but removing the gate is not the same as calibrating it; an over-permissive gate would still beat no gate. The authors acknowledge the shared-model design ([b149]) but do not quantify the over-attribution risk. This does not threaten the direction of the objective per-benchmark gains (Tables 1–2), which survive even if the verifier is imperfect; it threatens the mechanism claim (reward-free verification is a valid recovery proxy), the 81.7% recovery headline, and the quality of the transferred playbook.","agreement_with_reader":"agree"},"referee_report":{"model":"deepseek/deepseek-v4-flash","summary":"The paper argues that failure-recovery knowledge for LLM agents is conditional knowledge: it should be learned across tasks but surfaced only when a matching failure is diagnosed mid-trajectory. It instantiates this principle in Sentry, an external failure-management layer that monitors the task agent, routes invalid actions to hard repair, routes progress and reasoning-grounding failures to soft repair with at most k=5 retrieved playbook lessons, verifies recovery without access to task rewards over an H=10 horizon, and admits a new lesson only after a verified recovery. Across WebShop, AppWorld, SWE-bench Lite, and Mind2Web Replay, Sentry claims an average 37% gain over the strongest runtime-intervention baseline (up to 77% on WebShop) and a 39% gain over ACE on the two held-out benchmarks, with ACE+Sentry best in both. Supporting experiments include component ablations in which every removal reduces performance (Table 3), a frozen-playbook control isolating persistent exposure from memory evolution (Table 4), paired counterfactual forks at 200 intervention checkpoints (33.5% to 60.5% local recovery), retrieval ablations, hyperparameter sensitivity, token/latency overhead, and a human audit of intervention, recovery, and helpfulness judgments.","tokens_in":26269,"tokens_out":5052,"duration_ms":34130,"significance":"If the conditional-exposure principle holds, it is a clear and falsifiable design guideline for test-time agent reliability and self-evolving agents, and the cross-benchmark consistency of the gains is substantial. The experimental design is unusually careful for this area: component ablations where every removal degrades performance, a frozen-playbook control that isolates exposure from memory evolution, paired counterfactual forks measuring causal local recovery, a deterministic label-based retrieval rule that is inspectable, fixed task sets across five runs, and human validation against the detector, verifier, and intervention helpfulness. The principal open risk is that every playbook admission and every headline recovery count is gated by a reward-free verifier that shares its weights with the task agent and the detector, so the transfer and recovery-rate claims stand or fall with the verifier's unbiasedness; the manuscript acknowledges the shared-model design as a limitation but the mitigation is partial.","major_comments":[{"comment":"The recovery verifier that gates every playbook admission and every recovery count (81.7%, Figure 3) is the same Qwen3.5-9B model that generated the repair being judged and that diagnosed the failure; the paper explicitly acknowledges the shared-model design as a limitation ([b149]). The human audit reports 81.8% agreement over only 99 soft-repair windows with both annotators drawn from the research team that designed the verifier rubric, and it reports agreement rates but not error direction. If the 18% of disagreements skew toward false 'resolved', a non-trivial fraction of admitted lessons come from episodes that did not genuinely recover — exactly the 'lesson from a failed repair misfires later' failure mode the paper motivates its design against — and these junk lessons then enter the frozen playbook used in Table 4 and the held-out transfer results. This is load-bearing for the transfer and recovery-rate claims, so the manuscript should add an error-direction analysis of the disagreements, ideally validated against an independent recovery signal such as downstream reward where available, or a decoupled verifier model on a held-out subset.","section":"§3.3, §5.2, Appendix A.7","authors_acknowledge":"Sentry uses the same model for the task agent, detector, and verifier; although its judgments largely agree with human annotators, decoupled detector and verifier 9 models remain to be studied.","authors_acknowledge_p":0.76},{"comment":"The paper's central finding that 'failure lessons are conditional' rests on the pruning experiment: removing failure-mode lessons from ACE's playbook improves held-out performance from 0.335 to 0.391 on WebShop and from 0.562 to 0.643 on Mind2Web Replay. The provided text never specifies how 'failure-mode lessons' were identified in ACE's playbook, which lessons were removed, how many were removed, or the exact pruning rule; the only reference is to the held-out protocol of §4.3, which describes task splits but not the pruning procedure. Because this experiment is the empirical basis for the principle that the entire method instantiates, the procedure needs to be specified precisely so the finding can be reproduced and audited.","section":"§2, §4.3","authors_acknowledge":null,"authors_acknowledge_p":null}],"minor_comments":[{"comment":"Several table cells appear to have merged columns or missing separators, e.g., '7922793' in Table 6, '38.53±0.87 18766 19.61' in Table 7, '0.30±0.01 90 95' in Table 8, and '55435 770.410' in Table 9; these should be reformatted so the intervention counts and guided-task counts are legible.","section":"Appendix A.5.1, Tables 6–9","authors_acknowledge":null,"authors_acknowledge_p":null},{"comment":"Because task sets are fixed across the five runs, paired comparisons over the same tasks are possible; the manuscript should report paired significance (e.g., bootstrap or Wilcoxon signed-rank over tasks) rather than relying on visual separation of the mean±std intervals, which is weak evidence for several adjacent entries.","section":"§5.1, Tables 1–2","authors_acknowledge":null,"authors_acknowledge_p":null},{"comment":"The paired counterfactual results (74 higher final score, 101 ties, 25 worse out of 200 pairs) are consistent with the local-recovery claim but show that most pairs tie; the main-text sentence should state the local-recovery comparison as the primary evidence and characterize the final-score distribution without implying a uniform advantage.","section":"§5.2, Table 11","authors_acknowledge":null,"authors_acknowledge_p":null},{"comment":"The GPT-OSS-120B robustness experiment covers only WebShop and Mind2Web Replay, and the paper concedes this at the end of the appendix; the main text's summary 'Sentry's performance gains remain robust across models' should carry the two-benchmark scope explicitly in the same sentence.","section":"§5.4, Appendix A.5.2","authors_acknowledge":null,"authors_acknowledge_p":null}],"recommendation":"major_revision"},"author_rebuttal":null,"desk_editor":{"model":"deepseek/deepseek-v4-flash","letter":"What you should know first: this is a solid, unusually well-ablated empirical paper, and I mostly believe the direction of the results. The central claim — failure knowledge is conditional and should be surfaced only when a matching failure is diagnosed, then admitted only after verified recovery — is supported by cleaner experiments than most work in this area.\n\nThe genuinely new pieces: pruning failure lessons from ACE's playbook improves held-out performance (0.335 to 0.391 on WebShop); the frozen-playbook control isolates exposure from evolution and shows persistent context placement lowers reward even when the same lessons stay retrievable on demand; and the design itself — external, failure-gated, verified playbook with top-k retrieval. The ablations are the real strength. Every component removal hurts, the intervention-need gate is the biggest lever (54.7% average drop), and the paired counterfactual forks (local recovery 33.5% to 60.5%, higher final score in 74 of 200 pairs) are the right kind of evidence. I buy the mechanism at the level of direction.\n\nNow the soft spots, in proportion. The verifier worry is real, and the authors say so themselves ([b149]): Qwen3.5-9B is both the agent being repaired and the judge of whether the repair worked, with no reward access. The human audit covers 99 soft-repair windows with 81.8% agreement, same team, no error direction reported. The w/o-verification ablation (20% drop) proves gating matters, but removing the gate is not the same as calibrating it — an over-permissive verifier would still beat no gate. So the 81.7% recovery headline and the quality of the transferred playbook rest on an unmeasured error direction. This does not threaten the per-benchmark gains, which would survive an imperfect verifier; it does mean the mechanism claim, that reward-free verification is a valid recovery proxy, is not yet established. I would want error-direction analysis or a decoupled verifier before signing off on that.\n\nTwo smaller items. The statistics: five runs over a single fixed task set with randomized execution order. The ±std captures order noise, not task-sampling variance, so the headline numbers (77% on WebShop) are stated with more confidence than the design justifies. And the gains are uneven: WebShop carries the story, while Mind2Web Replay is +7.1% and its Replay scores are explicitly not comparable to official Mind2Web metrics — disclosed, but worth keeping in view when quoting the average.\n\nWho this is for: anyone working on agent reliability, runtime intervention, or memory design. The exposure-versus-selection framing is a genuinely useful way to think about when lessons should reach an agent. I would bring it to reading group and would cite the pruning and exposure-control findings.\n\nSend it to peer review. It is substantive, honestly written, and the ablation design deserves referee time. The revision ask should be verifier error direction and calibration, plus a statistical treatment that acknowledges the fixed-task-set sampling. None of that is a reject reason.","headline":"A genuinely careful empirical paper whose conditional-exposure claim mostly holds up; the load-bearing soft spot is the self-judging verifier with unmeasured error direction, and the gains are more WebShop-heavy than the abstract suggests.","tokens_in":27004,"tokens_out":4078,"duration_ms":26836},"pith_extraction":{"msc":[],"pacs":[],"model":"deepseek/deepseek-v4-flash","headline":"Failure knowledge is conditional knowledge: kept in an agent's context, recovery lessons misfire when their failure is absent, and gating them — stored externally, retrieved only on a diagnosed matching failure, admitted only after…","keywords":["LLM agents","failure recovery","conditional knowledge","test-time intervention","playbook retrieval","recovery verification","context evolution","runtime monitoring"],"falsifier":"Run Sentry's playbook admission under an independent recovery signal — task rewards, a decoupled verifier model, or an external judge — and compare held-out performance against the reported numbers; if the margin over baselines shrinks toward the unverified variant, the shared-model verifier was systematically over-attributing its own repairs as resolved.","tokens_in":27262,"feed_emoji":"🛠️","tokens_out":4745,"duration_ms":30413,"temperature":0.7,"pith_summary":"The paper claims that recovery knowledge for LLM agents is conditional knowledge: a lesson like \"after repeated empty searches, broaden the query\" helps only while that failure is happening, and keeping such lessons permanently visible makes agents misapply them and perform worse. To test this, the authors build Sentry, a layer that monitors an agent mid-task, diagnoses failures, retrieves at most five matching lessons from an external playbook, guides recovery, and stores a new lesson only after verifying — without seeing task rewards — that the agent actually recovered. Across WebShop, AppWorld, SWE-bench Lite, and Mind2Web Replay, Sentry beats the strongest runtime-intervention baseline on every benchmark (37% on average, up to 77%) and the strongest context-evolution baseline by 39%. Removing failure lessons from a standard playbook improves held-out performance, and re-adding the full playbook persistently to context lowers it, supporting the central conditional-exposure principle.","feed_headline":"Gating failure lessons lifts LLM recovery by 37%","feed_subtitle":"Sentry keeps recovery lessons out of context and shows them only when the matching failure fires.","key_machinery":"The load-bearing mechanism is the conditional-exposure design with three properties: surfacing (only a diagnosed failure triggers retrieval of at most k=5 matching lessons), verification (a lesson enters the playbook only after a verifier judges the triggering failure resolved over the next H=10 cycles, with no access to task rewards), and isolation (the full playbook never enters the agent's persistent context). Retrieval is label-filtered: entries must share the failure type and a fine-grained retrieval label with the diagnosis, ranked by label overlap with recency tie-breaking, and capped so no single failure subtype dominates. The companion results carry the argument: failing to gate — persistent context exposure, always-on intervention, or unverified admission — each measurably lowers performance in controlled ablations.","core_discovery":"The central claim is that how failure knowledge reaches an agent matters as much as what it contains. Context-evolution methods expose lessons too early — selected at task start and kept in context for the whole trajectory — so the agent must judge at every step whether each applies, and it often judges wrong. Runtime interventions act at the right moment but never learn from their rescues. Sentry combines the two: it maintains an evolving recovery playbook outside the agent's context, surfaces a few matching lessons only when it diagnoses a failure mid-trajectory, and admits a lesson only after a verifier, blind to task rewards, judges the recovery resolved. If the paper is right, the load-bearing result is that a failure-gated, verified, externalized memory reliably outperforms both always-on lesson exposure and intervention-without-learning across heterogeneous agentic tasks, and transferring lessons works on held-out tasks. The reported evidence includes a paired fork experiment showing local recovery rises from 33.5% without intervention to 60.5% with Sentry's soft repair.","pith_inferences":["The conditional-exposure principle likely generalizes beyond failure knowledge to any piece of advice an agent could misapply: the cost of a lesson lies not in what it says but in where the agent is forced to weigh it, which suggests a testable comparison of gating against simple pruning across non-failure advice as well.","Because the detector, verifier, and task agent use the same model, the measured gains may partly reflect the model being good at recovering from its own mistakes rather than recoverable failures in general; using decoupled models for detection and verification is the direct way to separate these effects.","The single-model verifier is the load-bearing point: 81.8% human agreement on 99 soft-repair windows is the evidence the paper offers, and the entire playbook is gated on that judgment, so an independent recovery signal is the most direct check of the headline numbers.","The playbook's steady growth (937 detected failures, 227 interventions in one setting) raises a question the paper flags: whether confidence-based admission, merging, or pruning of redundant entries would keep retrieval quality from degrading as the playbook ages."],"forward_implications":["Failure-specific memory should be kept outside the agent's persistent context and exposed only on a diagnosed, matching failure; adding the full playbook persistently lowers WebShop reward by 0.068 even when matching lessons remain retrievable on demand.","Lesson admission should be gated on verified recovery, since a lesson learned from a failed repair would misfire on future tasks too; removing verification reduces performance by roughly 20% on average.","Task-level context evolution and failure-level recovery memory are complementary: combining them (ACE+Sentry) gives the best measured result on both benchmarks where both are evaluated.","Learned recovery lessons transfer across disjoint tasks: a frozen playbook initialized on 50 tasks improves held-out WebShop reward from 0.251 to 0.364 and Mind2Web Replay completion from 0.533 to 0.651, with further gains from continuing verified updates.","Recovery works best when retrieval is matched to the diagnosed failure; loosening retrieval to failure-type-only, unfiltered, or random selection degrades performance by roughly 11%, 19%, and 29% respectively."],"supporting_citations":[{"why":"The strongest context-evolution baseline; its own playbook, with failure lessons removed, improves from 0.335 to 0.391 on WebShop, which motivates the conditional-exposure principle.","marker":"[30]"},{"why":"The representative runtime-intervention baseline whose fixed rules never learn; Sentry must beat it on every benchmark in the main comparison.","marker":"[8]"},{"why":"The WebShop benchmark where the largest relative gains (77%) and the exposure-control experiments are measured.","marker":"[24]"},{"why":"Source benchmark adapted into Mind2Web Replay, the interactive recovery-setting evaluation used in the main comparisons.","marker":"[4]"},{"why":"AppWorld, the stateful app-based tool-use benchmark used in the main comparisons and component ablations.","marker":"[19]"},{"why":"SWE-bench Lite, the software-engineering benchmark where progress recovery is hardest (34% local recovery).","marker":"[7]"},{"why":"Reflexion, the context-evolution baseline storing natural-language reflections, which Sentry is compared against.","marker":"[18]"},{"why":"ReasoningBank, the retrieval-based context-evolution baseline that selects lessons before execution.","marker":"[15]"},{"why":"Cited for capability erosion in self-evolving agents, which the persistent-exposure result mirrors.","marker":"[27]"}],"fun_headline_variants":["Sentry lifts LLM agent recovery 37% by gating failure lessons","Failure lessons beat context evolution when gated to the right moment","Gated failure playbook boosts LLM agent recovery by 37%","Show failure lessons only when they fire; recovery jumps 37%","Sentry keeps failure lessons conditional and lifts recovery 37%"],"cache_read_input_tokens":0,"weakest_assumption_plain":"Everything the playbook stores is gated on a verifier that shares its model with the agent and never sees task rewards, so the method's value depends on that model reliably telling whether a recovery actually happened.","fun_headline_variants_meta":{"raw":{"variants":["Sentry lifts LLM agent recovery 37% by gating failure lessons","Failure lessons beat context evolution when gated to the right moment","Gated failure playbook boosts LLM agent recovery by 37%","Show failure lessons only when they fire; recovery jumps 37%","Sentry keeps failure lessons conditional and lifts recovery 37%"]},"model":"deepseek/deepseek-v4-flash","effort":"low","cost_usd":0.000323,"raw_usage":{"cost":0.00032326,"is_byok":false,"cost_details":{"upstream_inference_cost":0.00032326,"upstream_inference_prompt_cost":0.0001645,"upstream_inference_completions_cost":0.00015876},"total_tokens":1742,"prompt_tokens":1175,"completion_tokens":567,"prompt_tokens_details":{"audio_tokens":0,"video_tokens":0,"cached_tokens":0,"cache_write_tokens":0},"completion_tokens_details":{"audio_tokens":0,"image_tokens":0,"reasoning_tokens":489}},"tokens_in":1175,"tokens_out":567,"cost_source":"openrouter_usage","duration_ms":9448,"image_pages":[],"temperature":1.0,"billed_attempts":1,"reasoning_tokens":489,"transport_provider":"openrouter","cache_read_input_tokens":0,"cache_creation_input_tokens":0},"cache_creation_input_tokens":0},"created_at":"2026-10-05T14:48:08.925517+00:00","model_set":{"reader":"deepseek/deepseek-v4-flash"},"pipeline_version":"pith-pipeline@v1.4.1-daily-deepseek-or-medium","input_kind":null,"input_chars":null,"input_total_chars":null,"passes_missing":null,"published_standing":null,"published_confidence":null,"objection_audit":null,"run_record":null,"basis":{"kind":"not_recorded","source":null,"chars_given":null,"chars_total":null},"receipt":null,"falsifier":"Run Sentry's playbook admission under an independent recovery signal — task rewards, a decoupled verifier model, or an external judge — and compare held-out performance against the reported numbers; if the margin over baselines shrinks toward the unverified variant, the shared-model verifier was systematically over-attributing its own repairs as resolved.","supporting_citations":[{"cited_title":"Agentic context engineering: Evolving contexts for self-improving language models","cited_arxiv_id":null,"evidence_quote":"The strongest context-evolution baseline; its own playbook, with failure lessons removed, improves from 0.335 to 0.391 on WebShop, which motivates the conditional-exposure principle."},{"cited_title":"AgentGuard: Runtime verification of AI agents.arXiv preprint arXiv:2509.23864, 2025","cited_arxiv_id":null,"evidence_quote":"The representative runtime-intervention baseline whose fixed rules never learn; Sentry must beat it on every benchmark in the main comparison."},{"cited_title":"WebShop: Towards scalable real- world web interaction with grounded language agents","cited_arxiv_id":null,"evidence_quote":"The WebShop benchmark where the largest relative gains (77%) and the exposure-control experiments are measured."},{"cited_title":"Mind2Web: Towards a generalist agent for the web","cited_arxiv_id":null,"evidence_quote":"Source benchmark adapted into Mind2Web Replay, the interactive recovery-setting evaluation used in the main comparisons."},{"cited_title":"Appworld: A controllable world of apps and people for benchmarking interactive coding agents","cited_arxiv_id":null,"evidence_quote":"AppWorld, the stateful app-based tool-use benchmark used in the main comparisons and component ablations."},{"cited_title":"Jimenez, John Yang, Alexander Wettig, Shunyu Yao, Kexin Pei, Ofir Press, and Karthik Narasimhan","cited_arxiv_id":null,"evidence_quote":"SWE-bench Lite, the software-engineering benchmark where progress recovery is hardest (34% local recovery)."},{"cited_title":"Reflexion: Language agents with verbal reinforcement learning","cited_arxiv_id":null,"evidence_quote":"Reflexion, the context-evolution baseline storing natural-language reflections, which Sentry is compared against."},{"cited_title":"Le, Samira Daruki, Xiangru Tang, Vishy Tirumalashetty, George Lee, Mahsan Rofouei, Hangfei Lin, Jiawei Han, Chen-Yu Lee, and Tomas Pfister","cited_arxiv_id":null,"evidence_quote":"ReasoningBank, the retrieval-based context-evolution baseline that selects lessons before execution."},{"cited_title":"Do Self-Evolving Agents Forget? Capability Degradation and Preservation in Lifelong LLM Agent Adaptation","cited_arxiv_id":"2605.09315","evidence_quote":"Cited for capability erosion in self-evolving agents, which the persistent-exposure result mirrors."}],"lane_accuracy":{"status":"not yet measured","lane":{"model":"deepseek/deepseek-v4-flash","input_kind":null},"url":"https://pith.science/accuracy"},"review_version":1}