Persistent memory is treated as an external runtime artifact. Shows the stability-plasticity dilemma of continual learning resurfaces at the memory level in memory-augmented agents, old and new experiences compete during retrieval under bounded context, and proposes a framework for representing and organizing cross-run experience to maximize transfer while minimizing forgetting, studied on ALFWorld and BabyAI.

Use When Continual Learning Moves to Memory: A Study of Experience Reuse in LLM Agents to carry context, state, and receipts across runs and failures.

Research source arXiv:2604.27003; inspect its method and evaluation before treating results as production evidence.

[2604.27003] When Continual Learning Moves to Memory: A Study of Experience Reuse in LLM Agents

Memory-augmented LLM agents offer an appealing shortcut to continual learning: rather than updating model parameters, they accumulate experience in external memory, seemingly sidestepping the stability-plasticity dilemma of parametric learning. We show that this challenge does not disappear but resurfaces at the memory level. Under a limited context window, old and new experiences compete during retrieval, relocating the continual-learning bottleneck from parameter updates to memory access. To study this phenomenon, we introduce a (k,v) framework that disentangles two fundamental design axes of external memory: how experience is represented and how it is organized for retrieval. Across sequential-task experiments in ALFWorld and BabyAI, we find that abstract procedural memories transfer more reliably than detailed trajectories, while negative transfer disproportionately harms the hard cases. Moreover, finer-grained memory organization is not universally beneficial: designs that yield strong forward transfer can simultaneously induce severe forgetting. Together, these results reveal that external memory does not resolve the continual-learning problem; it reshapes it into a problem of memory representation and retrieval design.


deja-vu

Persistent memory is treated as an external runtime artifact. Memory layer over coding-agent session logs that mines past sessions for reusable context and recalls it into future runs.

Use deja-vu to carry context, state, and receipts across runs and failures.

Inspectable GitHub source (593 stars; 40 forks; MIT license; updated 2026-08-07); popularity is context, not proof of reliability.

Carry context, state, and receipts across runs.

GitHub - vshulcz/deja-vu: Your agents already solved this. deja finds it — it indexes the sessions your coding agents already wrote to disk, months of history from before you installed it, and recalls them automatically at session start across seventeen harnesses. 84.9% hit@1 on LongMemEval-S, no LLM, no embeddings. One zero-dep binary, fully local. · GitHub

Your agents already solved this. deja finds it — it indexes the sessions your coding agents already wrote to disk, months of history from before you installed it, and recalls them automatically at session start across seventeen harnesses. 84.9% hit@1 on LongMemEval-S, no LLM, no embeddings. One zero-dep binary, fully local. - vshulcz/deja-vu


Persistent memory is treated as an external runtime artifact. Oracle's database-native memory layer for long-running agents: task-state retention across extended conversations, procedural knowledge accumulation from prior outcomes, and layered active/passive memory with per-user and per-agent scope control, the second major database vendor (after Tencent) to ship agent memory as a first-class DB substrate.

Use Oracle Agent Memory as an Enterprise Memory Substrate for Long-Horizon AI Agents to carry context, state, and receipts across runs and failures.

Research source arXiv:2607.13157; inspect its method and evaluation before treating results as production evidence.

[2607.13157] Oracle Agent Memory as an Enterprise Memory Substrate for Long-Horizon AI Agents

Agent memory is a systems problem for long-horizon agents. Practical deployments require retention of task state across extended conversations, recovery of user-specific facts and preferences across sessions, and accumulation of procedural knowledge from prior outcomes. These requirements extend beyond document retrieval: a memory layer must determine which interactions become durable state, how that state is scoped, how it is retrieved under latency constraints, and how it is revised or removed over time. This report studies Oracle Agent Memory as a database-native memory substrate built on Oracle Database. Three themes organize the discussion: memory as a lifecycle spanning ingestion, extraction, consolidation, retrieval, summarization, and revision or removal; a layered architecture that separates an active memory core from a passive memory-store interface with explicit scope control across users, agents, and threads; and evaluation methodology in which downstream task accuracy is complemented by memory-centric measures such as evidence retrieval, recall, latency, and estimated token use. The report summarizes LongMemEval results, reaching 93.8% accuracy, compares Oracle Agent Memory against flat-history baselines, using about 10.7x fewer tokens, and published or reported external baselines where available, and closes with implementation-oriented appendix material covering setup, thread lifecycle, and search semantics.

Richmond Alake; Cesare Bernardis; Paul Cayet; Luca Engel; Damien Hilloulin; Sungpack Hong; Allen Hosler; Nickolas Kavantzas; Ingo Kossyk; Son Le; Rhicheek Patra; Kartik Talamadupula; Valentin Venzin

23 pages, 7 figures. Technical report on Oracle Agent Memory


Persistent memory is treated as an external runtime artifact. Cross-platform GUI agent (Android, iOS, HarmonyOS, Windows) with a Know-Route-Act-Reflect loop that accumulates user experience into memory and grows a self-evolving skill library across sessions, a concrete instance of recurring-stateful-loop design applied to personal device automation.

Use KnowAct-GUIClaw: Personal GUI Assistant with Self-Evolving Memory to carry context, state, and receipts across runs and failures.

Research source arXiv:2607.12625; inspect its method and evaluation before treating results as production evidence.

[2607.12625] KnowAct-GUIClaw: Know Deeply, Act Perfectly, Personal GUI Assistant with Self-Evolving Memory and Skill

OpenClaw has emerged as a leading agent framework for complex task automation, yet it faces insufficient cross-platform GUI interaction support and a well-built self-evolution mechanism. These flaws limit its adaptation to diverse device ecosystems and prevent performance improvements through continuous learning from execution experience. To resolve these issues, we propose the Know Deeply, Act Perfectly paradigm for personal assistants, which holds that accumulated user interaction and task-running experience directly improve execution accuracy and efficiency, unifying cognitive comprehension and operational execution. Based on this paradigm, we introduce KnowAct-GUIClaw, a novel Know-Route-Act-Reflect framework designed to address OpenClaw's GUI manipulation deficits and break through its cross-platform and recursive self-improvement constraints. First, the host agent leverages accumulated interaction experience and task-relevant knowledge for long-horizon task decomposition and allocation (Know). Second, a pluggable GUI subagent with an experience-attributable memory system (Know) and self-evolving skill library (Act), enabling seamless cross-platform migration and fast-path integration. Especially, this framework continuously stores user profiles and feedback to improve the accuracy of task decomposition and tool calls. Extensive experiments across Android, iOS, HarmonyOS and Windows show that KnowAct-GUIClaw achieves superior efficiency, accuracy and cross-platform adaptability. Especially, the GUIClaw with open-source Kimi-2.6 models achieves the best performance (64.1%) on the long-horizon MobileWorld benchmark, beating all agentical frameworks and closed-source agentical models, e.g., Seed-2.0-Pro and GPT-5.5. Additionally, the knowledgeable memory and execution skills supported by our framework are transferable across diverse base models, improving by 8.5% with Kimi-2.6.

Yunxin Li; Jinchao Li; Shibo Su; Zhenran Xu; Chenrui Zhao; Tongshu Bian; Xiaoman Liang; Meishan Zhang; Baotian Hu; Min Zhang


Persistent memory is treated as an external runtime artifact. Minimal context-management framework that keeps a complete, structured interaction log as programmatic memory and reuses coding-agent capabilities to search that history rather than stuffing the context window, reporting +18.0 points over a base coding agent on ARC-AGI-3 while using 4.2-5.8x fewer tokens than specialized harnesses.

Use PRO-LONG: Programmatic Memory Enables Long-Horizon Reasoning to carry context, state, and receipts across runs and failures.

Research source arXiv:2607.20064; inspect its method and evaluation before treating results as production evidence.

[2607.20064] PRO-LONG: Programmatic Memory Enables Long-Horizon Reasoning

Long-horizon tasks require sustained perception, reasoning, and exploration, and are a persistent challenge for large language model (LLM) agents. This gap is reflected in their limited performance on continual learning benchmarks such as ARC-AGI-3, especially when models are evaluated out of the box. Various agent harnesses have been proposed to close this gap, and each commits to a strategy for handling long sequences of observations, i.e., what information to save from the environment and how to load it into model context, a choice we argue is particularly consequential. Existing methods for context management face a significant tradeoff, as preserving more information makes retrieving relevant details less tractable. We propose PRO-LONG, a minimal context management framework built around programmatic memory for LLM agents in long-horizon, exploratory settings. PRO-LONG addresses the tradeoff by keeping a complete, structured interaction log and capitalizing on recent progress in coding agents to search this history efficiently. On the full ARC-AGI-3 public game set, PRO-LONG improves over a base coding agent by an average of 18.0 percentage points across frontier models, and matches or exceeds state-of-the-art specialized harnesses (up to 76.1% pass@1) while using 4.2-5.8x fewer tokens. With Fable 5, PRO-LONG achieves 97.4% best@2 at a total cost of \$1,750. Relevant code and logs are available at https://github.com/alexisfox7/PRO-LONG.

Alexis Fox; Junlin Wang; Paul Rosu; Bhuwan Dhingra


engram

Persistent memory is treated as an external runtime artifact. Agent-agnostic persistent memory system for coding agents, shipped as a single Go binary, so lessons, decisions, and context survive across sessions and tools instead of cold-starting each run.

Use engram to carry context, state, and receipts across runs and failures.

Inspectable GitHub source (5,894 stars; 625 forks; MIT license; updated 2026-08-07); popularity is context, not proof of reliability.

GitHub - Gentleman-Programming/engram: Persistent memory system for AI coding agents. Agent-agnostic Go binary with SQLite + FTS5, MCP server, HTTP API, CLI, and TUI. · GitHub

Persistent memory system for AI coding agents. Agent-agnostic Go binary with SQLite + FTS5, MCP server, HTTP API, CLI, and TUI. - Gentleman-Programming/engram


Persistent memory is treated as an external runtime artifact. Position paper arguing coding agents need a second memory tier beyond deliberately authored documents: situationally-bound operational facts (gotchas, locations, conventions) captured as a side effect of work and delivered automatically when situations cue them, implemented as a harness property, not an agent choice. Experiments show cue-anchored injection beats voluntary memory lookup and persists through compactions where agent-managed memories vanish.

Use Delivery, Not Storage: Cue-Anchored Working Memory as a Harness Property for Coding Agents to carry context, state, and receipts across runs and failures.

