Your Agents Are Aging Too: Agent Lifespan Engineering for Deployed Systems

🕒 Published (v1): 2026-05-25 19:55 UTC · Source: Arxiv · link

Why this paper was selected

Agent lifespan engineering; first systematic study of deployed agent degradation over time

Ask a follow-up

Open an assistant pre-loaded with this paper's context.

💬 Ask ChatGPT✦ Ask Claude

TL;DR

Long-lived AI agents degrade over time not because model weights change, but because the surrounding agent harness — memory writing, retrieval, lifecycle management — evolves with accumulated state. This paper introduces AgingBench, a longitudinal benchmark that measures, taxonomizes, and diagnoses four distinct mechanisms of agent reliability decay after deployment. Across 14 models and ~400 runs, it shows aging is multi-dimensional and that effective repair requires stage-targeted diagnosis, not stronger base models.

Problem

Existing memory benchmarks treat reliability as a static, end-to-end snapshot score: given the current session, did the agent answer correctly? This misses the deployment reality of long-lived agents, where reliability is a lifespan property of the full agent harness. Even with frozen model weights, the effective agent state changes continuously as memory is compressed, accumulated, revised, and maintained. No prior benchmark measures longitudinal degradation, distinguishes how performance decays by mechanism, or localizes where in the memory pipeline the failure originates.

Method

Taxonomy. Agent aging is decomposed into four mechanisms: (a) Compression aging — write-time summarization drops future-relevant details (low-frequency facts like dollar amounts, proper nouns); (b) Interference aging — accumulated similar entries crowd out the correct fact at retrieval, even when no information is lost; (c) Revision aging — changed or derived state (e.g., \(\text{budget} = \text{initial} + \sum \Delta_i\)) is not propagated, producing compounding errors invisible to keyword recall; (d) Maintenance aging — lifecycle events (recompaction, history flush, prompt updates) trigger abrupt regression.

Temporal FactGraph. Each scenario is backed by a programmatic generator producing a DAG \(G = (\mathcal{F}, \mathcal{E}, \mathcal{I})\) with version chains tracking fact supersession, dependency edges linking probes to facts across sessions (chain depth \(d\)), and interference pairs injecting confusable entities. Four pressure dials — dependency density, update rate, chain depth, confusable pairs — are varied independently across presets (none/light/medium/heavy).

Session loop. At each session \(t\), the agent reads compressed memory \(M_t\), answers tasks, and writes back: $\(M_{t+1} = U(M_t, H_t;\, \theta)\)$ where \(U\) is the compaction function parameterized by \(\theta\). At designated sessions \(t = k\), the runner injects a lifecycle event \(e_k\). The resulting score sequence \(m(t) = \{s_0, \ldots, s_N\}\) forms the aging curve, from which half-life \(t_{1/2}\), decay slope (OLS), and per-session hazard proxy are computed.

Counterfactual attribution. Three probe conditions (P1: default; P2: oracle retrieval over agent-written memory; P3: gold context bypassing both write and retrieval) produce diagnostic profiles over write (W), retrieval (R), utilization (U), and store/lifecycle (S) stages, localizing where in the pipeline repair would be most effective.

Key Contributions

• Agent Lifespan Engineering (ALE) framing: reliability as a time-evolving property of the full agent harness, not the base model.
• Four-mechanism aging taxonomy (compression, interference, revision, maintenance), each mapped to a memory-pipeline stage and equipped with mechanism-specific metrics.
• AgingBench: 7 scenarios, programmatic task generation with temporal DAG structure, configurable pressure control, and support for both runner-managed and autonomous agent evaluation.
• Counterfactual diagnostic profiles: paired P1/P2/P3 probes that narrow "the agent forgot" into write-time omission, retrieval failure, utilization failure, or lifecycle shock.
• Empirical finding: behavioral compliance and factual precision can decouple; derived-state tracking can collapse sharply within a single model; the same aggregate failure rate hides different root causes across stages.

Results

• All 7 scenarios show overall downward performance trends across models as session count grows (Figure 4); rate and shape vary by mechanism.
• Behavioral tests can remain clean while factual precision decays simultaneously (compression/interference dissociation).
• Derived-state tracking (revision aging, S2 scenario) can collapse sharply within a single model while other metrics remain stable.
• Strong models may preserve information at write time yet fail to reuse it at utilization — demonstrating that model capability and pipeline reliability are not interchangeable.
• Routine maintenance (lifecycle events) can trigger abrupt post-event performance cliffs rather than gradual decline.
• Tested across 14 models (including GPT-4o, Qwen-14B, Gemma-4, DeepSeek variants, LLaMA-3, etc.) and multiple memory policies; ~400 runs spanning 8–200 sessions.

(Note: specific numeric recall/precision values by model are in the appendix and not fully reproduced in the truncated text above.)

Limitations

• Programmatic generators intentionally do not model the full distribution of real user behavior; they provide controlled pressure surfaces for isolating failures, not ecological validity.
• The benchmark targets compaction-based summarization as the baseline memory architecture; evaluation of more complex architectures requires plugging in alternative policies.
• Counterfactual probes produce diagnostic profiles indicating which stage to repair, not unique causal decompositions — multiple pipeline stages can fail simultaneously and the profiles cannot always disambiguate.
• Only agent-written memory (not external retrieval corpora) is evaluated in the oracle condition; the framework does not yet cover retrieval-augmented architectures with separate vector stores.
• Paper text is truncated; full empirical tables and per-model breakdowns are in appendices not included here.

Relevance to Harnesses / Meta-Harnesses

This paper directly formalizes the agent harness as the unit of reliability: it explicitly defines a deployed agent as "a language model coupled with memory writing, storage, retrieval, utilization, tools, prompts, workspaces, and maintenance procedures," and shows that harness-level behavior evolves even when model weights are frozen. For researchers building or evaluating meta-harnesses, AgingBench provides the first longitudinal evaluation framework that treats lifecycle events (recompaction, flush, prompt migration) as first-class experimental variables — exactly the events that harness engineers trigger during operation. The counterfactual P1/P2/P3 probe design is directly applicable to any harness audit pipeline, producing repair-oriented stage attribution without requiring white-box access to the agent internals. The four-mechanism taxonomy gives harness designers a concrete checklist for what operational pressures to test against during deployment.