acceptodds
Under review as a conference paper at ICLR 2027

Structured Memory Linking Objects and Concepts for Embodied Manipulation Agents

Abstract

Long-horizon embodied manipulation requires agents to reuse interaction knowledge while tracking changing objects and scenes. A past successful action may become inapplicable when an object's state changes, and its motion parameters may not transfer to another instance with different geometry. Reusing manipulation experience therefore requires memory to connect object-part geometry with action applicability and execution parameters, while tracking changing object states and scene relations. These requirements motivate a part-based representation with reusable structure, instance-specific geometric parameters, and interfaces to manipulation functions. We propose Object–Concept Linked Memory (OCLM), which uses object code representations to link grounded objects and reusable part templates to scene, transition, and skill memories. At runtime, the agent retrieves relevant objects, scene states, action outcomes, and skills to check applicability and select or parameterize template-grounded or policy-grounded execution. Observations and execution feedback update the associated memories, retaining reusable structural knowledge alongside evolving interaction history. Experiments on memory-dependent manipulation, articulated-object transfer, and real-world tasks show improvements in task success, retrieval accuracy, object re-identification, and cross-object skill transfer over the evaluated unstructured and embedding-based memory baselines.

Primary area:
foundation or frontier models, including LLMs
Keywords:
Memory, Embodied Agent, Manipulation

Reviews

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

This paper proposes a structured memory framework called OCLM. This framework is designed to address the challenges of reusing interaction knowledge and tracking states in long-horizon embodied manipulation tasks. The experimental results shows the effectiveness of the proposed framework.

Critical strengths
  1. The introduction is logical and clear, which describes the motivation of the proposed OCLM well.
  2. The experimental results (especially in Table 1-3) indeed show the effectiveness of the proposed OCLM.
Critical weaknesses
  1. The ablation study on the whole Object–Concept Linked Memory is missing. The ablation in Table 4 removes individual memory components but retains the overall OCLM architecture, the same LLM, and the same tool chain. While this shows which specific memory component matters most, it fails to isolate the Object–Concept Linked Memory itself. It is suggested to add an additional baseline using the same agent and the same perception tools but relying on a simple short-term or vector-based memory instead of structured memory. Without this, the large performance gap between Ours(DP) (71%) and the standalone DP (7%) cannot be definitively attributed to OCLM rather than to the strong LLM and tool chain.

  2. The comparisons with SOTA VLA methods are missing. The paper compares OCLM primarily with memory-based baselines (e.g., MemER, RoboEXP) and treats rapidly evolving end-to-end VLA models merely as "memory-less" black boxes. The paper’s impact would be significantly strengthened if it demonstrated how OCLM could serve as a plug-and-play module to enhance the long-horizon capabilities of existing SOTA VLA models, or if it provided a fairer, more detailed comparison under equivalent computational budgets.

Questions for authors
  1. The paper claims OCLM provides a "compact" memory representation, but why are there no quantitative storage measurements (e.g., byte size or growth curve) to support this claim?
3 comments

Thank you for these valuable suggestions on isolating the contribution of memory, evaluating integration with stronger VLA executors, and quantifying storage costs. Following your comments, we have clarified the shared-stack controls and added storage measurements and analysis to the appendix.

1. Whole-memory replacement controls

[W1] Sec. 5.1 identifies Ours(DP)'s 71% versus standalone DP's 7% as the combined agent and memory effect. The targeted comparison is the flat-record baseline in Table 4: it retains the same agent, perception tools, and execution capabilities, but serializes memory facts into flat records and uses embedding retrieval instead of structured cross-memory retrieval. It achieves 59%, versus OCLM's 71%. The generic-object-record control achieves 62%. Sec. 5.4 and App. B.1 distinguish these replacement controls from component-removal ablations. They assess memory organization/retrieval and template-linked representation within the shared stack.

2. Integration with a stronger VLA executor

[W2] OCLM provides memory to the high-level agent, while a VLA serves as a policy-grounded skill; this interface is described in Secs. 4.1.2/4.4 and App. E.3. The agent uses memory to coordinate subtasks and invokes the executor for local actions. Reliable execution can require subtask-specific fine-tuning.