Research source arXiv:2607.20972; inspect its method and evaluation before treating results as production evidence.

[2607.20972] Delivery, Not Storage: Cue-Anchored Working Memory as a Harness Property for Coding Agents

Coding agents ship with one kind of memory: documents. Instruction files, plan artifacts, and auto-written memory directories are deliberately authored and deliberately retrieved: the agent must choose to write them and choose to read them back. Human expertise runs on a second tier that never gets written down: situationally-bound operational facts (gotchas, locations, local conventions) encoded as a side effect of the work and retrieved involuntarily when the situation cues them. We argue this second tier is the load-bearing one for long-running agents and must be a harness property, not an agent choice. We contribute: (1) a two-tier design theory grounded in the cognitive literature on memory offloading, incidental encoding, and event-based prospective memory, each mapped to an architectural requirement; (2) a cue-anchored memory model where memories carry first-class trigger conditions over a composable vocabulary (path, symbol, semantic, event, temporal), evaluated deterministically by the harness, a composition no surveyed academic or shipped system provides; (3) a controlled evaluation on a real coding task showing that voluntary memory use is near zero even with a pre-seeded store (0 memory operations in 114 turns), that deterministic injection delivered in every seeded run with zero false alarms, and that 39% of intra-session re-reads re-buy content paid for before a compaction boundary; (4) a repeated-compaction decay probe: ten facts held only in conversation vanish at the first summary and stay absent from 106 of 108 compactions, and the deprived agent greps the harness's own session files to rebuild them, while the same facts injected from a harness-owned store arrive intact through all 138 compact-resumes as the final summary carries none. Delivery, not storage, is the product: the reliable memory channel for agents is the one the agent never has to think about.


Evaluation data is used as the feedback signal for improving loop behavior. Interoperability framework that decouples agent memory-system components from deployment environments, standardizing the memory lifecycle through declarative contracts so symbolic, neural, and multimodal memory types, and their evaluation protocols, become interchangeable rather than entangled.

Use MemTools: A Unified Research Framework for Interoperable Agent Memory to carry context, state, and receipts across runs and failures.

Research source arXiv:2607.21404; inspect its method and evaluation before treating results as production evidence.

[2607.21404] MemTools: A Unified Research Framework for Interoperable Agent Memory

While memory systems are essential for agent architectures, pervasive architectural fragmentation restricts systematic research. Existing implementations typically couple different stages of the memory lifecycle, entangle evaluation logic with specific datasets, and provide limited support for the management of heterogeneous memory types. We introduce MemTools, an interoperability research framework that decouples memory system components from their underlying deployment environments. MemTools standardizes the memory lifecycle through declarative data contracts, enabling the interchangeable assembly of components across different systems. It orthogonally separates benchmark datasets from execution protocols to facilitate controlled assessments. Furthermore, MemTools provides a unified computational interface for coordinating symbolic, neural, and multimodal memory representations within a shared runtime. Empirical evaluations on cross-system component integration, evaluation protocol reconfiguration, and heterogeneous memory coordination demonstrate that MemTools enables systematic isolation and analysis of memory design variables. These findings suggest that MemTools provides a practical and extensible infrastructure for advancing principled research on agent memory.

Chengfeng Zhao; Jinhui Chen; Sirui Liang; Shizhu He; Yequan Wang; Jun Zhao; Kang Liu


The work turns loop quality into a measurable task or score. Learns the memory-construction policy itself, what to extract, store, update, compress, or discard, by attributing token-level contributions of stored memory to the final answer and using them as local process rewards, replacing coarse outcome-level RL signals and heuristic memory rules; beats retrieval, heuristic, and RL baselines on dialogue QA with cross-benchmark generalization.

Use AttriMem: Attribution-Guided Process Feedback for Agent Memory Learning to carry context, state, and receipts across runs and failures.

Research source arXiv:2607.21106; inspect its method and evaluation before treating results as production evidence.

[2607.21106] AttriMem: Attribution-Guided Process Feedback for Agent Memory Construction

Effective memory is crucial for LLM agents, yet constructing it effectively remains challenging. A memory-construction policy decides what information to extract, store, update, compress, or discard as interactions accumulate. Heuristic memory methods rely on subjective, task-specific rules, which can misalign with downstream objectives and limit cross-task adaptability. RL-based methods, by contrast, learn from task feedback but mainly use outcome- or module-level rewards. These coarse signals indicate task success but cannot identify which intermediate memory contents support the final answer, creating a fine-grained credit-assignment bottleneck. However, constructing such process feedback is prohibitively difficult because intermediate memory decisions lack unique ground-truth targets, while the appropriate credit varies with the agent's uncertain reasoning trajectory and therefore cannot be specified in advance. We propose AttriMem, an attribution-guided process-feedback framework for learning memory-construction policies with RL. AttriMem augments the global outcome reward with local rewards derived from token-level contributions to the final answer. Experiments on long-horizon dialogue question answering show that AttriMem outperforms retrieval-based, heuristic, and RL-based baselines, generalizes across benchmarks and answer models, stabilizes RL optimization.

Qinfeng Li; Yuntai Bao; Xinyan Yu; Hongze Chen; Yanmin Liu; Wenqi Zhang; Xuhong Zhang


Persistent memory is treated as an external runtime artifact. Reframes agent memory and runaway token cost from a storage-and-retrieval problem to a context lifecycle and architecture problem, arguing production agent failures stem from unmanaged reasoning context (histories, tool definitions, ballooning tool outputs). Proposes five context-management primitives and shows validated compaction yields linear token cost while preserving accuracy (92%/93.2% in a reference implementation).

Use Agentic Context Management: Solving Agent Memory and Cost by Treating Them as Lifecycle and Architecture Problems to carry context, state, and receipts across runs and failures.

Research source arXiv:2607.21503; inspect its method and evaluation before treating results as production evidence.

[2607.21503] Agentic Context Management: Solving Agent Memory and Cost by Treating Them as Lifecycle and Architecture Problems

Production AI agents' failures are less often due to an inability to reason well and more often because they cannot manage what is in their reasoning context: conversation histories, large prompts, large tool definitions, and ballooning tool outputs. Agents drown in their own accumulating history while paying a token cost that grows every turn, producing missing recalls within and across conversations. The incumbent response treats this as a storage-and-retrieval problem. We argue that framing is too narrow. Actively managing what an agent holds in mind is a lifecycle, not merely a store: it spans deciding what to remember, extracting and structuring it, choosing the right store per data type, consolidating and forgetting while preserving provenance, deciding what is relevant now, anticipating what is needed next, and compacting context to a budget without losing what matters. In serious production this operates not over a single user but across an organizational scope hierarchy. We name this discipline Agentic Context Management (ACM) and decompose it into five primitives: architecting, ingesting, scoping, anticipating, and compacting & consolidation. We then make the economic case: naive context accumulation grows token cost quadratically in conversation length, crude summarization buys linear cost at the price of an accuracy cliff, and only validated compaction achieves linear cost with preserved fidelity. We describe a reference implementation, Maximem Synap, that realizes the five primitives as a multi-tenant service and reports 92% on LongMemEval and 93.2% on LoCoMo under the configuration detailed in Section 6. We close with dimensions existing benchmarks do not yet capture, latency, token efficiency, and context-rot resistance, and the frontier of decision-level and organization-level context the category points toward.

23 pages, 6 figures, 4 tables. Evaluation harness and study data: github.com/maximem-ai


Persistent memory is treated as an external runtime artifact. Federated evolution of agent knowledge: heterogeneous agent frameworks iteratively distill, aggregate, and adapt semantic reasoning abstractions so locally-learned experience (workflow reuse, memory) transfers across systems without sharing raw reasoning trajectories, extending memory-driven self-improvement from single-agent loops to a cross-framework collective.

Use FedAgentKE: Federated Semantic Knowledge Evolution for Heterogeneous Agents to carry context, state, and receipts across runs and failures.

Research source arXiv:2607.21361; inspect its method and evaluation before treating results as production evidence.

[2607.21361] FedAgentKE: Federated Semantic Knowledge Evolution for Heterogeneous Agents

Large language model (LLM)-based agents increasingly rely on reasoning, tool use, and iterative execution, yet existing agent frameworks still operate largely in isolation. While recent memory-based agent systems improve individual agents through local retrieval and workflow reuse, local experiences remain fragmented across isolated agent frameworks, limiting cross-framework knowledge transfer and collaborative reasoning evolution. We propose FedAgentKE, a lightweight framework for Federated Semantic Knowledge Evolution across heterogeneous agents. FedAgentKE enables distributed agent frameworks to collaboratively evolve transferable reasoning abstractions through iterative semantic knowledge distillation, aggregation, and adaptation without sharing raw reasoning trajectories. Experiments demonstrate consistent improvements under both cross-framework and cross-task settings, highlighting the potential of federated semantic knowledge evolution for future collaborative agent ecosystems.


Persistent memory is treated as an external runtime artifact. Treats an agent memory write as a database transaction rather than instant truth. Records carry evidence, permissions, provenance, and validity; writes are staged under snapshot isolation and admitted by a validate-and-commit pipeline; irreversible tool calls are gated on in-flight belief state; retracting a belief triggers typed cascading repair of derived records and side effects. Two invariants (action-safety gating, cascade-repair completeness) are stated formally. Rare example of borrowing real DB transaction semantics for multi-agent shared memory.

Use MemTX: Transactional Belief Commit for Stateful Agent Memory to carry context, state, and receipts across runs and failures.

Research source arXiv:2607.23929; inspect its method and evaluation before treating results as production evidence.

[2607.23929] MemTX: Transactional Belief Commit for Stateful Agent Memory

LLM agents increasingly coordinate through persistent shared memory: one agent's write becomes another agent's premise, and eventually a tool call with real side effects. Current agent memory systems treat every accepted write as immediately actionable truth, so a polluted tool result, a stale update, or a teammate's half-finished note can silently drive an irreversible action. We argue that a memory write is not a belief commit. We present MemTX, a transactional belief-commit protocol. Each record carries evidence, permissions, provenance, and validity. Writes are staged inside snapshot-isolated transactions and admitted by a validate-and-commit pipeline, irreversible tool calls are gated on in-flight belief state, and retracting a belief triggers typed cascading repair of its derived records and tool side effects. Two invariants, action-safety gating and cascade-repair completeness, are machine-checked by property-based testing and bounded exhaustive enumeration of 5.5 million protocol states, with zero violations. Across five backbones from three model families, MemTX leads all eight baselines with paired-McNemar significance on four backbones and statistically ties the best baseline on the fifth and strongest, while remaining the only method with zero downstream harm on every backbone. Backbone capability does not substitute for commit discipline.

