acceptodds
Under review as a conference paper at ICLR 2027

CoReMem: Graph-Organized Memory for Long-Horizon Multi-Agent Collaboration

Abstract

Long-horizon multi-agent systems distribute planning, retrieval, tool execution, and reflection across many roles and interaction rounds. Their histories are nevertheless often stored as separate Agent conversations, summaries, or vector memories. The same event can therefore be duplicated across private stores, different Agents can act on inconsistent versions of shared state, and an outdated intermediate conclusion can continue to influence later decisions. We introduce CoReMem, a graph-organized memory framework that represents Agents, tasks, subgoals, messages, tool outputs, environment states, and deliverables as typed nodes connected by delegation, reference, dependency, conflict, and temporal edges. Before acting, each Agent retrieves a budgeted local memory subgraph conditioned on its current subtask instead of reading the complete history. When an environment state, tool result, or task plan changes, CoReMem versions the updated node, propagates stale status through dependency edges, and rereads, recomputes, or replans only the affected subgraph before restoring current state. All memory organization and consistency maintenance remain external to the frozen language models. Our evaluation protocol tests the framework on long-horizon data analysis, software construction, and evidence synthesis workflows.

Primary area:
foundation or frontier models, including LLMs
Keywords:
Multi-Agent Systems, Long-Horizon Agent Memory, Graph-Based Memory, Dependency-Aware Retrieval, Stateful LLM Agents

Reviews

Among:
Shape:
1234this paper, Bottom 10%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 1.67 over 3 reviews, above 10% of the others.
Reviewer_h1XWOpenReview ↗
Rating
2
Confidence
4
Informativeness
2
Presentation
2
Soundness
1
Read review
Paper summary

The paper introduces CoReMem to address challenges in long-horizon multi-agent collaboration, including fragmented memory, inconsistent shared states, and the persistence of stale information. This method organizes collaboration history into a shared and versioned graph. When executing a task, an agent retrieves only the local subgraph relevant to the current subtask. When upstream information changes, only the affected downstream components are updated following the established dependency relationships. The authors evaluated their approach across nine benchmarks covering reasoning, coding, and knowledge-based tasks.

Critical strengths

The paper focuses on a meaningful problem. Existing multi-agent memory methods mainly focus on retrieving relevant memories, but less consideration is given to whether the memory remains valid after the upstream information has been corrected. The paper updates memory by using dependency relationships rather than semantic similarity. This provides an insightful perspective.

Critical weaknesses
  1. The paper lacks a Related Work section and the comparison with existing work is insufficient. There are many graph-based memory methods for agents like G-Memory [1] , DAMCS [2] and Zep [3], but the paper fails to explain the limitations of these works and why they can not solve the gaps. As a result, the motivation is not well supported.

  2. The paper lacks a clear optimization objective. Section 2.4 states the design goal to keep the task correct after changes while reducing retrieval tokens and recovery operations. However, the paper never turns this into a clear objective or trade-off. The memory retrieval is written as a maximization under a budget constraint, but the objective function itself is not clearly defined. As a result, design choices such as retrieval depth, budget, and the mapping from types to operations have no clear basis, and claims like “achieves a better balance” are hard to verify.

  3. The experiments do not match the motivation. The motivation is about changes in shared state in long-horizon collaboration. But the experiments mainly use short term tasks such as GSM8K and MMLU. Evaluating on long-horizon tasks such as GAIA and SWE-bench can make the results more convincing.

[1] Guibin Zhang et al. G-Memory: Tracing Hierarchical Memory for Multi-Agent Systems. In Advances in Neural Information Processing Systems (NeurIPS), 2025. [2] Hanqing Yang et al. LLM-Powered Decentralized Generative Agents with Adaptive Hierarchical Knowledge Graph for Cooperative Planning. arXiv preprint arXiv:2502.05453, 2025. [3] Preston Rasmussen et al. Zep: A Temporal Knowledge Graph Architecture for Agent Memory. arXiv preprint arXiv:2501.13956, 2025.

  1. The writing and experimental details are not clear enough, which reduces reproducibility. The experiments do not state the backbone LLM, do not provide key hyperparameters such as expansion depth and context budget, and do not report the number of runs or the variance.