[W2] To examine this integration, we conducted an additional real-world search experiment with π0.5. The standalone baseline was fine-tuned on 50 teleoperated demonstrations, each comprising placing an object into a drawer and grasping the corresponding handle. It achieved 4/20 successes (20%). For OCLM integration, π0.5 was fine-tuned on handle-pulling subtasks with ten demonstrations per handle location. The agent coordinated the search through OCLM and invoked these skills, achieving 16/20 successes (80%). We report these additional results here. This experiment demonstrates that OCLM can work with a fine-tuned π0.5 executor on a memory-dependent task. Since the configurations use different fine-tuning demonstrations, the results compare the integrated systems.

3. Storage measurements and growth

[Q1] App. B.4 and Fig. 5 now distinguish measured object-record storage from projected scene-level growth. On 131 matched parameterized assets (48 laptops, 48 faucets, 35 buckets), compact Concept records occupy 85,411 bytes, versus 1,144,579 bytes for one 640×480 JPEG per object plus metadata. JPEGs are code renders at quality 90; storage is measured in serialized bytes.

[Q1] Fig. 5 compares Concept Memory (with Prior Knowledge), Concept Memory (Record Only), Video Memory, and keyframe memory. The prior-knowledge curve adds the measured local template source once: 1,060,961 bytes across 14 categories and 84 Python files in the local source collection. The projection assumes ten objects per scene, one new object every five subsequent scenes, 1 KiB scene metadata per scene, and retention of ten JPEG frames or keyframes per scene. The inset makes the initial template overhead explicit. Video Memory models retained JPEG frames. The projection includes template function source and object/scene records; Transition/Skill histories and retrieval indexes are excluded.

I thank the authors for the added storage measurements and the π0.5 experiment. Two points remain.

W1. The flat-record (59%) and generic-object-record (62%) controls still retain long-term memory, differing from OCLM only in memory organization. They isolate "structured vs. flat memory," not "memory vs. no long-term memory." Please add a short-term-memory-only baseline (same LLM, tools, and execution stack, no persistent structured memory) to directly isolate OCLM's gain.

W2. As the authors note, the two π0.5 configurations use different fine-tuning demonstrations (50 vs. 10 per handle location), so the 20% vs. 80% gap cannot be attributed to OCLM. Please either re-run under an identical demonstration and compute budget, or explicitly downgrade this to a case study and report the training/inference compute costs of both settings.

Response to W1

Thank you for this suggestion. We added a short-term-only baseline with the same LLM, concept templates and perception/grounding tools. At each subtask boundary, agent context and dynamic memory are reset; structured scene information is rebuilt using only the preceding subtask segment and current observation. The task instruction is retained, but earlier history is unavailable.

TaskSR
Rearrange Blocks28%
Put Back Block18%
Swap Blocks19%
Swap T34%
Battery Try14%
Blocks Ranking Try15%
Cover Blocks5%
Mean19%

Using 100 rollouts per task, short-term-only achieves 19% versus OCLM's 71%, now reported in Table 4. This decrease is consistent with RMBench's reliance on history beyond the preceding subtask. Although short-term memory is insufficient to retain the full task history, recent spatial changes, together with the agent's understanding of the task and access to the shared tools, can still provide enough information to complete some tasks in a limited fraction of trials.

Response to W2

Because the standalone VLA and agent-based system differ in their execution workflows and fine-tuning demonstrations, the current experiment does not provide a fully controlled comparison. Following your recommendation, we present it as an integration case study. The table below summarizes the resource usage, configurations, and performance of both systems under the same training and inference hardware, with a common 60 s episode limit that includes model inference latency.

ItemStandalone π0.5OCLM + π0.5
Number of demonstrations5090: ten at each of nine handle locations
Mean demonstration duration16.4 s6.8 s
Total demonstration duration821 s612 s
Recording frequency30 Hz30 Hz
Training hardware4 × NVIDIA H200 Tensor Core GPU4 × NVIDIA H200 Tensor Core GPU
Training epochs1212
Inference GPUNVIDIA GeForce RTX 5090NVIDIA GeForce RTX 5090
GPU-memory usage during inference15.3 GB22.6 GB
LLM inference latency per episodeNot applicable35.4 s, included in the 60 s limit
Additional high-level LLM tokensNone33,066 input + 336 output tokens
Wall-clock time limit per episode60 s60 s
Successful trials within 60 s4/2016/20
Success rate within 60 s20%80%