Xiaoyang Li; Yiqi Wang; Haohui Lu; Zhi Chen; Mo Li; Pingan Song; Mingkai Zheng; Taotao Cai


Persistent memory is treated as an external runtime artifact. Identifies memory contamination -- a hallucinated fact written once persists as a false premise for every subsequent step -- and points out existing memory management handles retrieval and capacity but never write-time correctness. ConsistencyGate is a write-time admission gate that queries the LLM K times for a soft support score and admits only above threshold; model-agnostic, no fine-tuning, and reduces to a single forward pass in a log-probability variant. Pairs naturally with MemTX as the other half of the 'writes are not truth' argument.

Use ConsistencyGate: Preventing Memory Contamination in LLM Agents via Self-Consistency Admission Control to carry context, state, and receipts across runs and failures.

Research source arXiv:2607.22962; inspect its method and evaluation before treating results as production evidence.

[2607.22962] ConsistencyGate: Preventing Memory Contamination in LLM Agents via Self-Consistency Admission Control

LLM agents that operate over many turns accumulate facts in an external memory store and reuse them as premises for downstream reasoning. A hallucinated fact written at one step therefore persists as a false premise for every subsequent step, a failure mode we call memory contamination. Existing memory management addresses retrieval and capacity but not write-time correctness; this admission problem cannot be solved by utility- or recency-based criteria, and uncontrolled contamination compounds across long trajectories. We propose ConsistencyGate, a write-time admission gate that, before committing a candidate fact m extracted from context c, queries the LLM K times for a soft support score and admits m only when the average exceeds a threshold. The mechanism is model-agnostic, requires no fine-tuning, and reduces to a single forward pass in a log-probability variant for latency-sensitive deployments. To measure the effect on natural data, we construct two real-conversation benchmarks (LoCoMo-Contam and MSC-Contam) by planting controlled single-detail corruptions in long-term conversations from LoCoMo and MSC, and complement them with a structured synthetic corpus (MemContam) that isolates a near-oracle upper bound. Across four LLM backbones, ConsistencyGate reduces contamination on every benchmark relative to a write-everything baseline, with the cost concentrated on facts that are stated only implicitly in the source context. We release all three benchmarks together with the gate implementation.

24 pages, 2 figures, 6 tables, 1 algorithm; includes appendices


Evaluation data is used as the feedback signal for improving loop behavior. Inverts the standard agent-memory benchmark pipeline: instead of generating conversations then extracting answer keys (with documented label-error and contamination problems), a seeded life-script sampler emits facts with validity intervals, volatility classes, and source channels before any text exists, then renders chat and email and verifies every planted fact.

Use Ground Truth First: A Longitudinal Evaluation Instrument for Agent Memory, and the Tenure Crossover in Memory-Architecture Rankings to carry context, state, and receipts across runs and failures.

Benchmark or leaderboard source with repeatable tasks or scores; compare systems only after checking setup and scope.

[2607.21962] Ground Truth First: A Longitudinal Evaluation Instrument for Agent Memory, and the Tenure Crossover in Memory-Architecture Rankings

Benchmarks for LLM-agent memory typically generate conversations first and extract answer keys afterwards -- with documented label-error and contamination problems -- and they overwhelmingly measure short interaction histories. We invert the pipeline: a seeded life-script sampler emits facts with validity intervals, volatility classes, and source channels before any text exists; an LLM renderer writes chat and email from per-event fact manifests; a fidelity verifier confirms every planted fact; and questions are instantiated mechanically from the script, so gold answers are script-valid by construction and separately validated for answerability. The synthetic, fictionalized corpus (~380 questions, 15 types) embeds features absent from the benchmarks we survey: per-fact validity intervals, sent/received trust distinctions, injection probes in a benign harness, and as-of-date question sets. Benchmarking five memory architectures against a no-memory control (fixed answerer, versioned LLM judge, three replicates, two horizons), we find backend rankings invert with history length: the budgeted curated-map memory that leads at three weeks loses recall of evicted content by nine weeks (96% to 72%) while a provenance-typed graph rises to 90%; the inversion is positive for all six users under complete cross-family re-judging (exact p=0.031). A full-rendered-history baseline ties or exceeds the best memory system at the short horizon but shows no judge-independent advantage at nine weeks, at about twice the read cost. Write-stage quality strongly correlates with downstream quality (weakly-written facts fail 24% vs 2%), and injection resistance tracked whether provenance boundaries survive representation. A layered architecture performs best among the memory systems in both regimes (96.8% short-horizon) and is released as Veracium, an open-source library, with the corpus generator and harness.

25 pages, 2 figures. Code: https://github.com/veracium-ai/Veracium


Verification is promoted from a final check to a loop-control signal. Exposes the unstated assumption behind every retrieval-based long-term memory system: that a needed memory resembles the query needing it. A stored tree-nut allergy should change the answer to a macaron request via almond flour, yet the two texts share no retrievable cue. InMind is a 125-task expert-verified benchmark across ten life domains (113 tasks grounded in citable public sources) whose paired controls disentangle three conflated explanations -- never stored, no bridging knowledge, or stored and never surfaced.

Use Keep It InMind: Benchmarking the Implicit-Association Blind Spot in Agent Memory to carry context, state, and receipts across runs and failures.

[2607.24368] Keep It InMind: Benchmarking the Implicit-Association Blind Spot in Agent Memory

Long-term memory systems store what a user says in an external store and retrieve it when a related query arrives. This interface rests on an assumption so natural that it is rarely stated: a memory that is needed will resemble the query that needs it. World knowledge breaks the assumption. A tree-nut allergy should change the answer to a macaron request through their almond-flour ingredient, yet the two texts share no cue a retriever can see. We call this failure mode the implicit-association blind spot and introduce InMind, a 125-task, expert-verified benchmark spanning ten life domains, with 113 tasks grounded in citable public sources. Its paired controls separate three explanations that existing evaluations conflate: the fact was never stored, the model lacks the bridging knowledge, or the fact was stored and never surfaced. The verdict is clean. With the decisive memory placed in context, the backbone answers 84.0 percent of indirect queries; when the same memory must be retrieved, six vector, graph, and agentic memory systems reach at most 14.4 percent, even though they recall the same facts on demand at up to 100 percent. An embedding with eight times the dimensionality raises answer-blind target recall for every system yet leaves the gap essentially intact. A minimal diagnostic probe that keeps memory visible before the query arrives recovers most of the gap, locating the failure in the query-conditioned interface itself and pointing to routing, deciding which facts must stay visible, as the open problem InMind is built to score.

Ruizhe Li; Mingxuan Du; Benfeng Xu; Zhendong Mao


Persistent memory is treated as an external runtime artifact. Gives the agent purpose-built context editing tools so it decides when to compress rather than firing on rigid heuristic thresholds, offloading discarded content to external memory and querying it on demand -- lossless context management modeled on short-term/long-term human memory, plus a post-training pipeline that teaches the behavior.

Use ACM: Agentic Context Management for Long Horizon Tasks to carry context, state, and receipts across runs and failures.

Research source arXiv:2607.23809; inspect its method and evaluation before treating results as production evidence.

[2607.23809] ACM: Agentic Context Management for Long Horizon Tasks

Agentic tasks are inherently long-horizon and multi-turn, constantly accumulating context through interactions with the environment. Existing context compression methods inevitably incur information loss and are triggered by rigid heuristic rules, leaving them misaligned with the agent's evolving reasoning focus. We propose Agentic Context Management (ACM), a framework that equips agents with purpose-built context editing tools for lossless context management. Inspired by the interaction between short-term and long-term human memory, the agent autonomously decides when to compress its context, offloads discarded content to an external memory system, and queries it on demand for later retrieval. Building on this framework, we further develop a post-training pipeline that constructs high-quality demonstrations of context management and improves model performance on both agentic search and coding tasks. Further analysis reveals that effective context management reduces peak token pressure, enables extended explorations, and yields more consistent solutions across independent trials. Code, data, and model checkpoints are available at https://github.com/lixiaochuan2020/agentic-context-management.

Xiaochuan Li; Ryan Ming; Meng Chu; Shuai Shao; Rong Jin; Chenyan Xiong


Persistent memory is treated as an external runtime artifact. Challenges the retrieval-as-evidence default where retrieved memories are dumped straight into the answer model, leaving it to resolve redundancy, conflicts, and weak relevance at high context cost. MemChain is a trainable post-retrieval memory policy: generate a question-conditioned evidence plan, build an ordered grounded evidence trace organizing memories by semantic role and dependency, then execute explicit memory actions to emit a compact evidence context. A real processing stage between retrieval and generation.

Use MemChain: Learning Interpretable Memory Traces for Memory-Augmented LLM Agents to carry context, state, and receipts across runs and failures.

Research source arXiv:2607.24097; inspect its method and evaluation before treating results as production evidence.

[2607.24097] MemChain: Learning Interpretable Memory Traces for Memory-Augmented LLM Agents

Memory-augmented LLM agents typically answer queries by retrieving relevant memories and feeding them directly to an answer model. This retrieval-as-evidence paradigm assumes retrieved memories are already suitable for reasoning, leaving the answer model to resolve redundancy, conflicts, and weak relevance while incurring substantial context overhead in long-term memory tasks. We propose MemChain, a trainable post-retrieval memory policy that transforms retrieved candidates into answer-facing active memory, represented as a compact and grounded evidence context. Given a user query and retrieved candidates, MemChain first generates a question-conditioned evidence plan, then constructs an ordered grounded evidence trace that organizes retrieved memories according to their semantic roles and dependencies, and finally executes explicit memory actions to produce a concise evidence context for answer generation. To train the mediator, we introduce a two-stage learning framework. Supervised trace learning first teaches the policy to generate structurally valid plans, traces, actions, and evidence contexts. We then propose Trace-Guided Memory Policy Optimization (TMPO), a reinforcement learning objective that optimizes the memory policy using downstream answer quality while jointly encouraging trace grounding, evidence support, structural validity, and answer stability across multiple rollouts. Experiments on LoCoMo and LongMemEval-S demonstrate that MemChain consistently achieves state-of-the-art performance across both closed-source and open-weight frozen answer models while substantially reducing the memory context passed to the answer model.