Questions for authors
  1. Please clarify how the key components are implemented. For example, is the Checker that decides whether a repair is valid a programmatic check or a prompt-based LLM?

  2. For nodes generated by the LLM, how does the system decide which nodes they depend on? Does it treat all the context retrieved in that step as dependencies, or only the parts that were actually used?

  3. What annotations are used to compute the precision and recall of dependency edges in RQ4?

Reviewer_4HvPOpenReview ↗
Rating
2
Confidence
2
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

CoReMem stores a multi-agent system's history as one shared, versioned graph of typed records, such as tasks, messages, tool outputs, and deliverables, linked by delegation, reference, dependency, conflict, and temporal edges. Each agent reads a budgeted, task-conditioned subgraph, and when an upstream record changes, stale status propagates along recorded dependencies so that only affected records are reread, recomputed, or replanned. Across nine benchmarks, the paper reports the best macro-average, 68.99% against 67.92% for MRAgent, higher state consistency, and recovery at 41.73% of Full Replay cost.

Critical strengths
  1. A coherent, principled state model for shared multi-agent memory. Keeping the whole history in one versioned graph that separates identity from version and verification from validity, retains immutable versions and provenance, and checks freshness at commit time targets concrete failures of fragmented memory. Propagating staleness along recorded dependencies, so that only affected records are reread, recomputed, or replanned, is a well-founded basis for localized recovery.

  2. The evaluation isolates the reader and the recovery policy. The reader study varies only the reader on fixed graphs, and the recovery study varies only the recovery policy on matched traces and changes, with an affected-set reference built independently of the method's predictions. Within these controls, task-conditioned reading improves decision accuracy over fixed-hop reading while using fewer tokens, and its tokens per read grow far more slowly with history size than those of full-history reading. The paper is also candid about where the approach stops helping, such as near-global changes.

Critical weaknesses
  1. The evaluation does not show that the gains carry over to the long-horizon workflows the paper targets. The abstract describes long-horizon data analysis, software construction, and evidence synthesis workflows, but Section 4 evaluates nine standard benchmarks recast as controlled traces. Appendix A.1 states that history length, dependency depth, and the delayed change define this controlled setting rather than being properties of the benchmarks, and how the traces are built is described only at a high level. Even on these traces, CoReMem's lead over the strongest baseline, MRAgent, is 1.07 percentage points overall, with no variance reported and comparisons that the paper itself calls descriptive.

  2. The recovery saving is not an end-to-end cost result. The 41.73% recovery cost is normalized to Full Replay (Appendix D.3), but the paper does not define what the cost measures or which operations it includes. The paper also does not report recovery-specific token, LLM-call, or tool-call counts, does not define the reported latency measure, and does not measure storage footprint or maintenance cost separately.

Questions for authors
  1. Trace construction: How are benchmark items turned into traces with injected revisions, and how many items and revisions underlie task and post-change success?
  2. Recovery accounting: Appendix G.1 distinguishes FDR's uniform replay of recorded-dependency descendants from CoReMem's type-directed local operations, and Appendix C.1 specifies CoReMem's closure over recorded dependency edges. Since both start from recorded dependencies, the propagation-scope difference claimed in G.3 does not explain Table 12's affected-set precision of 91.52% versus 65.37%, with FDR's recall higher at 96.28% versus 94.76%. Beyond G.1's high-level distinction, how do the CoReMem and FDR propagation rules differ, when are affected-set metrics measured, and which operations does the Full Replay cost include, and what are the recovery-specific token, LLM-call, and tool-call counts and the definition of the reported latency measure?
  3. Uncertainty, comparisons, and ablations: What is the run-to-run variance of the Table 1 margins? Since the conclusion's 63.6% stale-error reduction is measured against MAGMA, can you report consistency, stale error, and cost for MRAgent and Graphiti/Zep, and isolate the reader and recovery components?
