Agent-Controlled Forgetting for Tool-Using Agents: Reversible Context Curation in Practice

Abstract: Tool-using agents repeatedly carry observations whose useful content can be much smaller than their original payload. We study agent-controlled forgetting: the acting model selects previously observed tool results, replaces each with a short note at its original position, and retains the exact original in a recoverable archive. A Python harness exposes batch archival and explicit recovery without task-specific model training, while protecting user instructions and assistant messages from these operations. In an exploratory OpenTelemetry debugging case followed by an unrelated implementation task, the method ended with 231,951 provider-reported prompt tokens versus 912,492 under retained history, used 50% fewer cumulative input tokens, and had an estimated API cost of USD 1.28-1.44 versus approximately USD 4.38. Both arms passed the two-case primary behavioral oracle; neither fully satisfied the follow-up evaluation. The method made more requests and took 17% longer. A contrasting application-development pair produced no context or cost saving, and an earlier continuation exhibited lower manually assessed quality despite reduced context. These observations demonstrate substantial resource savings in noisy tool-use trajectories and identify workload dependence as a central consideration for reversible context management.

• Paper explores a method automated-context-curation in which tool-using agents improve efficiency eliminating redundant Data from input at their Judgment.
• The study focuses on diagnostic concluding obsolete data replaced by an note could guarantee efficient use of memory and reduce cost up two 70% based on case study..
• Concludes need Why Understanding Context Memory Technique may vary sen scenario of Workload in exchange of trade-Off that cost saving and quality mechanism.

Research problem and contribution

“Agent-Controlled Forgetting for Tool-Using Agents: Reversible Context Curation in Practice” (2610.10590) examines whether a tool-using agent can reduce the cost and size of long interaction histories by selectively evicting previously observed tool results from its active context while retaining exact copies in an external archive. The central distinction is between exposure and continued retention. A tool result may need to be read in full to support diagnosis, yet become unnecessary once its evidential role has been resolved. The proposed mechanism allows the acting model to make that determination retrospectively, after interpreting the observation.

The contribution is deliberately narrower than a general memory architecture. The system provides a reversible, auditable operation over individual tool-result occurrences. Each result receives a stable identifier when it enters the conversation. The model can submit a batch of pairs consisting of a result identifier and a replacement note. The harness validates the entire batch atomically, archives the original text, image payloads, and provenance, and replaces the active result body at its original position with a note and archive reference. A recovery operation retrieves the exact archived payload as a new tool result at the end of the conversation.

This design has several important invariants. User, system, and assistant messages are not eligible for archival, so the operation cannot directly rewrite the task instructions or prior assistant outputs. Invalid, duplicate, already archived, or unavailable identifiers cause the complete batch to fail without partial mutation. Originals are archived before active-context stubs are committed. Recovery does not rerun the source tool; it restores the historical observation, rather than obtaining a new measurement from a potentially changed environment.

The method therefore provides reversibility at the storage level, not lossless preservation of the agent’s reasoning state. A note may omit details, mischaracterize an observation, or fail to preserve a dependency required later. Likewise, “forgetting” denotes eviction from the active request rather than deletion, model unlearning, or privacy erasure. These distinctions are central to interpreting the results: exact archive integrity does not establish semantic adequacy of the replacement notes.

Relation to context-management research

The paper positions its interface within a substantial body of work on agent-managed context and memory. MemGPT treats memory as a hierarchy controlled through function calls (Packer et al., 2023), while MemAct formulates context editing as an action selected by the acting policy. Context-Folding and AgentFold remove intermediate trajectory material through structured folding and summaries (Sun et al., 13 Oct 2025, Ye et al., 28 Oct 2025). ACON optimizes compression policies from trajectory feedback (Kang et al., 1 Oct 2025), and ACM combines agent-initiated management with archival and retrieval (Li et al., 26 Jul 2026). Other systems address learned external management, persistent-memory retention, graph-based pruning, or general read-write access to live context (Yi et al., 29 May 2026, Rusu et al., 29 Aug 2026, Shao et al., 29 Sep 2026).