Yiwen Ma; Songjun Tu; Qichao Zhang; Dong Li; Linjing Li; Dongbin Zhao


Persistent memory is treated as an external runtime artifact. Recasts bounded working-memory eviction as estimation of a hidden signal (will this item be reused), placing StreamingLLM, H2O, and SnapKV on a single axis: commit lag H. All deployed methods commit at H=0; Belady's optimum sits at full future knowledge. The unexplored middle -- fixed-lag smoothing -- waits a bounded number of steps, observes which items a correct near-future prediction actually attended to, then commits, turning Belady's unobservable future into something read off the model. Instantiated training-free as RMM, a strict generalization of H2O.

Use Eviction as Estimation: A Fixed-Lag Smoothing View of Test-Time Memory, and When Measuring Beats Accumulating to carry context, state, and receipts across runs and failures.

Research source arXiv:2607.24667; inspect its method and evaluation before treating results as production evidence.

[2607.24667] Eviction as Estimation: A Fixed-Lag Smoothing View of Test-Time Memory, and When Measuring Beats Accumulating

A language model with a bounded working memory must repeatedly decide which stored items to keep. Every deployed method decides the moment an item arrives, from the past (StreamingLLM, H2O) or from a guess about the future (SnapKV). We recast the choice as an estimation problem on a hidden signal, whether an item will be reused, placing existing methods on one axis, the commit lag $H$: online filters and learned predictors commit at $H=0$, while Belady's offline optimum sits where the whole future is known. The missing regime in between, fixed-lag smoothing, waits a bounded number of steps, observes which items a correct near-future prediction attended to, and only then commits. This measurement, demonstrated utility, turns Belady's unobservable future request into something we read off the model itself. We instantiate it as a training-free policy, RMM, a strict generalization of H2O that reduces to it exactly when the measurement is uniform. In controlled settings where reuse is endogenous and separated in time, demonstrated utility identifies used memory far better than accumulated attention, and a small bounded memory behaves like a much larger one. But on independent third-party benchmarks, run inside NVIDIA's KVPress harness against its own SnapKV, H2O, and StreamingLLM implementations, the advantage mostly disappears: RMM is on par with H2O for single-turn question answering and loses to both H2O and SnapKV in a streaming multi-turn setting. The cause is simple: on natural text the model is correct about most tokens, so weighting attention by correctness barely changes it, and demonstrated utility collapses onto accumulated attention unless reuse is sharp and endogenous, which standard benchmarks do not exercise. Our contribution is the framework and an honest map of when measuring beats accumulating, not a new state of the art.


Verification is promoted from a final check to a loop-control signal. Argues computer-use agents are over-invested in perception when a screenshot is a lossy rendering of the real target -- files, application backends, DOM. StateAct is a code-first multi-agent harness where the main agent manipulates program state through code and a GUI subagent handles screenshot-and-click only where required (28 of 108 tasks, 1.1% of main-agent steps). The same state access enables an independent finish gate that catches structural failures like missing, unsaved, or misplaced output. Harness design plus a verification gate in one paper.

Use StateAct: Program State, before Pixels, for Long-Horizon Computer-Use Agents to carry context, state, and receipts across runs and failures.

Research source arXiv:2607.22798; inspect its method and evaluation before treating results as production evidence.

[2607.22798] StateAct: Program State, before Pixels, for Long-Horizon Computer-Use Agents

Computer-use agents are usually improved by strengthening perception: better models for reading a screenshot and choosing where to click. Yet a screenshot is only a lossy rendering of the underlying program state, e.g., the files, application backends, and DOM that hold the task data. Different states can produce the same pixels, while code can inspect and modify that state directly. StateAct is a code-first, multi-agent harness built around this distinction. Its main agent works directly with program state by using code, while a dedicated GUI subagent handles screenshot-and-click interaction on the few subgoals that need it, just 28 of 108 tasks and 1.1% of main-agent steps. The same direct access to program state also supports verification: an independent finish gate double-checks the saved result for structural failures, e.g., output that is missing, unsaved, or written to the wrong path. To stay on track over hundreds of steps, the main agent hands subgoals to fresh subagents, keeping its own context focused. On OSWorld 2.0, StateAct lifts Claude Opus 4.8 from 20.6% to 26.9% on binary success, and from 54.8% to 61.6% on partial success, at ~ 9x lower cost per task than the same model driven by screenshots alone; a code-only variant with no GUI subagent reaches only 45.9% partial, below that screenshot-based baseline's 54.8%. In general, grounding action, verification, and memory in state, what we call state-grounding, shifts the main bottleneck from perception toward reasoning: failures depend more on what the agent thinks than on what it sees.

Yan Yang; Xiangru Jian; Ziyang Luo; Zirui Zhao; Yutong Dai; Ziji Shi; Hanshu Yan; Jun Hao Liew; Silvio Savarese; Junnan Li


Verification is promoted from a final check to a loop-control signal. Frames long-horizon embodied policy improvement as execution-guided program search: represent the policy as an inspectable control program, revise it after rollout evaluation, re-execute, compare. Notes that existing LLM-driven evolutionary approaches only select among independently generated variants and skip sequential local improvement entirely. MEMENTO adds a memory-guided single-elite memetic loop and first evolves a rollout evaluator mapping rollouts to scalar fitness -- evolving the verifier alongside the policy is the transferable idea.

Use MEMENTO: Memory-Guided Memetic Code-as-Policy Evolution to carry context, state, and receipts across runs and failures.

Research source arXiv:2607.22832; inspect its method and evaluation before treating results as production evidence.

[2607.22832] MEMENTO: Memory-Guided Memetic Code-as-Policy Evolution

Long-horizon embodied tasks require policies that execute many dependent actions before task success can be observed. Representing policies as executable control pro- grams (code-as-policy) enables their decision logic to be inspected and revised after rollout evaluation. Revised programs can then be executed and compared by rollout performance, framing policy improvement as execution-guided program search. Evo- lutionary methods driven by large language models (LLMs) provide a natural mecha- nism for this search by generating variants and selecting high-performing candidates. However, existing approaches primarily select among independently generated vari- ants and lack a sequential local improvement phase. We introduce MEMENTO, a memory-guided single-elite memetic framework for code-as-policy evolution. ME- MENTO first evolves a rollout evaluator that maps policy rollouts to scalar fitness and structured feedback metrics. Fitness selects accepted candidates and the next elite, while feedback metrics condition policy proposals generated by memory-guided hill-climbing, macro-mutation, and crossover. We evaluate MEMENTO on two long- horizon embodied domains: Robosuite Franka Tower-of-Hanoi manipulation and AI2- THOR household interaction. MEMENTO outperforms Eureka and REvolve, adapted as code-as-policy evolutionary baselines, in task success and generalization to held- out Robosuite object configurations and unseen AI2-THOR scenes. Ablations show that zero-shot generation and unevolved evaluators fail to solve either domain, and that removing policy-search branches reduces performance. Finally, we deploy the best-evolved Robosuite policy on a physical Franka robot, demonstrating the feasibil- ity of sim-to-real transfer of the evolved code-as-policy. Code, prompts, and videos are available at: https://github.com/sygkounas/MEMENTO.

Alkis Sygkounas; Victor Aregbede; Amy Loutfi; Andreas Persson


OptMem

Persistent memory is treated as an external runtime artifact. Created 2026-07-25. Minimalist persistent memory for agents: an append-only LOG.txt plus a binary tree of pairwise summaries at increasing levels, exposed through three commands (`memo wake` to rehydrate at session start, `memo note` to record ≤280 chars, `memo recall <regex>` to search the full log).

Use OptMem to carry context, state, and receipts across runs and failures.

Inspectable GitHub source (1,130 stars; 71 forks; updated 2026-08-07); popularity is context, not proof of reliability.

GitHub - VictorTaelin/OptMem: Permanent memory for AI agents. A 426-token prompt, a script, plug and play. · GitHub

Permanent memory for AI agents. A 426-token prompt, a script, plug and play. - VictorTaelin/OptMem


Persistent memory is treated as an external runtime artifact. Learnable routing tokens arbitrate between an episodic buffer for novel tasks and expandable parametric memory for recurring patterns, addressing stability-plasticity for agents on task streams with no clean task boundaries. The consolidation direction, episodic experience graduating into parameters, is the piece most retrieval-only memory stacks lack.

Use UniMem: Complementary Episodic-to-Parametric Memory for Boundary-Agnostic Task Streams to carry context, state, and receipts across runs and failures.

Research source arXiv:2607.26017; inspect its method and evaluation before treating results as production evidence.

[2607.26017] UniMem: Complementary Episodic-to-Parametric Memory for Boundary-Agnostic Task Streams

Memory is essential for LLM agents to accumulate task experience and reuse task-specific execution strategies. However, real-world deployment over boundary-agnostic and evolving task streams exposes a fundamental stability-plasticity dilemma. External retrieval-based memory can rapidly absorb new evidence, but it often fails to internalize recurring execution patterns and incurs inference-time retrieval overhead. Parametric memory enables stable and efficient execution once learned, but typically relies on explicit task boundaries and fixed parameter budgets. Inspired by the human brain, which balances plasticity and stability through complementary episodic storage and gradual consolidation, we propose UniMem, a self-routing framework for autonomous memory management. UniMem uses learnable routing tokens as memory controllers, enabling adaptive coordination between complementary memory pathways: novel or sparse tasks are retained in an episodic buffer for retrieval-augmented execution, while recurring and reliable patterns are consolidated into expandable parametric memory. By decoupling task identification from task execution with routing tokens and parametric memory blocks, UniMem expands memory on demand without task labels during deployment or uncontrolled parameter growth. Experiments on long-horizon streaming task sequences show that UniMem consistently outperforms baselines while maintaining execution fidelity, achieving an average gain of 4.0 EM points across three backbone models.

Siyu Xia; Chenheng Zhang; Yanting Wu; Haoxuan Li; Jiajun Chai; Xiaohan Wang; Guojun Yin; Wei Lin; Zhouchen Lin; Haifeng Zhang; Jun Wang


Context is managed as durable loop state rather than a single prompt payload. ARC stores tool observations in an append-only addressable log and swaps in compact ID citations under context pressure, letting the agent recall detail without re-running tools, 99.40% on Needle-in-a-Haystack and 29.97% on LongBench-v2 Hard. A concrete alternative to lossy summarization compaction.