With demonstration data of a comparable scale, this integration case study demonstrates the potential of OCLM to improve VLA performance on memory-dependent tasks with manageable additional GPU-memory and LLM-token costs (under USD 0.50).

Reviewer_1NUHOpenReview ↗
Rating
2
Confidence
3
Informativeness
2
Presentation
2
Soundness
1
Read review
Paper summary

The paper proposes Object–Concept Linked Memory, or OCLM, an LLM-agent memory that links grounded objects, modeled as parametric part templates from analytic concepts, to a scene graph, state-transition records and skill records, with coarse-to-fine retrieval and verified write-back. Using GPT-5.6 Sol as planner, it reports up to 71% average success on seven RMBench tasks against 53% for Mem-0, gains of 2.5 to 10.6 points over A3VLM and ManipLLM on PartNet-Mobility transfer, and 84% against 56% for a MemER-style baseline on five real-robot tasks.

Critical strengths

The memory is built to be executed rather than merely retrieved, which is how it lifts a fixed DP policy from 7% to 71% success on RMBench.

The system is evaluated broadly, from simulation and articulated-object transfer to a dual-arm robot, and the ablations in Table 4 show clearly what each memory component contributes.

Critical weaknesses
  1. Novelty over prior work is limited, because Appendix A.1 states that the part templates, parameter estimators and program synthesis in Figure 2 follow the analytic concepts of Sun et al. 2024 and 2025, and the closely related work on executable analytic concepts, arXiv 2510.07975, is not cited. The four dynamic stores also mirror uncited designs such as Voyager's skill library, ExpeL's experience memory, Statler's world state, ConceptGraphs scene graphs and REFLECT's failure summaries, so the contribution rests on keying them to template types, which only the generic-object-record ablation tests at 62% against 71% success.

  2. The core operators appear only as notation, and the paper omits the weights and threshold of Sk,jS_{k,j}, how skill preconditions and effects are extracted from successful runs, whether coarse retrieval and skill abstraction are LLM prompts or index lookups, and the prompts themselves. Training data for the Point Transformer regressor, the only learned part of OCLM, is not described, and because the template library is never updated online, parts without a matching template, such as the deformable objects left to future work, fall outside its scope.

  3. The comparisons do not isolate the memory design, since most RMBench baselines are end-to-end policies while OCLM adds a frontier LLM, SAM 2, FoundationPose, a learned regressor and scripted primitives, and on this stack the flat-record variant in Table 4 already reaches 59%, above Mem-0's 53%. The DP, π0.5 and Mem-0 entries in Table 1 are identical to RMBench's own Table 1 although Mem-0 is marked as manually tested, dropping two of RMBench's nine tasks lifts Mem-0's average from 42.0% to 53%, and each entry is one 100-episode batch without confidence intervals.

Questions for authors
  1. How are the preconditions and effects of a template-grounded skill derived from a successful execution, and could you give the prompts or index logic behind coarse retrieval and skill abstraction along with the values of λg\lambda_g, λT\lambda_T, λr\lambda_r and the identity threshold? What does the agent do when a detected part matches no template in MtempM_{\text{temp}}, given that the library is never extended online?

  2. Does FoundationPose run in model-based mode with a CAD mesh for every object, and on what data is the Point Transformer regressor trained for each template type? In the RMBench and real-robot settings, are poses and part parameters estimated from RGB-D or read from simulator state and known object models?

  3. Were the DP, π0.5 and Mem-0 entries in Table 1 re-run or taken from RMBench, what does OCLM score on Observe and Pick Up and Press Button, and where do the MemER numbers come from? Which planner, perception stack and executor do RoboEXP, the MemER baseline and the real-world MemER-style baseline each use?

1 comment

Thank you for your detailed and valuable comments.

1. Contribution and prior work

[W1] In Sec. 2.2, we added Executable Analytic Concepts (arXiv:2510.07975), Voyager, ExpeL, Statler, ConceptGraphs, and REFLECT. We acknowledge their precedents for executable grounding, skills, experience retrieval, world state, scene graphs, and failure summaries. OCLM's contribution is linking persistent object identities and reusable part-template types to current scene states, verified transitions, and executable skill bindings; the underlying analytic concepts are inherited.

