- Rating
- 3
- Confidence
- 4
- Informativeness
- 3
- Presentation
- 3
- Soundness
- 2
Read review
Paper summary
The paper investigates retention of task-relevant information when using 3D scene graph representations as robot memories, for robots performing a sequence of tasks. The key idea is to retain a lightweight local memory of the information relevant to tasks, while offloading heavier representations to the cloud. The approach, called PORTER, quantified the loss of task information when offloading certain portions of the representation (payloads). The resulting metric is used in a submodular maximization problem to decide what to offload. The approach is tested in relevant benchmarks and shown to retain useful information while reducing the amount of information stored at the edge.
Critical strengths
- The paper tackles an interesting problem and tension: how to retain task-relevant representations over long-deployments where the robot performs many different tasks.
- The idea of looking at task support (essentially, understanding which tasks become infeasible if a payload is lost) instead of relevance is very interesting.
- The presentation/writing is clear and easy to follow.
- Formulating the problem as a submodular maximalization problem is quite elegant.
- The experiments are quite comprehensive and apply PORTER to multiple scene graph memory construction approaches.
- The paper also tested the approach in real-robot experiments.
Critical weaknesses
- Equation (1) feels a bit ad hoc and is still related to task relevance: the paper would benefit from providing deeper foundations for this definition and the one in eq (5). Also, alpha and epsilon should be discussed right after eq (1). Moreover, after eq (1), it would be good to provide an example of how the metric can capture the fact that certain objects are redundant for a task (e.g. a sofa or chair for sitting), but other are simultaneously needed (e.g., sponge and dish soap for washing dishes).
- If the weights \omega_r are all the same, why bother to include them in the definitions?
- Table 1: strictly speaking, all objects (or at least their anchors) are retained by PORTER so the comparison in Table 1 seems confusing. It might be more relevant to compare memory reduction with and without PORTER. Same for Figure 4.
- Clarity: Section 4.1: the description of Tier 2 and 3 tasks could be clearer in the experimental setup. In Section 3.2, please give an example of functional requirement to make the presentation clearer. The information rendered in Figure 2 might be better rendered as a 2D instead of a 3D plot.
- Minor: considering that storage is cheap, one is left to wonder whether in practice one would send information out to the cloud or just store it to disk. The approach in the paper can easily handle both cases, and I feel that emphasizing the edge-cloud application might not be the strongest angle to take.
- Minor: DAAAM (Gorlo et al, 2026) is used as a benchmark in the experiments but it is not discussed/mentioned in the related work section.
Questions for authors
- Equation (1) feels a bit ad hoc and is still related to task relevance: the paper would benefit from providing deeper foundations for this definition and the one in eq (5). Also, alpha and epsilon should be discussed right after eq (1). Also: can you provide an example of how the metric can capture the fact that certain objects are redundant for a task (e.g. a sofa or chair for sitting), but other are simultaneously needed (e.g., sponge and dish soap for washing dishes)?
- Table 1: strictly speaking, all objects (or at least their anchors) are retained by PORTER so the comparison in Table 1 seems a bit unfair or at least confusing. can you clarify why the number of objects was used as a key metric?
7 comments
Rebuttal by Authors (2/5)
W2: If the weights are all the same, why bother to include them in the definitions?
A2: We retain to make the formulation flexible to different priorities among functional requirements. For example, in a meal-preparation task, locating the main ingredient may be assigned a higher priority than locating a serving utensil, depending on the task objective.
In this work, however, we do not estimate task-dependent priorities and adopt uniform weights () as a simplifying assumption. Thus, the weighted formulation provides flexibility for scenarios with non-uniform requirement priorities, while our current experiments use the uniform-weight setting. Exploring task-dependent requirement weighting is an interesting direction for future work.
Rebuttal by Authors (3/5)
W3: Table 1: strictly speaking, all objects (or at least their anchors) are retained by PORTER so the comparison in Table 1 seems confusing. It might be more relevant to compare memory reduction with and without PORTER. Same for Figure 4.
A3: We thank the reviewer for pointing out this ambiguity. We originally reported the number of locally resident payload objects to remain consistent with the object-level evaluation protocol of JITOMA-Bench. However, we agree that this metric requires clarification: the reported count refers to objects whose full payloads remain locally resident, not the total number of objects or anchors retained by PORTER. PORTER retains lightweight anchors and persistent IDs for all objects, while only a subset of their full payloads remains locally available.
(3.1) Anchor versus payload memory. To illustrate why resident-payload object count provides a useful coarse indication of memory usage, we measured the average payload and anchor sizes in the three ConceptGraphs scenes used in Table 1:
| Scene | # Objects | Mean payload/object | Mean anchor/object | Ratio |
|---|---|---|---|---|
| Apartment | 452 | 38.68 MiB | 4.19 KiB | 9,453× |
| Office | 924 | 22.54 MiB | 4.19 KiB | 5,509× |
| Cubicle | 224 | 47.42 MiB | 4.19 KiB | 11,589× |
As shown above, individual payloads are thousands of times larger than their corresponding anchors. Thus, although all object anchors remain locally available, the number of locally resident payloads provides a useful coarse indication of local object-state memory usage. We acknowledge that object count alone is not a direct measurement of memory consumption.
As an additional aggregate comparison, the trajectory-averaged resident-payload footprint decreases from 10.37–20.17 GiB in Vanilla ConceptGraphs to 0.64–1.02 GiB with PORTER, corresponding to a 92.4–96.2% reduction across the three scenes. These supplementary measurements directly demonstrate the reduction in resident payload memory.
We have clarified the meaning of the resident-payload count in Sec. 4.1 and the corresponding Table 1 and Figure 4 descriptions, and added the detailed anchor–payload memory analysis in Appendix A.3.5.
Rebuttal by Authors (1/5)
We sincerely thank the reviewer for the thoughtful and constructive feedback. Your suggestions have been helpful in improving the clarity and theoretical motivation of our formulation. We respond to each point below.
A1: In response, we have revised the method section to better explain the intuition behind Eqs. (1) and (5), clarify the roles of the parameters, and introduce examples illustrating redundancy and complementarity.
(1) Anchor-based support (Eq. 1). Equation (1) estimates how strongly an individual object supports a task requirement based on its anchor embedding, yielding a full-payload support score. The corresponding anchor-only support is scaled by η, reflecting the support retained after payload offloading. Since anchors remain locally available after offloading, this allows PORTER to estimate task support without first retrieving the full payload. Here, α filters weak semantic matches and rescales stronger ones, while ε caps individual support below 1 to prevent complete saturation in the subsequent Noisy-OR aggregation.
(2) Redundancy and complementarity. Following the reviewer's suggestions, for illustration, assuming η=0, consider a task requiring a place to sit, with a sofa and a chair each providing a support score of 0.8 for the corresponding functional requirement. Following the Noisy-OR aggregation, their joint coverage is 1−(1−0.8)2=0.96. Offloading either object reduces coverage by only 0.16, since the other can still provide the required support. However, once only one object remains, offloading it causes a further loss of 0.8.
Consequently, the marginal task-support loss, and thus the resulting ISE increase, depends on whether alternative objects can still provide support for the same requirement, rather than simply on the individual support score of the offloaded object.
In contrast, washing dishes may require both a cleaning tool (sponge) and a cleaning agent (dish soap). Since coverage is computed separately for each functional requirement, additional sponges cannot compensate for the absence of dish soap. This allows ISE to account for both interchangeable objects and objects that serve different, complementary requirements.
(3) Log-survival loss (Eq. 5). ISE measures the relative task support lost after offloading compared with full residency. The support-survival ratio ρr(S) measures the fraction of the full-residency support that remains locally available for requirement r. Minimizing its negative log-survival loss is equivalent to maximizing the weighted geometric mean of requirement-wise survival ratios:
∏r∈Rqρr(S)ωr
This formulation ensures that a requirement with very little support remaining has a strong effect on the loss, rather than having its loss simply offset by high support for other requirements.
We have incorporated these explanations, parameter definitions, and illustrative examples into
Secs. 3.2–3.3of the revised manuscript.