Use Addressable Recall Compaction for Long Context-Window Control in AI Agents to carry context, state, and receipts across runs and failures.

Research source arXiv:2607.25066; inspect its method and evaluation before treating results as production evidence.

[2607.25066] Addressable Recall Compaction for Long Context-Window Control in AI Agents

Long-horizon LLM agents accumulate reasoning traces, actions, and tool observations that can eventually exceed a model's fixed context window. Existing compaction methods address this limitation by discarding, summarizing, or retrieving earlier information, but they may remove task-critical details or fail to recover them reliably. We propose ARC (Addressable Recall Compaction), a context-management framework that separates archival storage from active-context presentation. ARC stores tool observations in an append-only, ID-addressable log and replaces older observations with compact citations when compaction is required. The agent can subsequently use these identifiers to request stored content without re-executing the corresponding tools or depending solely on similarity-based retrieval. We evaluate ARC using Qwen3-8B with a 16k context window and Qwen3-32B with a 32k context window. On the Needle-in-a-Haystack evaluation, ARC achieves an average exact-answer accuracy of 99.40%, compared with 88.12% for the best-performing baseline in our evaluation. ARC also reduces estimated serving time and HBM traffic under our hardware-cost model. On the LongBench-v2 Hard subset, ARC obtains an average accuracy of 29.97%, compared with 28.25% for the best-performing baseline. These results indicate that explicit, address-based recall can improve information retention and serving efficiency relative to the evaluated context-management baselines under the tested settings.

Thang Dang; Yuma Ichikawa; Sakina Fatima; Koichi Shirahata


Persistent memory is treated as an external runtime artifact. First systematic study of the now-ubiquitous markdown-files-on-disk memory pattern, asking whether agents can keep a growing store organized and whether that organization actually pays off in retrieval cost, answer quality, and memory health. Evaluates the default memory design most practitioners already run without evidence.

Use Filesystem-Based Memory for LLM Agents: Organization, Evolution, and Sustainability to carry context, state, and receipts across runs and failures.

Research source arXiv:2607.26637; inspect its method and evaluation before treating results as production evidence.

[2607.26637] Filesystem-Based Memory for LLM Agents: Organization, Evolution, and Sustainability

Deployed LLM agents increasingly keep their long-term memory as a filesystem: a directory tree of markdown files that the agent itself reads, writes, and reorganizes through generic file tools. Yet research has largely passed over this medium: prior systems design bespoke memory representations and study retrieval over them, leaving the default's two working assumptions untested: that an agent can keep a growing store organized as memories accumulate, conflict, and go stale, and that this organization pays. We present the first systematic exploration of filesystem-based memory for LLM agents. We formalize the setting as three roles around one memory filesystem: a management agent integrates and organizes incoming content, a search agent answers queries with cited sources, and an execution agent supplies task trajectories that are distilled into skills, unifying declarative memory and skills in a single store. Across long-conversation benchmarks and embodied tasks, we vary memory shape (agent-organized hierarchy, verbatim dump, chunk retrieval), stream scale, tool harness (sandboxed shell, memory-tool-style functions, varied search tooling), and the strengths of the management and search agents, tracking answer quality, cost, and store health as memory grows. What organization reliably buys is search economy: organized stores roughly halve retrieval cost where material is large. Today's agents, however, fall short of the default's promise: in our growth study, organization erodes for all but the strongest management agent, and no agent we measure converts organization itself into better answers. And the model is not the only lever over a store's shape: changing the tool set alone reshapes the store as strongly as swapping the model. The study turns the filesystem default from an assumption into a design space for agent memory.

Sizhe Zhou; Sheldon Yu; Hui Wei; Junda Wu; Siru Ouyang; Yizhu Jiao; Shijia Pan; Julian McAuley; Yu Zhang; Tong Yu; Jiawei Han


Persistent memory is treated as an external runtime artifact. Scores individual memory records with Shapley-style attribution and exposes an interactive dashboard for inspecting memory value, hierarchy, and competing management strategies. Rare tooling for the operator side of agent memory, what is in there, what is it worth, what should be evicted.

Use MemLens: A Value-Aware Memory Management System with Interactive Analytics for LLM-based Agents to carry context, state, and receipts across runs and failures.

Research source arXiv:2607.25992; inspect its method and evaluation before treating results as production evidence.

[2607.25992] MemLens: A Value-Aware Memory Management System with Interactive Analytics for LLM-based Agents

Recently, memory management has become a key infrastructure for LLM-based agents, as it directly affects long-horizon reasoning, personalized responses, and knowledge reuse. However, existing LLM memory systems typically adopt a coarse-grained (utility-agnostic) manner that treats heterogeneous user-LLM interaction records uniformly, leading to redundant and low-impact records persisting in the memory repository. To address this challenge, we present MemLens, a value-aware memory management system that takes memory records as first-class data objects. MemLens provides an end-to-end interactive analytics dashboard that exposes the complete memory lifecycle, including Shapley-style memory evaluation, value-aware storage, and memory-assisted response. Through a study-copilot application, the system enables users to inspect memory values, visualize hierarchical memory structures, and compare various memory management strategies in terms of response quality, retrieval latency, and token consumption. Therefore, our MemLens can serve as an efficient, interpretable, and personalized long-term memory management system for LLM-based agents.

Shuyue Wei; Chang Liu; Zimu Zhou; Yongxin Tong; Lizhen Cui


Control flow is represented as an inspectable graph rather than an opaque prompt loop. Agent-local Neo4j store combining vector indexes with bitemporal modeling so facts carry both valid-time and transaction-time, reaching 46.7% overall recall and 80% on knowledge-update questions where naive stores overwrite silently. Honest about weak temporal-reasoning performance, which is useful signal.

Use A Graph-Native Bitemporal Memory Store for Conversational AI Agents to carry context, state, and receipts across runs and failures.

Research source arXiv:2607.26520; inspect its method and evaluation before treating results as production evidence.

[2607.26520] A Graph-Native Bitemporal Memory Store for Conversational AI Agents

Conversational AI agents commonly lack persistent memory across sessions. The obvious fixes like injecting full chat histories into the context window, or delegating to a third-party memory service, either exhaust the model's context budget or send personal data through infrastructure the user does not control. We describe a memory store that avoids both problems: an agent-local Neo4j property graph augmented with HNSW vector indexes and a full bitemporal data model. Each memory is stored as an immutable identity node linked to versioned content nodes carrying two closed-open time intervals: valid time (when the fact was true in the world) and transaction time (when the database recorded it). This design supports point-in-time semantic retrieval without physically overwriting history. Semantic edges between related memories are maintained automatically at write time using cosine similarity over 1024-dimensional embeddings. We evaluate the system on LongMemEval, a 500-question benchmark spanning six question types designed to stress long-term memory. Across 60 sampled questions, the current-state semantic search path achieves 46.7% R@10 overall, rising to 80% on knowledge-update questions. The time-travel path yields 80% R@10 on knowledge-update but decreases recall on temporal-reasoning questions (50% to 37.5%), a consequence of post-filter dilution that points directly to a concrete design improvement. We discuss what these results reveal about the limits of pure retrieval for different question types and what each failure mode suggests for future work.


Control flow is represented as an inspectable graph rather than an opaque prompt loop. Organizes past trajectories into a directed graph linking high-level skills to executable action templates across several relation types, then retrieves task-relevant subgraphs at inference to guide skill switching and action selection. Turns accumulated experience into navigable structure rather than a flat trajectory pile.

Use HiSkill: Empowering LLM Agents with Hierarchical Skill Graphs to carry context, state, and receipts across runs and failures.

Research source arXiv:2607.25853; inspect its method and evaluation before treating results as production evidence.

[2607.25853] HiSkill: Empowering LLM Agents with Hierarchical Skill Graphs

Skills have become an important abstraction for enabling large language model (LLM) agents to reuse past experience in long-horizon interactive tasks. However, existing trajectory-to-skill methods often produce flat collections of high-level textual skills that are stored and retrieved independently, leaving skill relations underutilized and maintaining a gap between high-level skills and executable actions. In this paper, we propose HiSkill, a hierarchical skill graph framework that organizes interaction trajectories into a directed graph with skill nodes, AtomicOp nodes, and typed edges. Specifically, the graph connects reusable high-level skills with executable action templates, while also capturing decomposition, temporal transition, compatibility, support, and recovery relations among them. At inference time, HiSkill retrieves a compact task-relevant subgraph and performs subgraph-guided task execution, where a symbolic task state, an active skill, and the retrieved subgraph guide the LLM agent to switch skills, select AtomicOps, and ground executable actions iteratively. Experiments on three interactive environments show that HiSkill outperforms state-of-the-art baselines while reducing inference token consumption, demonstrating the effectiveness of bridging high-level skills and executable action grounding through a hierarchical skill graph. Our data and code is available at https://github.com/BUPT-GAMMA/HiSkill.

Yu Hao; Jinxuan Cai; Qi Zhang; Yawen Li; Zhiqiang Zhang; Chuan Shi; Cheng Yang


Context is managed as durable loop state rather than a single prompt payload. Names an invariance race between cutting redundancy and preserving task-relevant code, then organizes retrieved evidence by code object with companion selection to raise recall while spending fewer tokens. Sharpens the context-budget problem specific to repository-scale coding loops.

Use VITAL-RAG: Invariance Race for Context Allocation in Coding Agents to carry context, state, and receipts across runs and failures.

Research source arXiv:2607.26937; inspect its method and evaluation before treating results as production evidence.

[2607.26937] VITAL-RAG: Invariance Race for Context Allocation in Coding Agents

Coding agents often retrieve code from an entire repository, but only limited evidence can fit into the final model input. Conventional retrieval-augmented generation (RAG) for coding agents treats fragments from the same code object as separate results, so redundant views can occupy multiple context positions and crowd out useful code. Grouping fragments by code object reduces this redundancy, but can discard local information needed for the task. We describe this tension as an invariance race: allocation should stay stable under redundant renderings but change when a fragment adds task-relevant semantics. To address this race, we introduce VITAL-RAG, which organizes evidence by canonical code object, keeps one query-relevant companion only when it adds semantics not already represented, and renders selected evidence under per-object and global token budgets. On RepoBench, VITALRAG improves Recall@4K from 39.59% to 63.67% while reducing evidence tokens by 35.63%. Across three model backends, it matches or outperforms recent baselines on RepoClassBench and achieves the highest raw Pass@1 on RepoExec.