[W3] The 71% versus 7% comparison measures the combined agent and memory system. Sec. 5.4, Table 4, and App. B.1 describe shared-agent/tool controls: flat records with embedding retrieval achieve 59%, and generic object records achieve 62%, versus OCLM's 71%.

2. Memory operators and template coverage

[W2, Q1] App. A.1.1 specifies identity-score components, weights (0.45, 0.35, 0.20), threshold 0.75, and minimum margin 0.10. Sec. 4.3 and App. E.1 specify metadata filtering and synopsis-guided MLLM selection with applicability checks. Apps. E.2–E.3 provide prompts and tool interfaces.

[W2, Q1] Sec. 4.2.3 and App. E.1 clarify that skill preconditions come from template requirements and task applicability constraints, not successful runs. Verified pre/post-state changes enter Transition Memory and link to skills. Consolidation records executed function bindings, parameters, and outcomes, without a separate LLM abstraction prompt.

[W2, Q1] App. A.1 specifies the fallback: when observations are uncertain, the agent requests additional observations and repeats grounding for up to two attempts. If sufficiently observed structure matches no template, it retrieves a policy-grounded skill with satisfied applicability and preconditions. Outcomes are verified and recorded without creating a new template. If no skill applies, it replans and terminates the subtask when no feasible alternative remains. Coverage depends on available skills.

3. Perception and estimator training

[Q2] App. A.1 describes how segmentation and depth provide a partial component point cloud. Predicted template parameters instantiate a mesh that FoundationPose uses as its model-based reference for 6D pose estimation, without fine-tuning or a supplied test-object CAD model. Parameters and pose are then refined against the observed point cloud.

[W2, Q2] Poses and structural parameters are estimated from RGB-D. The agent, grounding tools, and executor receive no privileged simulator information. Appendix A.1 specifies ConceptFactory training assets and parameter annotations, supervision, training configuration, and exclusion of evaluation objects from estimator training.

4. Comparisons and evaluation

[W3, Q3] We apologize for Mem-0's incorrect “manually tested” marker. Table 1’s caption now identifies DP, π0.5, and Mem-0 as quoted from RMBench and removes the marker. Mem-0's 53% is the rounded seven-task mean (53.43%), whereas RMBench's 42.0% covers nine tasks.

[W3, Q3] The original MemER paper has no RMBench results. We have updated the MemER results in Table 1 to the commonly used evaluation values reported across recent studies, using EventVLA (arXiv:2606.20092v2, Table 8) as the numerical source, with matching values on overlapping tasks in ChainVLA (2608.02326) and Orchestra (2610.18352). The revised caption cites these sources.

[W3, Q3] App. A.5 specifies that RoboEXP shares OCLM's VLM as proposer/verifier, with an action stack and ACSG. Perception uses wrist-camera RGB-D, GroundingDINO, SAM-HQ, and CLIP, fused into voxel-based 3D memory. Its seven geometric primitives open/close doors and drawers, relocate/return objects, and move the camera; point clouds determine grasp/motion parameters, with top-down pickup. Its perception and executor differ from OCLM's.

[W3, Q3] App. A.6 specifies that the real-world MemER-style baseline shares OCLM's visual inputs, MLLM, perception, grounding, and execution tools, replacing structured records with historical keyframes. It adapts keyframe memory rather than reproducing the trained MemER policy, and is separate from the simulation results.

[W3, Q3] Ours(CS) achieves 92/100 successes on Observe and Pick Up and 74/100 on Press Button. Our original task selection emphasized evaluating the linked memory system. Observe and Pick Up primarily requires remembering object shape, corresponding to OCLM's Object Memory, and therefore provides a narrower assessment of interactions among memory components. Press Button primarily involves selecting the press skill associated with the Button Template, with limited demand for remembering object interactions and scene history. We therefore omitted these tasks from the original table because they exercise narrower aspects of the system. We report these omitted results here. Ours(DP)'s 71% remains a seven-task average. App. B.1 specifies RMBench’s 100-rollout protocol.

Reviewer_q694OpenReview ↗
Rating
1
Confidence
2
Informativeness
2
Presentation
2
Soundness
1
Read review
Paper summary

Object–Concept Linked Memory (OCLM) links parametric part templates to object instances. It records scene relations, transitions and skills. An LLM-based agent retrieves these records to check and execute actions. Feedback updates memory. Tests cover seven RMBench tasks, ten articulated-object categories and five real-robot tasks. Reported success with a diffusion-policy (DP) executor is 71% on RMBench. Average real-robot success is 84%.