The present study does not claim priority for archival, summaries, recoverable transcripts, or agent-selected context editing. Its narrower claim is practical: a prompted acting model can select individual tool-result occurrences, leave notes at their original positions, preserve exact payloads externally, and continue a task without modifying the tools that generated the observations. The study also does not compare against learned managers, automatic threshold eviction, programmatic filtering, ACON, ACM, provider-side context editing, or general context-language-model interfaces. Consequently, the reported results establish the behavior of one interface and prompting policy against retained history, not superiority over the wider design space.

The timing of curation is the paper’s main conceptual emphasis. Pre-exposure retrieval and filtering can reduce the initial input but may discard evidence before the agent has interpreted it. Post-exposure curation allows the model to use diagnostic conclusions when deciding what remains active. This is particularly relevant for broad MCP responses, browser observations, test logs, and telemetry payloads whose useful information may be a small subset of the original result.

Method and accounting

The experimental method uses a prompted acting model rather than a separately trained context manager. The prompt instructs the model to curate after meaningful research or diagnostic progress, retain unresolved evidence, batch substantial archival operations, and continue the original task. A heuristic reference to approximately 25% irrelevant content is included in the instructions, but this is neither an annotated property of the data nor an enforced classifier threshold.

The runtime harness issues reminders when the projected request reaches approximately 40,000 text tokens or when image content is present. Subsequent reminders require meaningful additional eligible output, configured as 20,000 characters or a new image. Reminders are ephemeral and do not become persistent conversation history. The retained-history comparator receives the same task tools but no context-management instructions, tools, or reminders.

Resource accounting separates active prompt size, cumulative input, completion tokens, total reported tokens, requests, elapsed time, and estimated API cost. Provider-reported prompt tokens are used as an operational proxy for active context. They are not treated as a direct measure of usable reasoning capacity, and the paper explicitly rejects interpreting smaller prompts as evidence of improved reasoning. Cost estimates incorporate ordinary input, cached input, and output tariffs, with ranges used when cache details are incomplete. This is important because context edits may invalidate reusable prompt prefixes and impose immediate cache costs even when they reduce later input.

The primary evaluation is an exploratory systems comparison using the provider model identifier z-ai/glm-5.3-flash through TensorX. It consists of one retained-history run and one method run for a noisy OpenTelemetry debugging task followed by an unrelated C++ implementation task. The arms begin from byte-identical source snapshots and reset environments, but their trajectories are not identical: browsing decisions, observations, generated code, and image occurrences differ. The study is therefore a comparison of complete deployment trajectories, not a controlled intervention on identical histories.

A Planroom application-development pair provides a workload contrast. A six-session Sphinx batch supplies descriptive supporting evidence under an older configuration. An earlier browser continuation is reported as an adverse observation rather than omitted. The paper correctly treats these episodes as non-independent case studies rather than as a pooled benchmark with conventional confidence intervals.

Central OpenTelemetry result

The strongest result occurs in the OpenTelemetry debugging-and-pivot case. The primary task required diagnosis of a failing checkout, implementation of a frontend error contract, and verification through Cypress cases. After the primary submission, the same session received an unrelated C++ currency-service task involving graceful shutdown and startup failure behavior. The environment generated substantial competing telemetry and browser output, including a 2,478,818-character browser_find result that caused the largest retained-context expansion.

The curation method archived 26 tool-result occurrences across nine successful archival batches. The archived text totaled 2,247,229 characters, while the replacement notes totaled 9,709 characters. All archived text and image lists matched the recorded tool returns exactly. No recovery was requested, so the experiment validates storage preservation but does not test whether the model can later identify and retrieve an archived result when it becomes necessary.

The resource differences were substantial:

Metric	Retained history	Reversible curation
Primary prompt at submission	847,674 tokens	124,746 tokens
Final measured prompt	912,492 tokens	231,951 tokens
Peak prompt	912,492 tokens	381,299 tokens
Cumulative input	45,766,146 tokens	22,988,240 tokens
Input plus completion	45,799,980 tokens	23,060,159 tokens
Model requests	121	More than retained
Elapsed time	1,730 s	2,025 s
Estimated API cost	$4.378–$4.379	$1.283–$1.436

At primary submission, the method reduced the measured prompt by approximately 85%. After the C++ follow-up, the final measured prompt was 75% smaller, and peak prompt size was reduced by approximately 58%. Cumulative input and total input-plus-completion usage were each reduced by 50%. The estimated API cost fell by approximately 67–71%, despite reported cache effects.

The implication is specific and operational: when a trajectory contains large tool outputs whose diagnostic role has already been resolved, reversible curation can substantially reduce repeated input and provider charges. The savings do not result from avoiding the initial cost of reading the data. They arise because subsequent requests no longer carry the complete payload.

The resource benefit was not accompanied by a speed advantage. The method produced more than twice as many completion tokens and took 17% longer, with elapsed time increasing by 17%. Additional curation decisions, reminders, tool calls, and altered cache behavior therefore impose measurable overhead. The result supports a resource-efficiency claim, not a latency-reduction claim.

Behavioral outcomes and quality interpretation

Both arms passed the two-case primary behavioral oracle. This establishes that the method preserved the tested checkout behavior despite extensive context eviction. It does not establish full satisfaction of the prose task specification or general behavioral equivalence.

The follow-up C++ task produced mixed evidence. Both candidates compiled. The curation method passed the SIGTERM and SIGINT probes, exiting after 8.43 and 8.85 seconds, respectively. The retained-history candidate failed both probes and was killed with status 137. Conversely, the retained candidate passed the occupied-port startup-failure probe with status 1, whereas the method’s second process failed to finish within 30 seconds. The method therefore displayed stronger tested signal handling but weaker tested startup-failure handling.

A frozen mixed grader assigned 3/6 to the method and 2/6 to retained history. These aggregate scores are difficult to interpret because the grader combines executable process checks with syntax-sensitive static patterns. The method’s implementation called server_ptr->Shutdown(...) rather than the expected server->Shutdown(...), while the retained candidate used signalfd rather than the expected sigwait. Both contained remaining-budget calculations. Inspection also identified a plausible cause of the method’s startup-failure timeout: its failure branch joins a signal-waiting thread without first arranging for that thread to terminate.

The paper appropriately treats the runtime observations as more informative than the aggregate score. The follow-up does not demonstrate a general quality improvement from smaller context. It demonstrates that context curation can coexist with partial behavioral success and partial failure modes that are unrelated to prompt size alone. The study also cannot isolate the effect of the task pivot because each follow-up inherits its own preceding trajectory rather than branching from an identical history.

Workload dependence

The Planroom pair provides a direct counterexample to universal savings. Both conditions supported all twelve assessed browser journeys, but the method ended with 283,105 prompt tokens compared with 265,965 for retained history. Total input plus completion usage was 68,136,934 tokens for the method and 67,669,624 for retained history, a difference of less than 1% in favor of retention. Estimated cost was $3.510–$3.577 for the method and $3.461–$3.465 for retained history.

The method archived 34 results, but these operations removed only 69,685 net history characters. This reduction was insufficient to offset differing generated trajectories and the overhead of context-management actions. The result establishes a concrete workload boundary: frequent archival is not itself evidence of effectiveness. Curation is useful only when the removed payload is sufficiently large, sufficiently repeated, and sufficiently dispensable relative to the overhead it introduces.

The Planroom pair completed faster under the method—24.29 minutes versus 31.78 minutes—but the experiment does not identify the cause. Since the trajectories differ and the comparison contains one pair, the timing result should not be attributed to context curation.