Zijian Lu; Yonghua Lu; Mingcai Chen; Yiping Zuo; Xin He; Weijun Wang; Weibei Fan


Context is managed as durable loop state rather than a single prompt payload. Maintains lexical, dense, and structural views per repository commit that persist incrementally across code changes, giving agents ranked search and symbol navigation at far fewer tokens than grep-driven exploration. Treats repo context as a served, versioned index rather than something re-derived every session.

Use CodeNib: A Multi-View Data System for Serving Repository Context to Coding Agents to carry context, state, and receipts across runs and failures.

Research source arXiv:2607.25431; inspect its method and evaluation before treating results as production evidence.

[2607.25431] CodeNib: A Multi-View Data System for Serving Repository Context to Coding Agents

Coding agents repeatedly search, navigate, and retain context from evolving repositories, but disconnected indexes, language servers, and task-local histories force repeated discovery and obscure lifecycle costs. CodeNib builds reusable lexical, dense, and structural views per repository commit, maps outputs to repository-relative source ranges, maintains selected views across edits, and serves ranked search, symbol navigation, and bounded context through one runtime. Across 100 snapshots, we map quality-cost frontiers across the repository-context lifecycle. When outputs match an independent rebuild, graph and vector updates are $8.7\times$ and $25.4\times$ faster at the median. On the static-navigation subset matching normalized live-server locations (63% of 1,000 requests), the median per-request live/static latency ratio is $4.7\times$. Across five models, selected context policies preserve localization with 50--87% fewer trajectory tokens than paired grep/read. Together, these results support multi-view repository-context serving with explicit, operation-specific validity boundaries.

Zhongming Yu; Hengjia Yu; Boqin Yuan; Shuting Zhao; Yizhao Chen; Aryan Dokania; Mihir Jagtap; Jiayu Chang; Yitong Ma; Yash Jayswal; Wentao Ni; Hejia Zhang; Zhaoling Chen; Gangda Deng; Jishen Zhao


Makes persistence and context management visible as runtime design choices. Simon Willison's practitioner read on what the 2026-07-28 MCP specification revision actually changes for people running agents at scale.

Use Stateless MCP Has Recaptured My Interest to carry context, state, and receipts across runs and failures.

Contextual source from simonwillison.net; useful for practice signals or boundary conditions, not independent validation.

Stateless MCP has recaptured my interest (and inspired mcp-explorer and datasette-mcp)

Tuesday was Stateless MCP day—the rollout of MCP 2.0, or the 2026-07-28 Model Context Protocol specification to use the more formal but less memorable name. This is the most significant …


Durable execution and replay are treated as first-class loop infrastructure. Applies database transaction semantics to agent memory: an Ordered PatchTest validates every write against its source, a Temporal Resolver picks versions, and a durable snapshot journal recovers complete state after corruption. This is the memory-durability primitive most long-running loops lack, writes are gated, not appended blindly.

Use MemTxn: A Transaction Boundary for Source-Supported Updates and Complete-State Recovery in Agent Memory to carry context, state, and receipts across runs and failures.

Research source arXiv:2607.27834; inspect its method and evaluation before treating results as production evidence.

[2607.27834] MemTxn: A Transaction Boundary for Source-Supported Updates and Complete-State Recovery in Agent Memory

Persistent memory lets long-running large language model agents reuse information across sessions and tasks. Yet errors in writable memory can persist and corrupt future behavior. Existing systems improve storage and retrieval, but they do not provide a transaction boundary for reliable updates and recovery. We therefore propose MemTxn, a governance layer outside the answer model. MemTxn verifies whether an update is supported by its source. It also selects the visible version when facts conflict and restores the application-visible state after a fault. The system uses Ordered PatchTest to validate writes, a Temporal Resolver to select versions, and a durable snapshot journal to recover state. On an item-disjoint audit, MemTxn accepts all 60 supported originals and rejects all 179 hard negatives. Under persistent multi-key faults on LongMemEval-S and LoCoMo states, it restores the complete declared active map without knowing the actual physical write set. On MemoryAgentBench FactConsolidation, MemTxn achieves the highest average F1 across all twelve answer-model configurations. It outperforms Dense by 17.06--24.07 points in five representative settings.

Hanshuai Cui; Zhiqing Tang; Zhi Yao; Fanshuai Meng; Qianli Ma; Weijia Jia


Persistent memory is treated as an external runtime artifact. Asks whether structured memory access requires generation at all, and answers no. Most agent memory systems spend extra LLM calls generating intermediate records and mediating retrieval, adding recurring token and latency cost while merged or omitted details obscure the original evidence.

Use Zero-Mem: Zero-Token Memory Operations for LLM Agents to carry context, state, and receipts across runs and failures.

Research source arXiv:2607.29377; inspect its method and evaluation before treating results as production evidence.

[2607.29377] Zero-Mem: Zero-Token Memory Operations for LLM Agents

LLM agents need memory to act consistently over long interactions, yet many systems use additional LLM calls to operate that memory. Generating intermediate records and mediating their retrieval adds recurring token and time costs, while omitted or merged details can obscure the original evidence. We ask whether structured memory access requires generation at all. Zero-Mem introduces \emph{zero-token memory operations}: no step outside final question answering invokes an LLM or consumes LLM input or output tokens; encoder computation is accounted for separately. Zero-Mem preserves original interaction traces as its source of record. It organizes the traces in two complementary ways. An entity--context graph exposes connections across interactions, while a temporal hierarchy preserves conversational locality and session state. For each query, Zero-Mem weighs the two views, retrieves from both, and follows their structure to recover supporting relations or surrounding context. Deterministic calibration first discards conflicting evidence and then keeps the reader's answer grounded in the retrieved traces. Only the final-QA reader invokes an LLM. Across long-memory and long-context question-answering benchmarks, Zero-Mem achieves competitive performance while eliminating LLM calls and LLM-token consumption from memory operations. With the same final-QA reader and context budget, it reduces memory-operation time cost by 57.6\% relative to the fastest compared baseline. Ablations support the contribution of the two views and their query-dependent coordination. Overall, the results show that structured agent memory need not generate an intermediate representation of the past. After peer review, the code and implementation details will be available at \textcolor{blue}{https://github.com/TheMoon0815/Zero-mem}.

Yilin Xiao; Zhehan Zhu; Yujing Zhang; Jin Chen; Zijin Hong; Luyao Zhuang; Qinggang Zhang; Shengyuan Chen; Xiaocao Ouyang; Lingfei Ren; Xiao Huang


Makes persistence and context management visible as runtime design choices. Repair agents treat every issue independently and throw away the procedural knowledge from previous repairs.

Use Reusing Past Repairs Through Hierarchical Trajectory Abstraction for Coding Agents to carry context, state, and receipts across runs and failures.

Research source arXiv:2607.29658; inspect its method and evaluation before treating results as production evidence.

[2607.29658] Reusing Past Repairs Through Hierarchical Trajectory Abstraction for Coding Agents

Although LLM-driven repair agents can tackle complex, repository-level issues, they treat every issue independently and discard the procedural knowledge accumulated from previous repairs. We introduce STAIR, a framework that converts historical repair trajectories into hierarchical, reusable plans that can be adapted to steer future repairs. Each past trajectory is transformed into a multi-level tree that ranges from fine-grained diagnostic actions to high-level repair strategies, encoding experience at several granularities. When a new issue arrives, STAIR selects relevant plan nodes from multiple abstraction levels, tailors them into executable, issue-specific plans, and supplies them to the agent through its prompt. On SWE-bench Verified, STAIR integrated with Lingxi reaches 81.2% Pass@1 using MiniMax M2.5 and 79.2% using GPT-5. The generated plans also generalize across agents: without any code change, they lift the Pass@1 of a structurally different agent, mini-SWE-agent v2, from 75.8% to 81.0%. Ablation experiments further show that mixing multiple abstraction levels surpasses any single level and that raw, unabstracted trajectories transfer substantially worse.

Yisen Xu; Jiayuan Zhou; Ruiqi Pan; Tse-Hsun Chen


Durable execution and replay are treated as first-class loop infrastructure. Argues that treating retrieved experience as a static record to replay causes negative transfer when past runs do not match present state, and trains a unified policy (GRPO) that reconstructs memory conditioned on the current state instead.

Use MemHarness: Memory Is Reconstructed, Not Replayed to carry context, state, and receipts across runs and failures.

Research source arXiv:2607.28272; inspect its method and evaluation before treating results as production evidence.

[2607.28272] MemHarness: Memory Is Reconstructed, Not Replayed

Retrieving past experiences has become a common strategy to enhance large language model agents. However, most existing memory-augmented agents treat retrieved experiences as static records to be replayed verbatim, injecting them into the context regardless of whether they align with the agent's current situation. This ``replay'' paradigm ignores the gap between the abstract, general nature of stored experience and the concrete, ever-changing states encountered at decision time, frequently causing negative transfer. In contrast, humans rarely recall past experiences verbatim; instead, they reorganize and adapt retrieved memories to fit the present context. Inspired by this, we propose MemHarness, a framework that equips LLM agents to actively harness and reconstruct past experiences based on the present context. At each decision step, a unified policy model critiques and reconstructs the retrieved experience conditioned on the current state, producing context-grounded guidance before acting. This reconstructive ability emerges naturally through end-to-end training with GRPO. Experiments on ALFWorld and WebShop show that MemHarness substantially outperforms pure RL and static memory-augmented baselines, demonstrating strong robustness in out-of-distribution (OOD) scenarios. Furthermore, our analyses reveal that this reconstruction objective not only prevents negative transfer but also serves as latent guidance during training, fundamentally improving the agent's intrinsic reasoning capabilities.

Rong Wu; Daocheng Fu; Licheng Wen; Xuemeng Yang; Shu Zou; Jianbiao Mei; Yuxin Wang; Hairong Zhang; Yu Yang; Tao Hu; Cong Zhang; Botian Shi; Pinlong Cai


The work turns loop quality into a measurable task or score. Commits a memory snapshot on every write and supports natural-language rollback requests via hybrid retrieval, so an agent can inspect and revert prior memory states rather than living with whatever it last wrote. Claims to be the first open-source system plus benchmark for systematic semantic global memory rollback.