Critical strengths
  1. It's useful to connect object identity and part geometry with action applicability and execution parameters. Appendix A.2 keeps verified observations separate from stale/pending fields and predicted effects. This helps stop predictions from being treated as observations when memory is updated.

  2. The internal controls do help. Table 4 and Appendix B.1 take away access to histories while keeping perception tools and execution capabilities. Flat records and generic object records keep much of the information. OCLM gets 71% success against 59% for flat records and 62% for generic object records.

Critical weaknesses
  1. Sec. 5.2 says the agent transfers to unseen instances/categories. There are no source/target splits or per-category trial counts in Appendix A.3. So what was unseen in Table 2? The test objects' relation to the template library and parameter-estimator training data needs to be given.

Appendix A.3 specifies randomized starts and success predicates. It allows five interactions per action proposal. But that doesn't tell what experience is there beforehand. Algorithm 1 initializes dynamic memories before the episode loop. Their contents and reset rules aren't specified. This also affects the main and real-robot tests. Skills could be preloaded or carried over. Do successful and failed interactions accumulate across episodes? Table 2 doesn't separate acquired-experience transfer from access to preloaded skills/templates as reported. This doesn't establish train–test overlap.

  1. There isn't enough detail to reproduce several parts of OCLM. Sec. 4.2 needs more on the identity-score functions and their weights and threshold. The fine-retrieval ranking rule is unclear in Sec. 4.3. Appendix A.1 gives the Point-Transformer architecture but not training data or supervision/loss. Grounding accuracy isn't given either. Prompts/tool schemas and task-specific template coverage need more detail. How were the skills built?

The geometric tolerances aren't in Appendix A.2. It separates failed and unverified outcomes. Algorithm 1 (lines 28–33) instead marks an attempt failed when its predicted postcondition is unverified. Which rule was actually used? It affects skill statistics and later retrieval.

Memory/retrieval is the new part here. The analytic-concept representation comes from cited work. For the external comparisons it isn't clear what information the baselines get or what grounding/skill access they have. Training/query budgets need explaining too. The internal controls don't answer these questions. Sharing the DP executor still leaves the added high-level agent mixed up with memory's effect.

Joint object–skill retrieval accuracy is defined in Appendix A.4. But query counts/selection and reference labels need more detail. So do candidate pools. Appendix B.3 goes from 50 to 1000 episodes without memory-entry counts/sizes or a clear query protocol. Its low module-level latency is useful but doesn't include LLM query generation and reasoning. The stored workload and how queries relate to stored experience need to be clear. Appendix B.1 gives 100 rollouts and feasibility filtering. Seeds and matching of accepted scenes are unclear. So is uncertainty. These method gaps and the unclear transfer protocol support clear rejection.

Questions for authors
  1. For Table 2, give source/target assets and categories, per-category trial counts, template-library coverage and parameter-estimator training data. Which prior executions and memory entries are available initially? When are memories reset or carried across episodes? Separate unseen instances from unseen categories using known part templates. Entirely new template types aren't required.

  2. Please give the identity-score functions/weights/thresholds, fine-retrieval ranking rule, prompts/tool schemas, geometric verification tolerances and estimator training procedure. If a predicted postcondition cannot be verified, does it stay unverified as in Appendix A.2 or become failed as in Algorithm 1? How does this rule affect skill statistics and subsequent selection? Please show a trace of the evaluated queries, records and updates.

  3. What observations, grounding tools, callable skills, initial experience and query/context budgets does each baseline get? Give Table 4's actual flat/generic retrieval configurations. For RA/Re-ID, give query counts, reference labels and candidate pools. For Appendix B.3, give memory sizes and the query-generation/evaluation protocol. Please give configured evaluation seeds, scene matching and uncertainty of the main/ablation differences. These questions clarify the reported comparisons. They don't require redesigning every baseline or testing additional domains.

2 comments

Thank you for these valuable suggestions. They helped us identify ambiguities in the experimental protocols and implementation details. Following your comments, we have expanded and clarified the main text and appendices, as detailed below.

1. Transfer protocol and initial experience

