Can the same compress-then-act pattern work for agent state memory?
This explores whether the 'compress-then-act' move — squeeze down history, then operate on the distilled version — transfers cleanly to an agent's running state and memory, or whether agent memory has properties that make naive compression backfire.
This explores whether the 'compress-then-act' pattern transfers to agent state memory — and the corpus says: yes, but only when the compression is gated, structured, and matched to what the task actually needs. The optimistic case is real. DeepAgent's autonomous memory folding consolidates raw interaction history into episodic, working, and tool schemas, cutting token overhead while still letting the agent pause and rethink strategy Can agents compress their own memory without losing critical details?. An external, RL-trained manager can do the squeezing for a frozen agent, adaptively pruning context so the agent acts on a cleaner state Can external managers compress context better than frozen agents?. So the pattern works — but notice both cases add *structure* and *control* to the compression rather than just shrinking text.
The sharpest warning comes from the failure side. When agents continuously consolidate textual memory, utility follows an inverted-U: early compression helps, then it actively hurts, eventually performing *worse* than just keeping raw episodes — one model re-failed 54% of problems it had previously solved, through misgrouping, stripping away the conditions that made a memory applicable, and overfitting to narrow streams Does agent memory degrade when continuously consolidated?. That's the crux: 'compress-then-act' assumes the distilled state preserves what you'll need to act on. For agent memory, compression often discards exactly the situational detail that made a past action correct.
This is why granularity turns out to be the whole game. Agent memory works best when its abstraction level matches the domain — workflow-level summaries for routine-rich tasks, causal rules for environment-rich ones, and fine-grained state-action pairs for spatial web tasks Does agent memory work better at one level of abstraction?. For web agents specifically, indexing procedures by environment state and the local action taken beats high-level workflow abstractions, because aggressive summarization loses the click-by-click specifics Does state-indexed memory outperform high-level workflow memory for web agents?. In other words, the more you compress, the more you risk throwing away the part of state that distinguishes 'act here' from 'act there.'
The deeper reframing is that agent failure in long workflows usually isn't a knowledge gap — it's weak *control* over memory. Bounded, schema-governed committed state with explicit gating (separating what gets recalled from what gets permanently written) prevents the error accumulation and constraint drift that plague transcript-replay and naive retrieval Can agents fail from weak memory control rather than missing knowledge?. RAISE makes the same point from a design angle: agent memory decomposes into distinct components at different time scales, each needing its own update policy How should agent memory split across time scales?. So the real successor to 'compress-then-act' isn't compression at all — it's *adaptive* memory that forms, refines, and prunes links from execution feedback rather than collapsing everything on a fixed schedule Should agent memory adapt dynamically based on execution feedback?.
Worth knowing for the curious: you can push this so far that memory operations *replace* weight updates entirely — AgentFly treats learning as a memory-augmented decision process and hit 87.88% on GAIA without touching model parameters Can agents learn continuously from experience without updating weights?, while the Thread Inference Model structures reasoning as recursive subtask trees with rule-based KV-cache pruning, sustaining accurate reasoning even after discarding 90% of the cache Can recursive subtask trees overcome context window limits?. The lesson across all of it: compression is safe when it's *governed by what the agent will do next*, and dangerous when it's a blind summarization step run on a timer.
Sources 10 notes
DeepAgent's autonomous memory folding consolidates interaction history into episodic, working, and tool memory schemas. This reduces token overhead while letting agents pause to reconsider strategies—the autonomy and structure together avoid degradation that plagues poorly designed consolidation.
An external RL-trained manager can adaptively prune context for frozen agents, with the key insight that stronger agents benefit from high-fidelity preservation while weaker agents need aggressive compression to stay reliable.
LLM-consolidated textual memory degrades as experience accumulates, eventually performing worse than episodic-only retention. GPT-5.4 failed 54% of previously-solved problems after consolidation, with three mechanisms identified: misgrouping, applicability stripping, and overfitting on narrow streams.
Workflow-level memory wins in routine-rich domains, causal-rule memory in environment-rich domains, and state-action memory in spatially-rich web tasks. The optimal abstraction depends on whether task variance comes from arguments, causal structure, or fine-grained UI state.
PRAXIS shows that indexing procedures by environment state and local action pairs yields consistent accuracy and reliability gains across VLM backbones on the REAL benchmark, compared to higher-level workflow abstractions that lose click-by-click specifics.
Agent performance degrades in long workflows because transcript replay and retrieval-based memory lack gating mechanisms. A bounded, schema-governed committed state that separates artifact recall from permanent memory write prevents error accumulation and constraint drift.
RAISE shows that agent memory consists of four components organized by two design axes: dialogue-level (conversation history, scratchpad) versus turn-level (examples, task trajectory). This granularity distinction predicts different failure modes and update policies for each component.
FluxMem demonstrates that adaptive memory topology—where links form, refine, and consolidate based on closed-loop execution feedback—consistently reaches state-of-the-art across three distinct benchmarks. Dynamic connectivity outperforms fixed retrieval by aligning abstraction and eliminating interference.
AgentFly formalizes agent learning as a Memory-augmented MDP with three memory modules (case, subtask, tool) that enable credit assignment and policy improvement entirely through memory operations. The approach achieved 87.88% on GAIA validation without modifying LLM parameters.
The Thread Inference Model demonstrates that reasoning structured as recursive subtask trees with rule-based KV cache pruning sustains accurate reasoning beyond context limits, even when manipulating 90% of the cache. This enables single models to replace multi-agent systems by handling full recursive reasoning internally.