The Sphinx pilot exhibits a related pattern. Every method session ended with a smaller final prompt than every retained session. Two of the three method sessions achieved 24/24 private cases, as did one retained session. Cumulative usage overlapped substantially, and the six sessions concern one authored task under an older configuration. This evidence supports the possibility that context reduction can occur without an immediate accuracy penalty in some trajectories, but it does not establish non-inferiority or generalization.

An earlier browser continuation is more adverse. The method used 63% fewer total tokens but received a manual score of 4/12, compared with 6/12 for retained history. Both answers contained substantive state-machine errors, and a later method-only repetition scored 6/12. Because the repetition was selected after observing the weak result, it cannot replace the original observation as a balanced replication. The episode therefore records a quality loss accompanying resource savings, reinforcing the paper’s central workload-dependence claim.

Limitations and open questions

The principal limitation is the extremely small and development-informed sample. The main OpenTelemetry and Planroom results each consist of a single pair, and the high-noise OpenTelemetry case was selected after earlier experimentation. The Sphinx sessions provide only three runs per arm on one authored task and use a different configuration. There is no randomized task order, held-out task distribution, preregistration, or basis for estimating a universal degradation threshold. Treating requests or grader cases as independent observations would be statistically invalid because they are strongly dependent within trajectories.

The treatment is also composite. The method condition includes context tools, examples, instructions, runtime reminders, and the model’s own selection behavior. No ablation separates these components. The experiments do not compare against chronological eviction, threshold-triggered provider editing, automatic summarization, programmatic filtering, learned context managers, ACON, ACM, or other established baselines. The reported resource reduction therefore cannot be attributed to the specific note-and-archive interface relative to the broader class of context-management methods.

The two arms also encounter different trajectories. In the OpenTelemetry case, retained history contains 275 logical image occurrences while the method contains none. These are repeated input occurrences rather than 275 unique screenshots, but the difference still prevents attribution of the entire resource gap to text archival. Provider accounting does not expose a separate image-cost decomposition.

Semantic safety remains untested. Exact byte-level archive equality establishes that the original payload is preserved, but not that the note is sufficient for future reasoning or that the removed result is genuinely dispensable. The absence of recovery in the central pair leaves retrieval reliability unmeasured. The method may fail because a note is incomplete, because the agent does not recognize when recovery is required, or because recovered evidence arrives at a less useful position as a new result at the conversation end.

Quality evaluation is heterogeneous and imperfect. The primary oracle covers only two behaviors, the currency grader includes static heuristics that can generate false negatives, Planroom evaluation combines trace-based assessment with independent checks, and the adverse browser case uses manual scoring. These measures support descriptive conclusions but not statistical equivalence. The method is also evaluated through one provider model identifier, with unknown checkpoint identity, hardware, cache internals, and determinism. Reported price savings exclude local build, browser, evaluation, and labor costs, and the paper correctly does not infer energy savings from token or price reductions.

The most important open experiment is an identical-history pivot intervention. Both conditions should first produce the same trajectory, after which only the context policy should differ before the unrelated task. A second necessary test should make an archived detail explicitly necessary and measure recovery selection, retrieval success, downstream correctness, and cost. Finally, controlled comparisons against automatic clearing, compacting, filtering, and learned management systems are required to determine whether model-selected per-result notes offer a favorable resource–quality trade-off beyond generic context reduction.

Conclusion

The paper presents a concrete and auditable mechanism for reversible context curation in tool-using agents. In a noisy OpenTelemetry debugging trajectory followed by a task pivot, the method reduced the final measured prompt by 75%, cumulative input by 50%, and estimated API cost by approximately 67–71%, while preserving success on the two primary behavioral tests. These savings were accompanied by more requests, more completion tokens, and 17% greater elapsed time.

The contrasting Planroom result and adverse browser continuation show that smaller active context does not guarantee lower cost, preserved quality, or improved execution. The evidence supports a narrower conclusion: agent-selected archival can be highly effective when large observations become redundant across a long trajectory, but its value is workload-dependent and its semantic risks remain insufficiently measured.