[W1, Q1] Sec. 5.2 and Apps. A.1/A.4 distinguish ConceptFactory assets used for estimator training from PartNet-Mobility evaluation assets, with test objects excluded from estimator training. Table 5 lists the 39-category, 4,481-asset source collection. Cross-object source memory excludes all instances from Washing Machine, Kitchen Pot, Safe, and Table, leaving 35 source categories. This tests reuse of known part structures across categories, not discovery of new template types. Cross-instance source memory excludes test instances. Table 6 gives the six category-level test counts and 20 trials per object (286 objects, 5,720 trials per variant for Semantic-memory and OCLM).

[W2, Q1] App. A.3 specifies initialization and resets. For RMBench and real-robot evaluation, templates/functions are loaded first; the agent then reads RMBench or teleoperated demonstrations. Each trial restores the snapshot after demonstration reading. For transfer, initial memory contains non-test source-object instances, program-generated transition examples, and bound functions. These functions specify success conditions, not empirical success proportions. Trial updates never carry into subsequent trials. Thus, transfer uses preloaded source knowledge rather than accumulating target-test experience across trials.

2. Grounding, retrieval, and execution updates

[W3, Q2] App. A.1 describes the parameter estimator, ConceptFactory supervision, training configuration, and generated-mesh FoundationPose pipeline. App. A.1.1 gives identity-score components, weights (0.45, 0.35, 0.20), threshold 0.75, margin 0.10, and the pose-similarity formula. Sec. 4.3 and App. E.1 specify metadata filtering followed by synopsis-guided MLLM selection. Apps. E.2–E.3 provide prompts, record formats, and tool contracts; App. E.4 provides a Kitchen Pot retrieval/update trace. This trace combines function calls and demonstration evidence; it is not a newly executed robot rollout.

[W3, Q2] Sec. 4.2.3 and App. E.1 clarify that skill preconditions come from template requirements and task applicability constraints. Consolidation records executed bindings, parameters, and outcomes, without a separate abstraction prompt. Verified pre/post-state changes link transitions to skills. Zero-execution skills have unavailable success rates, not observed zero success. Program-generated examples do not establish verified execution success.

[W4, Q2] Sec. 4.4, App. A.2, and Algorithm 1 distinguish evidence labels from statistics. Unverified means insufficient evidence to determine whether the postcondition holds. Algorithm 1's else branch means verified success was not established, not that physical failure was confirmed. Records retain success, failure, or unverified labels. All attempts count toward the total; only verified successes increase the success count. Unverified attempts lower the rate used for skill selection, measuring verified reliability rather than physical success alone. Neither an unverified predicted effect nor its negation is committed as a verified state or transition. Unresolved fields remain stale or pending. The agent re-queries memory and verifies preconditions before dependent execution; if unresolved, execution is deferred. These edits clarify existing semantics without changing implementation.

3. Comparison scope and evaluation details

[W5, Q3] Sec. 5.1 explicitly treats the DP-to-Ours(DP) improvement as the combined agent/memory effect. Sec. 5.4, Table 4, and App. B.1 provide shared-stack controls: flat records serialize the same facts and use embedding retrieval (59% SR), while generic object records retain geometry, poses, affordances, and callable skills but omit part-template links (62%), versus OCLM's 71%. These controls assess organization/retrieval and template-linked representation.

[W5, Q3] Table 1 identifies DP, π0.5, and Mem-0 as quoted RMBench results and simulation MemER as an external reproduction. They are not shared-tool evaluations. App. A.5 specifies RoboEXP's shared VLM and distinct perception/executor. App. A.6 specifies that the real-world MemER-style adaptation shares OCLM's visual inputs, MLLM, and perception, grounding, and execution tools.

[W6, Q3] App. A.6 defines joint object–skill correctness and retrieval timing; App. B.1 specifies 100 accepted rollouts, feasibility filtering, seed progression, and SR aggregation. We follow RMBench's reporting convention without claiming multi-seed significance. App. B.3 measures formed-query-to-record retrieval latency, excluding LLM query generation and reasoning. App. B.4 separately reports measured object-record storage and a projected storage-growth analysis.

I thank the authors for their response and clarification. I remain concerned regarding the novelty over prior works and the points raised by the other two reviewers. Therefore, I would retain my scores.

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

Related papers

Loading the map…

Discussion (0)

Sign in to comment.