Three papers released the same day address the same problem from different angles: how to reduce the cost of agent memory without losing information.

Zero-Mem takes the most radical approach. It eliminates model calls entirely from memory management: zero tokens consumed on generating intermediate summaries or mediating retrieval. It preserves the original traces of interactions and organizes them in an entity-context graph and a temporal hierarchy. Only the final step, answering the question, calls the LLM. Reported result: 57.6% less time on memory operations compared to the fastest baseline (source: abstract, July 31, 2026).

RecHarness tackles a different angle: automatic model optimization. Instead of letting an LLM handle both direction selection and code generation, it separates the two tasks. A bandit algorithm selects the direction based on historical results; the LLM generates only the concrete hypothesis and code. More stable, less wasted budget.

The third paper shows that a frozen diffusion model can self-guide using its own samples as reference. A signal that generative memory can self-organize without retraining.

Why this matters to you

If you’re building agents that work across long sessions, memory cost is already your bottleneck. As we covered on July 26 with the paper on five primitives of agentic context and AWS’s TAKC approach, memory tokens grow quadratically without compaction. These three papers trace the shift from “memory is free” to “memory must be designed.” Zero-Mem proves you can structure recall without spending tokens to manage it. RecHarness shows that separating decision-making from execution stabilizes search. For those using agents in daily work, the lesson is single: memory architecture matters as much as model choice.

In detail

The problem these three papers tackle became clear in recent weeks. On July 26, an arXiv paper formalized agent memory as a lifecycle with five primitives, showing that cost grows quadratically without compaction. The same day, AWS published TAKC, an approach that pre-compresses entire document bases by analysis type. Both said the same thing: memory is no longer free.

Zero-Mem: remove the model from memory.

Zero-Mem’s core idea is that memory management doesn’t require generation. Most agentic systems use additional LLM calls to summarize, index, or mediate retrieval. Each call costs tokens and time.

Zero-Mem eliminates this overhead. The original traces of interactions remain intact, organized in two complementary views. The first is an entity-context graph that exposes connections between interactions. The second is a temporal hierarchy that preserves conversation locality and session state. For each query, the system weights both views, retrieves from both, and follows their structure to reconstruct support relationships. A deterministic calibration first discards conflicting evidence, then anchors the response to retrieved traces.

Reported result: with the same final reader and same context budget, Zero-Mem reduces memory operation time by 57.6% compared to the fastest baseline. Code release is promised after peer review.

RecHarness: separate decision-making from execution.

RecHarness emerges from Kuaishou, the Chinese short-video platform. The problem is optimizing recommendation models, currently done by engineers iterating manually over architecture, objective function, and training strategy. Leaving both direction choice and code generation to an LLM leads to unstable searches when experiment budget is limited.

The solution separates the two roles. A bandit algorithm (a type that balances exploration and exploitation) selects modification direction based on historical results. The LLM generates only the concrete hypothesis and code. When local changes stagnate, a basin-jump mechanism activates a structural arm that jumps to a different architecture. A seven-day A/B test on a real advertising platform shows measurable improvements: +2.084% on ADVV metric, +0.534% on revenue (source: abstract, July 31, 2026).

The third paper: self-guided diffusion.

The paper on diffusion in pixel space shows a frozen model can improve its own generations using its own samples as guidance. No retraining needed. The connection to agentic memory is indirect but relevant: if a model can self-organize part of its output, there’s room for memory systems that compact without external model calls.

What remains open.

Zero-Mem is tested on question-answering benchmarks, not real agentic workloads with tool calling and multi-turn planning. The code release promise is conditional on peer review. RecHarness works in the specific domain of recommendation, and generalization to other optimization types remains to be shown. The diffusion paper is the most speculative of the three: the connection to agentic memory is an implication, not a result.

Together, though, they sketch a clear trend. Agentic memory cost is becoming a first-order design criterion, not an implementation detail.