Use ChronoMem: Version Control and Semantic Rollback for Large Language Model Agent Memory to carry context, state, and receipts across runs and failures.

Research source arXiv:2607.27773; inspect its method and evaluation before treating results as production evidence.

[2607.27773] ChronoMem: Version Control and Semantic Rollback for Large Language Model Agent Memory

LLM agents increasingly rely on long-term memory to support multi-session interaction and personalization. However, existing agent memory systems are designed around forward-only evolution, continuously accumulating, consolidating, and overwriting knowledge, with no principled mechanism to inspect, version, or revert prior states. This makes agents brittle under corrections, concept drift, and memory corruption, particularly after they have already been exposed to subsequent information. We present ChronoMem, a semantic version-control layer for agentic memory integrated into the production-ready, open-source Agent Development Kit by Google. ChronoMem commits whole-memory snapshots at each memory write, maintains structured version histories, and supports natural-language rollback requests by mapping undo intents to concrete historical versions through hybrid lexical and semantic retrieval, rank fusion, and reranking. We further introduce a post-exposure evaluation protocol that tests whether an agent can behave counterfactually after rollback by answering queries and summarizing history as if future updates had never occurred. On long-horizon conversational benchmarks augmented with evolving memory states and rollback tasks, ChronoMem substantially improves rollback-consistent question answering and history summarization relative to prompt-only and retrieval-only baselines, while achieving strong performance in semantic version selection. To our knowledge, ChronoMem is the first open-source system and benchmark for systematic semantic global memory rollback in LLM agents.

Yongye Su; Wujiang Xu; Chaoji Zuo; Elisa Bertino


Persistent memory is treated as an external runtime artifact. Maintains symmetric matrices of per-peer competence and peer-relationship evidence, updated online from correctness feedback with spectral bounds for stability, then reuses that memory for residual steering, response-free peer routing, or reliability-weighted voting.

Use Σ-Mem: An Online Reliability Memory for LLM-based Multi-Agent Systems to carry context, state, and receipts across runs and failures.

Research source arXiv:2607.27958; inspect its method and evaluation before treating results as production evidence.

[2607.27958] $Σ$-Mem: An Online Reliability Memory for LLM-based Multi-Agent Systems

Memory is central to long-horizon LLM agents, yet existing memory systems primarily preserve interaction content rather than modeling which agents can be trusted and under what conditions. This limitation is particularly important in multi-agent systems, where a central model may be unable to directly verify plausible or correlated peer responses. We introduce $\Sigma$-Mem, an online reliability memory that records historical competence evidence for individual peers and peer relationship evidence across the peer set. Both forms of evidence are maintained as real symmetric states and updated from post-decision correctness feedback. By Weyl's inequality, the spectral change caused by each event-level update is bounded, enabling stable online adaptation without retraining the underlying models. $\Sigma$-Mem provides a general write-and-read interface: the same memory can be used for residual steering of a central model, response-free peer routing, or reliability-weighted voting. Across five Qwen-family models, $\Sigma$-Mem adapts to counterfactual reliability shifts and generalizes to unseen peers and task domains. Direct memory readouts also outperform majority voting and the best fixed peer over the full OOD evaluation set. Moreover, performance improves consistently as more correctness feedback becomes available, indicating that $\Sigma$-Mem progressively accumulates actionable reliability information. These results establish reliability memory as a reusable foundation for adaptive coordination in LLM-based multi-agent systems.

Peilin Feng; Suorong Yang; Soujanya Poria


State persistence is explicit enough for repeated runs and handoff. Treats a persistent, evolving skill document as the agent's carried state across a sequence of tasks, rather than as a retrieval index consulted per task.

Use SkillRise: Agentic Reinforcement Learning for Cross-Task Skill Evolution to carry context, state, and receipts across runs and failures.

Research source arXiv:2607.26784; inspect its method and evaluation before treating results as production evidence.

[2607.26784] SkillRise: Agentic Reinforcement Learning for Cross-Task Skill Evolution

Large language model agents often encounter related yet distinct tasks that share reusable solution patterns. Yet standard agentic reinforcement learning treats tasks as independent episodes, while existing approaches to skill learning either focus on repeated attempts of one task or use pipelines with multiple stages that entangle extraction, retrieval, and execution. We introduce SkillRise, a unified reinforcement learning framework for learning skills across tasks. SkillRise organizes related instances into progressively challenging sequences and uses a single policy to alternate between task solving and curating an evolving skill document passed directly to the next task. Decoupled credit assignment across tasks supervises solving with the current task outcome and curation with discounted downstream outcomes. Experiments on ALFWorld, WebShop, and ScienceWorld show that SkillRise achieves the strongest Pass@1 performance among the compared methods, with gains over the strongest baseline ranging from 2.3 to 8.5 percentage points. Although trained across distinct tasks, its learned curation policy remains effective for repeated attempts on the same task. Further analysis reveals scaling at test time across tasks: performance improves with longer sequences of related tasks even when each task is attempted only once. This trend suggests that SkillRise reuses transferable skills across tasks rather than benefiting from repeated sampling of the same task. SkillRise further retains strong performance while substantially reducing the runtime overhead of skill learning pipelines with multiple stages. Together, these results provide a simple and efficient training paradigm for LLM agents to extract, refine, and reuse transferable skills across tasks.

Zhiyuan Yao; Yuxin Chen; Zhengxi Lu; Zishan Xu; Yueqing Sun; Yifu Guo; Yuquan Lu; Zhengzhou Cai; Kangning Zhang; Zhuowen Han; Zi-Han Wang; Ziang Ye; Qi Gu; Xunliang Cai; Weiwen Liu; Yongliang Shen


Orchestration And Multi-Agent Delegation

AutoGen

The work separates roles across agents, verifiers, or orchestration layers. Multi-agent programming framework for conversations, tool use, and orchestration; active development has moved to the Microsoft Agent Framework.

Use AutoGen to choose an implementation surface for repeatable agent work.

Inspectable GitHub source (60,292 stars; 9,080 forks; CC-BY-4.0 license; updated 2026-08-07); popularity is context, not proof of reliability.

Choose runtimes, tools, and delegation surfaces.

GitHub - microsoft/autogen: A programming framework for agentic AI · GitHub

A programming framework for agentic AI. Contribute to microsoft/autogen development by creating an account on GitHub.


Microsoft Agent Framework

The work separates roles across agents, verifiers, or orchestration layers. Microsoft's successor to AutoGen and Semantic Kernel for building and orchestrating multi-agent workflows in Python and .NET.

Use Microsoft Agent Framework to choose an implementation surface for repeatable agent work.

Inspectable GitHub source (12,654 stars; 2,125 forks; MIT license; updated 2026-08-07); popularity is context, not proof of reliability.

GitHub - microsoft/agent-framework: A framework for building, orchestrating and deploying AI agents and multi-agent workflows with support for Python and .NET. · GitHub

A framework for building, orchestrating and deploying AI agents and multi-agent workflows with support for Python and .NET. - microsoft/agent-framework


LangGraph

Control flow is represented as an inspectable graph rather than an opaque prompt loop. Graph-based framework for controllable agent workflows, persistence, and human-in-the-loop steps.

Use LangGraph to choose an implementation surface for repeatable agent work.

Inspectable GitHub source (39,108 stars; 6,578 forks; MIT license; updated 2026-08-07); popularity is context, not proof of reliability.

GitHub - langchain-ai/langgraph: Build resilient agents. · GitHub

Build resilient agents. Contribute to langchain-ai/langgraph development by creating an account on GitHub.


CrewAI

The work separates roles across agents, verifiers, or orchestration layers. Framework for multi-agent workflows organized around roles, tasks, and crews.

Use CrewAI to choose an implementation surface for repeatable agent work.

Inspectable GitHub source (56,732 stars; 8,087 forks; MIT license; updated 2026-08-07); popularity is context, not proof of reliability.

GitHub - crewAIInc/crewAI: Framework for orchestrating role-playing, autonomous AI agents. By fostering collaborative intelligence, CrewAI empowers agents to work together seamlessly, tackling complex tasks. · GitHub

Framework for orchestrating role-playing, autonomous AI agents. By fostering collaborative intelligence, CrewAI empowers agents to work together seamlessly, tackling complex tasks. - crewAIInc/crewAI


LlamaIndex Workflows

Shows how delegation, handoff, and workflow control turn one agent into a coordinated loop. Event-driven workflow abstraction for agentic applications.

Use LlamaIndex Workflows to choose an implementation surface for repeatable agent work.

Primary documentation from a platform, SDK, standard, or framework; strong implementation signal.


OpenAI Agents SDK handoffs

Shows how delegation, handoff, and workflow control turn one agent into a coordinated loop. First-class delegation between specialized agents.

Use OpenAI Agents SDK handoffs to choose an implementation surface for repeatable agent work.

Primary official documentation from openai.github.io; use it for current product or standard behavior.


Agent Protocol

Shows how delegation, handoff, and workflow control turn one agent into a coordinated loop. API protocol for agent interaction, useful for separating loop managers from agent runtimes.

Use Agent Protocol to choose an implementation surface for repeatable agent work.

AgentProtocol.ai — AI agent protocols explained

AgentProtocol.ai is an independent, vendor-neutral guide to AI agent communication standards — MCP, A2A, Agent Protocol and interoperability.


AgentKit

Durable execution and replay are treated as first-class loop infrastructure. TypeScript toolkit for durable, event-driven agents on workflow infrastructure.

Use AgentKit to choose an implementation surface for repeatable agent work.

Inspectable GitHub source (918 stars; 139 forks; Apache-2.0 license; updated 2026-08-06); popularity is context, not proof of reliability.

GitHub - inngest/agent-kit: AgentKit: Build multi-agent networks in TypeScript with deterministic routing and rich tooling via MCP. · GitHub

AgentKit: Build multi-agent networks in TypeScript with deterministic routing and rich tooling via MCP. - inngest/agent-kit


deepagents

Shows how delegation, handoff, and workflow control turn one agent into a coordinated loop. LangChain project for deeper, longer-running agents with middleware and harness patterns.

Use deepagents to choose an implementation surface for repeatable agent work.

Inspectable GitHub source (27,470 stars; 3,836 forks; MIT license; updated 2026-08-07); popularity is context, not proof of reliability.

GitHub - langchain-ai/deepagents: The batteries-included agent harness. · GitHub

