Agentic Context Management: paper reframes agent memory and cost as architecture problems

Agents drown in their own context

An arXiv preprint that reached Hacker News's front page argues that when production AI agents fail, the cause is rarely weak reasoning. According to the paper, submitted on 23 July 2026 by Gaurav Dadhich, the more common culprit is everything sitting inside the model's context: conversation histories that keep growing, oversized prompts, sprawling tool definitions, and tool outputs that expand with every call. The agent sinks under its own history while the token bill climbs turn after turn — and it still misses information stated earlier in the same conversation, or in a previous one.

The paper's central claim is that the industry's default response — treating this as a storage-and-retrieval problem solved by bolting a memory store onto the agent — is too narrow a frame. What agents actually need, the author argues, is active management of what they hold in mind: a lifecycle that spans deciding what to remember, extracting and structuring it, picking the right store for each kind of data, consolidating and deliberately forgetting while preserving provenance, working out what is relevant right now, anticipating what is needed next, and compacting context to a budget without discarding what matters. In production, the paper adds, this has to operate across an organizational scope hierarchy, not just for a single user.

Five primitives

The preprint names this discipline Agentic Context Management (ACM) and decomposes it into five primitives: architecting, ingesting, scoping, anticipating, and compacting and consolidation. Mapped loosely onto the lifecycle above, architecting covers decisions about what deserves to be remembered; ingesting covers extraction, structuring and store selection per data type; scoping covers relevance and the organizational hierarchy; anticipating covers predicting what the agent will need next; and compaction and consolidation cover budgeted shrinking, merging and forgetting.

The cost argument

The economic case is where the framing becomes practical. With naive context accumulation — resending the full history every turn — token cost grows quadratically with conversation length, since each new turn re-transmits everything that came before. Crude summarization flattens the curve to linear growth, but the paper says this comes at the price of a sharp drop in accuracy. The author's claim is that only what the paper calls validated compaction achieves linear cost while preserving fidelity. For teams running long-lived agents, that is a line-item argument, not an academic one.

A reference implementation

To show the primitives are buildable, the paper describes Maximem Synap, a reference implementation that realizes them as a multi-tenant service. It reports 92% on LongMemEval and 93.2% on LoCoMo, two long-term conversational memory benchmarks, under the specific configuration detailed in the paper. The usual preprint caveats apply: this is a single-author paper that has not been peer-reviewed, and the numbers are tied to one configuration rather than an independent evaluation.

Where benchmarks fall short

The paper closes by arguing that existing benchmarks miss the dimensions that matter most in deployment: latency, token efficiency, and what it calls resistance to context rot. It also points toward a further frontier — decision-level and organization-level context — suggesting the category extends well beyond per-conversation memory.

Why it matters

If the diagnosis holds, memory stops being a bolt-on retrieval component and becomes an architectural concern with explicit lifecycle stages and budget-versus-fidelity tradeoffs. For agent builders, the framing converts a vague "my agent forgets things" complaint into a concrete engineering checklist, and it turns token cost from a fixed tax into a designable curve: quadratic by default, linear only with deliberate compaction. The organizational scoping point matters for anyone deploying agents across teams and tenants rather than single users. The flagged benchmark gaps — latency, token efficiency, robustness as context degrades — also mean current leaderboards cannot tell you whether a memory system will survive production. The traction the paper found on Hacker News suggests many builders already recognize the problem, even if the tooling to measure solutions is still catching up.