Self-GC Self-Governing Context for Long-Horizon LLM Agents

Jul 16, 2026

Upload by Ivy

Long-horizon LLM agents accumulate tool results, files, plans, and user constraints that cannot be treated as disposable suffix text. Existing systems rely on run-time heuristics like chronological pruning or late self-summaries, which may hide exact evidence, locators, and editable artifacts. Self-GC treats agent history as lifecycle-governed runtime objects: it indexes turns and tool spans, uses a side-channel planner to fold/mask/prune by future dependency value, and lets a harness enforce recoverable sidecars and safe commit boundaries. Across hard and production suites, it prunes substantially with high no-impact retention and reduces daytime input tokens.

LanguageEnglish

CategoryResearch & Report

FormatPDF

Pages15

Reading Time38 min

Abstract

Introduction

Trade-off in token-buffer context management

Self-GC: object-level lifecycle governance

Validation and results

Self-GC: Self-Governing Context for Long-Horizon LLM Agents Xubin Hao, Hongjin Meng, Xin Yin, Jiawei Zhu, Chenpeng Cao Xiaohongshu {haoxubin, menghongjin, yinxin1, zhujiawei1, [caochenpeng}@xiaohongshu.com](caochenpeng}@xiaohongshu.com) arXiv :2607 .00692v 1 [ cs .AI] 1 Jul 2026 Abstract Long-horizon LLM agents accumulate tool results, files, plans, and user constraints that are too structured to be treated as a disposable text suffix. Current systems mostly rely onin-run heuristics such as chronological pruning and tooloutput masking, or on final self-summary near a context limit. Heuristics are cheap but blind to future dependencies; summaries preserve narrative state but often hide exact evidence, locators, and editable artifacts. We present Self-GC, where GC denotes self-governing context while deliberately echoing garbage collection: the system does not merely reclaim unused tokens, but governs the lifecycle of agent context objects. Self-GC turns user turns, tool spans, and skill state into indexed objects; asks a side-channel planner to propose fold, mask, and prune actions; and lets the harness enforce recoverable sidecars, safe commit boundaries, and cache-aware commit. On a 33-session Hard Set, Self-GC prunes 43.95% of prefix tokens while leaving 84.85% of future continuations unaffected, compared with no-impact rates of 54.55% to 69.70% for heuristic baselines. On a 332-session productionderived suite, three planner backbones reach no-impact rates of 91.27% to 94.58%, while baselines remain at 77.71% to 87.46% . In production, an online account-level split reduces daytime average input tokens by 10% to 15%, with peak reductions near 20%. These results point to context management as runtime lifecycle control over indexed, recoverable objects rather than post hoc text cleanup. Introduction Large language models (LLMs) have rapidly evolved from single-turn assistants into interactive agents that browse the web, invoke tools, edit files, and coordinate multi-step workflows (Liu et al. 2023a; Zhou et al. 2024; Guo et al. 2026) . These agents show strong promise across information seeking, coding, document production, and data analysis. Unlike single-turn prompting, however, a long-horizon agent must carry forward far more than natural-language dialogue. Its active context also accumulates execution traces such as user requests, shell outputs, browser evidence, intermediate artifacts, skill state, and local plans. As the interaction horizon grows, this active context turns into a central runtime resource that directly shapes overall cost, latency, and downstream task quality. However, a critical systems challenge persists, because most deployed context-management mechanisms still treat Figure 1: Object-level context management on a shared agent trace. Token-buffer methods drop future-critical anchors; Self-GC preserves them through fold, mask, and prune with sidecar recovery. agent history as a linear token buffer. One family of methods prunes spans during the run with simple rules over message age, length, and type. Another family waits until the context nears a hard limit and then asks a model to summarize the prior interaction (Cassano and Rush 2026; Xu, Zhang, and Arunachalam 2026) . Both strategies are useful, yet they expose a sharp trade-off. Position-based heuristics cannot tell whether an old tool output holds the only URL, table value, file path, or editable body that a later step still needs. Final summaries preserve narrative state, but they often compress exact evidence into prose that can no longer be addressed, audited, or restored. This work addresses the trade-off by challenging the tokenbuffer view itself. Our key observation is that long-horizon agent context is better understood as a collection of runtime objects with different lifecycle requirements. Some objects are obsolete and can be removed, some are repetitive but should still leave structural hints, and others are bulky

FAQs

What problem does Self-GC address in long-horizon LLM agents?

Self-GC targets the mismatch between linear token-buffer context management and object-level future dependencies that determine whether old tool outputs and artifacts must remain recoverable for later steps.

How does Self-GC decide what to fold, mask, or prune?

Self-GC indexes user turns, tool spans, and skill state into context objects, then uses a side-channel planner to propose fold/mask/prune actions based on reflected future value of those objects.

What do the reported experiments show about pruning impact and efficiency?

On a 33-session hard set, Self-GC prunes 43.95% of prefix tokens while keeping 84.85% of future continuations unaffected, outperforming heuristic baselines. In a 332-session production-derived suite, no-impact rates reach 91.27% to 94.58%, and production account-level splitting reduces daytime average input tokens by 10% to 15%.

Jul 16, 2026

Upload by Ivy