The batteries-included agent harness. Contribute to langchain-ai/deepagents development by creating an account on GitHub.


Temporal for AI

Durable execution and replay are treated as first-class loop infrastructure. Durable execution for long-running agent workflows: crash-proof state, automatic retries, and human-in-the-loop signals.

Use Temporal for AI to choose an implementation surface for repeatable agent work.

AI Applications & Agents With Temporal | Temporal

Build the most capable AI applications and agents on Temporal's open foundation, powered by durable execution


Restate

Durable execution and replay are treated as first-class loop infrastructure. Durable execution runtime for building resilient, stateful agents and workflows that survive failures mid-loop.

Use Restate to choose an implementation surface for repeatable agent work.

Working implementation, framework, runtime, or repository; signal comes from usable code and ecosystem adoption.

Restate - Build innately resilient distributed apps

Restate is a lightweight runtime that lets developers build innately resilient distributed apps without the complexity tax.


DBOS

Durable execution and replay are treated as first-class loop infrastructure. Lightweight PostgreSQL-backed durable execution library for crash-proof agent workflows, queues, and scheduled triggers.

Use DBOS to choose an implementation surface for repeatable agent work.

DBOS is an open source durable execution and workflow orchestration system that radically simplifies the development and operation of reliable, observable workflows.


Composio Agent Orchestrator

Workspace isolation is part of the loop design, not an afterthought. Orchestrates parallel coding agents in isolated worktrees that plan tasks, fix CI failures, respond to reviews, and manage their own PR lifecycle.

Use Composio Agent Orchestrator to choose an implementation surface for repeatable agent work.

Inspectable GitHub source (8,843 stars; 1,297 forks; Apache-2.0 license; updated 2026-08-07); popularity is context, not proof of reliability.

GitHub - Untrivial-ai/agent-orchestrator: Agent IDE that enables you to manage fleets of coding agents. It comes with an agentic orchestrator that plans tasks, spawns agents, and autonomously handles CI fixes, merge conflicts, and code reviews. · GitHub

Agent IDE that enables you to manage fleets of coding agents. It comes with an agentic orchestrator that plans tasks, spawns agents, and autonomously handles CI fixes, merge conflicts, and code reviews. - Untrivial-ai/agent-orchestrator


Omnigent

Shows how delegation, handoff, and workflow control turn one agent into a coordinated loop. Databricks' open-source meta-harness and control plane that runs Claude Code, Codex, Cursor, and Pi under shared policies, with budget caps and human-approval gates enforced at the harness layer rather than in prompts.

Use Omnigent to choose an implementation surface for repeatable agent work.

Inspectable GitHub source (8,249 stars; 1,245 forks; Apache-2.0 license; updated 2026-08-07); popularity is context, not proof of reliability.

GitHub - omnigent-ai/omnigent: Omnigent is an open-source AI agent framework and meta-harness: orchestrate Claude Code, Codex, Cursor, Pi, and custom agents — swap harnesses without rewriting, enforce policies and sandboxing, and collaborate in real time from any device. · GitHub

Omnigent is an open-source AI agent framework and meta-harness: orchestrate Claude Code, Codex, Cursor, Pi, and custom agents — swap harnesses without rewriting, enforce policies and sandboxing, and collaborate in real time from any device. - omnigent-ai/omnigent


Control flow is represented as an inspectable graph rather than an opaque prompt loop. Replaces opaque agent loops with immutable plan-version DAGs and a planning-execution-recovery split, giving inspectable scheduling, deterministic recovery, escalation, and termination guarantees.

Use From Agent Loops to Structured Graphs: A Scheduler-Theoretic Framework for LLM Agent Execution to choose an implementation surface for repeatable agent work.

Research source arXiv:2604.11378; inspect its method and evaluation before treating results as production evidence.

[2604.11378] From Agent Loops to Structured Graphs:A Scheduler-Theoretic Framework for LLM Agent Execution

The dominant paradigm for building LLM based agents is the Agent Loop, an iterative cycle where a single language model decides what to do next by reading an ever growing context window. This paradigm has three structural weaknesses: implicit dependencies between steps, unbounded recovery loops, and mutable execution history that complicates debugging. We characterize the Agent Loop as a single ready unit scheduler: at any moment, at most one executable unit is active, and the choice of which unit to activate comes from opaque LLM inference rather than an inspectable policy. This perspective places Agent Loops and graph based execution engines on a single semantic continuum. We propose SGH, Structured Graph Harness, which lifts control flow from implicit context into an explicit static DAG. SGH makes three commitments: execution plans are immutable within a plan version, planning execution and recovery are separated into three layers, and recovery follows a strict escalation protocol. These choices trade some expressiveness for controllability, verifiability, and implementability. Our contributions are fourfold: a scheduler unified framework that applies classical scheduling theory to LLM agent execution and identifies challenges introduced by non deterministic LLM nodes; a trade off analysis of controllability, expressiveness, and implementability across 70 surveyed systems; a formal specification including a node state machine with termination and soundness guarantees; and an attributable experimental framework with a seven group design for future validation. This is a position paper and design proposal. We provide a theoretical framework, design analysis, and experimental protocol, not a production implementation or empirical results.


Eve

Durable execution and replay are treated as first-class loop infrastructure. Vercel's TypeScript-native agent framework with durable execution, sandboxed compute, and OpenTelemetry tracing built in, so recurring agent work persists, replays, and is observable across runs by default.

Use Eve to choose an implementation surface for repeatable agent work.

Inspectable GitHub source (4,435 stars; 427 forks; Apache-2.0 license; updated 2026-08-07); popularity is context, not proof of reliability.

GitHub - vercel/eve: The Open Framework for Building Agents · GitHub

The Open Framework for Building Agents. Contribute to vercel/eve development by creating an account on GitHub.


Control flow is represented as an inspectable graph rather than an opaque prompt loop. Decomposes work into a dependency-aware DAG, runs domain agents in parallel, and uses an LLM verifier to drive adaptive replanning with configurable stop conditions, the verify-and-replan core of a reliable loop.

Use Verified Multi-Agent Orchestration: A Plan-Execute-Verify-Replan Framework to choose an implementation surface for repeatable agent work.

Research source arXiv:2603.11445; inspect its method and evaluation before treating results as production evidence.

[2603.11445] Verified Multi-Agent Orchestration: A Plan-Execute-Verify-Replan Framework for Complex Query Resolution

We present Verified Multi-Agent Orchestration (VMAO), a framework that coordinates specialized LLM-based agents through a verification-driven iterative loop. Given a complex query, our system decomposes it into a directed acyclic graph (DAG) of sub-questions, executes them through domain-specific agents in parallel, verifies result completeness via LLM-based evaluation, and adaptively replans to address gaps. The key contributions are: (1) dependency-aware parallel execution over a DAG of sub-questions with automatic context propagation, (2) verification-driven adaptive replanning that uses an LLM-based verifier as an orchestration-level coordination signal, and (3) configurable stop conditions that balance answer quality against resource usage. On 25 expert-curated market research queries, VMAO improves answer completeness from 3.1 to 4.2 and source quality from 2.6 to 4.1 (1-5 scale) compared to a single-agent baseline, demonstrating that orchestration-level verification is an effective mechanism for multi-agent quality assurance.

Xing Zhang; Yanwei Cui; Guanghui Wang; Wei Qiu; Ziyuan Li; Fangwei Han; Yajing Huang; Hengzhi Qiu; Bing Zhu; Peiyang He

International Conference on Learning Representations

Published in ICLR Workshop on Multi-Agent Learning: Generalization and Adaptation in Intelligence (MALGAI); the linked arXiv record remains available for open access.


Control flow is represented as an inspectable graph rather than an opaque prompt loop. Organizes how agent workflows are fixed ahead of time or generated and revised per run, and which evaluation signals drive that choice, a map of the design space for recurring loops.

Use From Static Templates to Dynamic Runtime Graphs: A Survey of Workflow Optimization for LLM Agents to choose an implementation surface for repeatable agent work.

Research source arXiv:2603.22386; inspect its method and evaluation before treating results as production evidence.

[2603.22386] From Static Templates to Dynamic Runtime Graphs: A Survey of Workflow Optimization for LLM Agents

Large language model (LLM)-based systems are becoming increasingly popular for solving tasks by constructing executable workflows that interleave LLM calls, information retrieval, tool use, code execution, memory updates, and verification. This survey reviews recent methods for designing and optimizing such workflows, which we treat as agentic computation graphs (ACGs). We organize the literature based on when workflow structure is determined, where structure refers to which components or agents are present, how they depend on each other, and how information flows between them. This lens distinguishes static methods, which fix a reusable workflow scaffold before deployment, from dynamic methods, which select, generate, or revise the workflow for a particular run before or during execution. We further organize prior work along three dimensions: when structure is determined, what part of the workflow is optimized, and which evaluation signals guide optimization (e.g., task metrics, verifier signals, preferences, or trace-derived feedback). We also distinguish reusable workflow templates, run-specific realized graphs, and execution traces, separating reusable design choices from the structures actually deployed in a given run and from realized runtime behavior. Finally, we outline a structure-aware evaluation perspective that complements downstream task metrics with graph-level properties, execution cost, robustness, and structural variation across inputs. Our goal is to provide a clear vocabulary, a unified framework for positioning new methods, a more comparable view of existing body of literature, and a more reproducible evaluation standard for future work in workflow optimizations for LLM agents.

Ling Yue; Kushal Raj Bhandari; Ching-Yun Ko; Dhaval Patel; Shuxin Lin; Nianjun Zhou; Jianxi Gao; Pin-Yu Chen; Shaowu Pan


Agent-as-a-Router

Verification is promoted from a final check to a loop-control signal. Agentic model routing for coding agents reframed as a context-action-feedback loop (ACRouter: orchestrator, verifier, memory) that learns which LLM to route each task to from execution feedback rather than frozen priors, with the CodeRouterBench benchmark across 8 frontier models.

Use Agent-as-a-Router to choose an implementation surface for repeatable agent work.

Inspectable GitHub source (1,082 stars; 18 forks; MIT license; updated 2026-08-07); popularity is context, not proof of reliability.

GitHub - LanceZPF/agent-as-a-router: The official implementations of Agent-as-a-Router: Agentic Model Routing for Coding Tasks. · GitHub

The official implementations of Agent-as-a-Router: Agentic Model Routing for Coding Tasks. - LanceZPF/agent-as-a-router