Reviewer_vQJ2OpenReview ↗
Rating
1
Confidence
3
Informativeness
1
Presentation
2
Soundness
1
Read review
Paper summary

The paper proposes CoReMem, a shared memory for teams of LLM agents. The memory is a graph. Nodes are agents, tasks, subgoals, messages, tool outputs, environment states and deliverables. Each node has versions and a status (current, stale, invalid, superseded). Before an agent acts, it reads a small part of the graph that fits a token budget. When a node changes, the system follows dependency edges, marks the nodes below it as stale, and redoes only that part. The LLMs are frozen. The paper reports results on nine benchmarks and four further studies on reading, recovery, history size and noisy edges.

Critical strengths
  1. Agents that act on old information is a common failure in multi-agent systems.
  2. The design is clean. It keeps "is this checked?" apart from "is this still current?". It also checks, before writing, that what the agent read is still the latest version.
  3. The paper reports where the method stops helping. When almost everything changes, it costs more than replaying everything (103.84%). It also shows what happens when edges are missing or wrong.
Critical weaknesses
  1. The benchmarks do not test the problem the paper claims to solve. The abstract says the method is tested on long data analysis, software building and evidence synthesis workflows. But seven of the nine benchmarks are short, single questions: GSM8K, SVAMP, AQuA, MATH, HumanEval, MBPP and MMLU. The paper never says how these become long tasks with four agents and 128 memory nodes. It also never says what a "delayed change" is in a math question. The results fit this concern: on math and code, the gain over the best baseline is only 0.45 to 1.53 points.
  2. Key details of the experiments are missing. The paper does not name the LLM used. It does not name the retrieval or embedding model, or give the values of B and H ("Medium" is not a value). It does not say how the baselines were run inside the same workflow. It does not say who made the labels R, M* and I*, or how. In several places the paper says it does not know how its own system works, for example: "the aggregate results do not reveal the exact implementation of every checker", "No particular cycle-breaking policy or retry threshold is claimed", and "These measurements do not reveal which individual calls were avoided". Table 4 lists Excel files and cell ranges as the source of the tables. With this, the results cannot be checked or reproduced.
  3. The comparisons are incomplete, and the gains are small. Overall, CoReMem beats MRAgent by 1.07 points. But the consistency, stale error and cost results (Tables 7-8, Fig. 2) and the history study (Table 14) leave out the four strongest baselines: MRAgent, Graphiti/Zep, LightMem and A-MEM. Graphiti/Zep already marks old facts as invalid over time, so it is the closest baseline for the main claim. Map-Graph (Wang et al., 2026) and Governed shared memory (Margalit et al., 2026) also track versions and affected records. They are cited in one sentence but never compared.
  4. The hardest part, finding the dependency edges, is not explained. For text messages, knowing which inputs an output really used is the difficult problem. The paper only says the writer records "assignments, citations, tool inputs, file reads". Table 16 reports edge precision and recall of 95.18 and 93.47, but does not say what the true edges are. The recovery study (RQ3) only compares variants the authors built. Also, local recovery beats Full Replay on post-change success (94.28 vs. 93.16) and replan success (95.46 vs. 91.38). Full Replay redoes everything with the latest inputs, so it should be the upper limit. Please explain this.
Questions for authors
  1. Which LLM is used, and how many runs and task instances are in each table?
  2. How is a GSM8K or MMLU question turned into a four-agent task with 128 nodes and a delayed change?
  3. How are dependency edges created for text messages, and what are the true edges in Table 16?
  4. Why does local recovery beat Full Replay?
  5. How is CoReMem different from build systems, truth maintenance systems and data provenance tools, which also redo only the parts affected by a change?

From OpenReview, CC BY 4.0. Authors as signed there; shown unedited.

Related papers

Loading the map…

Discussion (0)

Sign in to comment.