{"id":"2738a4a7-b6ca-40a3-b494-5754f092b5c2","arxiv_id":"2608.09410","paper_version":1,"verdict":"CONDITIONAL","confidence":"HIGH","novelty_score":6.0,"correctness_risk":"high","formal_verification":"none","parameter_count":5,"one_line_summary":"HyMeS separates motor control from memory management by steering a frozen neural policy with a learned symbolic program, lifting task success from 41.3% to 60.1% on a 12-task memory benchmark.","lead":"This paper introduces HyMeS, a hybrid system that lets a robot store task details, like a number seen on a card, in a computer program while a neural network handles the physical motions. It reports large gains on a memory-dependent manipulation benchmark and on a real robot, compared with a standard vision-language-action policy and a memory-augmented baseline.","discovery_kind":"new_method","skeptic_critique":{"model":"deepseek-v4-flash","headline":"Development rollouts used to refine the heuristic program are not stated to be disjoint from the 160 evaluation episodes; without a held-out split, the headline gains may be fitted to the test set.","rationale":"The reader's weakest assumption identifies the same load-bearing concern: the paper never states that the rollout-driven refinement episodes are disjoint from the 160 reported evaluation episodes. This is the right point of attack because the whole empirical contribution is the magnitude of the improvement on RoboMemArena and the real robot. The architecture is plausible, the ablation of 'one-shot P(0)' versus 'rollout-refined P*' supports the value of rollout feedback, and the fixed-policy-weight comparison on SO-101 is a strong design choice. But if P* was selected using benchmark verdicts on the same episodes later reported as evaluation episodes, the headline numbers are not a prediction of generalization; they are a selection result. The fix is straightforward: state the split, report error bars, and release P* and episode identifiers so the held-out evaluation can be checked. Because this concern is unresolved but not shown to be fatal, the appropriate verdict remains CONDITIONAL, matching the reader's verdict; no adjustment is needed beyond making the condition explicit.","tokens_in":12396,"tokens_out":3070,"duration_ms":34060,"concrete_test":"Obtain from the authors the exact development/evaluation split: how many of the 160 RoboMemArena episodes were used to select P*, and how many were reserved for evaluation. Then rerun the frozen P* on a newly sampled held-out set of the same 12 tasks, or re-split the episodes 80/80 and re-select P* only on the development half. If the held-out CSR/TSR no longer exceed π0.5 by roughly 13.7/18.8 points, the reported gains are fitted to the evaluation episodes. Also require release of P* and the episode seeds so the check can be reproduced independently.","verdict_should_be":"UNCHANGED","load_bearing_attack":"The central empirical claim is that HyMeS lifts CSR from 52.5% to 66.2% and TSR from 41.3% to 60.1% over the same-weight π0.5 policy (§Experiments). This claim depends on the final program P* being developed on data not used for evaluation. The method says the coding agent revises P using 'stage-wise verdicts b_n provided by the benchmark' (Eq. 10, Memory-Strategy Learning in Code Space) and that 'the best-performing program on development rollouts is retained as P*'. The evaluation section states that 'All methods are evaluated on the same corrected tasks and episodes' and that 'Exploration experience is frozen during evaluation,' but nowhere states that the 160 evaluation episodes are disjoint from the development rollouts. If the same episodes served both purposes, the benchmark verdicts b_n let the coding agent tune constraint rewards, verification thresholds (k, w, λ0, β), and transition rules to those exact episodes, so the 66.2/60.1 numbers would be test-set fitting rather than prediction. The paper also reports no error bars, and with only 10–20 episodes per task, per-cell differences are noisy. This is not an internal inconsistency, but it is the least secure link between the architecture and the headline result.","agreement_with_reader":"agree"},"referee_report":{"model":"deepseek-v4-flash","summary":"The paper proposes HyMeS, a hybrid framework for memory-dependent robot manipulation. A pretrained flow-matching VLA (π0.5) is fine-tuned on demonstrations and then frozen, while a coding agent iteratively edits an executable heuristic program P=(C,V,U) that maintains symbolic memory, selects stage-specific constraint rewards, and verifies stage completion through proprioceptive and multi-frame VLM evidence (PACE). The selected constraint is injected into the denoising velocity field to steer the frozen policy. Experiments on a corrected 12-task subset of RoboMemArena (160 episodes) report an improvement in Cumulative Success Rate from 52.5% to 66.2% and Task Success Rate from 41.3% to 60.1% over the same-weight π0.5 policy, and on an SO-101 robot TSR from 25.7% to 57.1% with shared weights and demonstrations. Ablations attribute much of the gain to rollout-refined heuristics and to combining proprioceptive and visual verification evidence.","tokens_in":12713,"tokens_out":6434,"duration_ms":68814,"significance":"If the quantitative results are sustained, this is a genuinely useful contribution: separating motor-skill learning (weight space) from memory-strategy learning (code space) is a principled response to the combinatorial explosion of history-dependent task configurations, and the resulting symbolic memory is inspectable at every control step. The real-robot experiments, in which π0.5 and HyMeS share the same demonstrations and policy weights, are a well-designed isolation of the memory mechanism. The conceptual claim is falsifiable and the architectural separation is appealing. However, the headline empirical claim currently rests on an evaluation protocol whose development/evaluation split is not established, and the paper provides no variance estimates or full disclosure of the heuristic-learning loop, so the quantitative results need verification before the significance can be fully credited.","major_comments":[{"comment":"The paper never states that the development rollouts used to refine P (Eq. 10) are disjoint from the 160 evaluation episodes. The method says the coding agent revises P using 'stage-wise verdicts b_n provided by the benchmark' and retains the 'best-performing program on development rollouts' as P*; the experiments say 'All methods are evaluated on the same corrected tasks and episodes' and 'Exploration experience is frozen during evaluation.' Freezing at evaluation does not prevent the same episodes from having been used in the rollout-driven edit loop. If the development and evaluation episodes overlap, the reported CSR/TSR gains are fitted to the test set rather than predicted. This is the central claim of the paper, so the authors must demonstrate a clean development/evaluation split, for example by using disjoint episode sets, by pre-registering the evaluation episodes, or by fixing P* before any evaluation episode is run, and they should state the number of development rollouts per task.","section":"Method, Memory-Strategy Learning in Code Space (Eq. 10); Experiments, Experimental Setup"},{"comment":"No variance or confidence intervals are reported. Per-task episode counts are 10–20 in simulation and 10–15 on the real robot, so a single episode changes TSR by 6.7–10 percentage points. The headline comparisons (52.5→66.2 CSR, 41.3→60.1 TSR) need standard errors or bootstrap intervals, at least at the overall level, and per-cell episode counts. In addition, the paper evaluates on a 'corrected 12-task protocol' that is a post-hoc subset of the 26-task RoboMemArena benchmark; the selection rule 'dominated by motor-skill failures' needs an operational definition, and results on the original protocol (or a justified reason for reporting only the subset) should be given so that the comparison to PrediMem is transparent.","section":"Experiments, Table 1 and Table 2"},{"comment":"The heuristic-learning process is not fully reproducible from the text. The free parameters of the guidance schedule λ0, β, and p_mid (Eq. 13) are not given values, and the coding-agent edit loop is described only at a high level (Eq. 10). The paper should report the number of development iterations, the number of rollouts per iteration, the exact coding-agent prompt and edit protocol, the model version (Opus 4.8), the compute budget, and any manual intervention in the selection of P*. Without these details, the claim that memory-management strategies are learned rather than hand-engineered cannot be assessed by a reader, and the central comparison cannot be reproduced.","section":"Method, Memory-Strategy Learning in Code Space; Implementation details"},{"comment":"The sentence 'its gradient coincides with the clean-action gradient as τ→1' is not established. R_ρ is evaluated on the intermediate noisy chunk a_τ, so ∇_{a_τ} R_ρ(a_τ, o_t; s_t) is not generally equal to the gradient with respect to the clean action a, even as τ→1, unless R is defined through a clean-action transform and the limit is taken carefully. Please provide a derivation or state the approximation explicitly, since this equation is the mechanism by which symbolic memory steers the policy.","section":"Method, Eq. (12)"}],"minor_comments":[{"comment":"The action superscript/subscript notation is garbled in several places (for example, 'aat 2' and 'a 2 to 2'); please clean up the typography so that the two candidate actions are clearly distinguished.","section":"Figure 1 and surrounding text"},{"comment":"The notation ee(a) and Γ(target(s_t), o_t) is used without definition in the equation; define the terminal end-effector position and the keypoint-grounding function before first use.","section":"Method, Eq. (11)"},{"comment":"The abstract says 'mean cumulative success' and 'mean task success'; Table 1 shows both category averages and an overall average. Please clarify whether the reported 'mean' is the mean over all 160 episodes or the mean of category averages, since the two can differ.","section":"Abstract and Table 1"},{"comment":"The statement that task selection 'uses only protocol checks and π0.5 behavior, without HyMeS results' is good practice, but the criterion 'dominated by motor-skill failures' should be made operational (for example, a TSR threshold) so that readers can judge whether the subset is cherry-picked.","section":"Experiments, Experimental Setup"},{"comment":"PrediMem is reevaluated on the 12-task protocol; please state whether its hyperparameters were tuned on this subset or taken from the original benchmark, since retuning on the same subset could make the comparison more favorable to HyMeS.","section":"Experiments, Baselines"},{"comment":"The six-task ablation subset is not enumerated. Please list the tasks in the subset so that the ablation can be compared with Table 1, and report the number of episodes used.","section":"Ablation Studies, Table 3"}],"recommendation":"major_revision","confidential_remarks":"The main risk is evaluation leakage: if the development rollouts used to refine the heuristic program are not disjoint from the 160 evaluation episodes, the headline gains are test-set fitting. I would not recommend acceptance until the authors demonstrate a clean split and report variance estimates. The manuscript also needs fuller disclosure of the coding-agent edit loop and hyperparameters for reproducibility. The conceptual contribution is sound and the real-robot shared-weight comparison is a strength, so the issues are fixable within a revision."},"author_rebuttal":null,"desk_editor":{"model":"deepseek-v4-flash","letter":"Know this: HyMeS is a genuine architectural contribution, and the paper is readable and honest. But the evaluation protocol has a hole that needs patching before the headline numbers mean what they claim.\n\nThe new thing here is the split: motor skills stay in the frozen VLA weights, while a coding agent maintains an executable symbolic memory and uses VLS-style denoising constraints to steer a frozen policy. The memory is not a latent buffer; it is readable code, updated by PACE using proprioception and multi-frame VLM judgments. That combination is new, and it directly targets the demonstration cost of memory-augmented VLAs. The ablations are informative: rollout-refined P* beats one-shot P0, and removing either PACE modality hurts. The real-robot comparison is well isolated, with the same weights and demos for both methods. The paper also clearly states limitations (latency, contact-rich failures) without overclaiming.\n\nThe soft spot is the development/evaluation split. The method says the coding agent revises P using stage-wise benchmark verdicts and that the best program on development rollouts is retained as P*, but the experiments never say the development rollouts are disjoint from the 160 evaluation episodes. If they are not, Eq. 10 is a test-set-fitting loop: the program is tuned to the same episodes it is then evaluated on, and the 52.5→66.2 CSR and 41.3→60.1 TSR gains become fitted numbers rather than predictions. This is not an internal contradiction; the paper just needs to state the split and ideally release the rollout logs. The lack of error bars matters too: 10–20 episodes per task is thin, and the per-task table shows plenty of noise. The task selection is also a post-hoc subset of RoboMemArena built around pi0.5 failures, which is defensible but makes the absolute numbers hard to compare to the full benchmark. The real-robot results are only 35 trials total, so treat them as feasibility evidence, not measurement.\n\nWho is this for? People building on frozen VLAs and anyone working on memory in robot learning. The architecture itself deserves discussion. But I would not trust the effect sizes until the split is clarified and code/programs are released. Send it to peer review, yes, with the split question as the central required revision.","headline":"Solid architecture, honest writeup, but the headline gains may be test-set fitting until the authors clarify the development/evaluation episode split.","tokens_in":13190,"tokens_out":2481,"would_cite":true,"duration_ms":26782,"reading_group":"yes","serious_thinker":"yes","would_accept_peer_review":true},"rs_alignment":null,"lean_confirmation":null,"pith_extraction":{"msc":[],"pacs":[],"model":"deepseek-v4-flash","headline":"HyMeS shows that a robot can solve memory-dependent tasks by keeping motor skills in policy weights and putting working memory in executable code that steers a frozen VLA.","keywords":["hybrid learning","memory-dependent manipulation","vision-language-action models","coding agents","flow matching","robot manipulation","inference-time steering","heuristic learning"],"falsifier":"Run the development loop on a disjoint set of task instances, freeze the selected program, and evaluate on the 160 episodes; if the task success and cumulative success gains over pi0.5 vanish or shrink substantially, the memory program was fitting evaluation feedback rather than generalizing.","tokens_in":12221,"feed_emoji":"🤖","tokens_out":5328,"duration_ms":49089,"temperature":0.7,"pith_summary":"The paper claims that memory-dependent manipulation does not require training memory into a vision-language-action policy. Instead, HyMeS separates the problem: the VLA learns motor skills in its weights once, and a coding agent learns a memory-management program in code space, iteratively revising executable rules from rollout feedback. During execution, that program maintains a symbolic task state, translates it into a differentiable constraint, and steers the frozen VLA's action generation, with multimodal verification deciding when a stage is done. The authors report large gains over the same-weight VLA on RoboMemArena and on a real robot, suggesting memory can be acquired without demonstrations for every history-dependent configuration.","feed_headline":"Memory in code lifts robot task success from 41.3% to 60.1%","feed_subtitle":"HyMeS adds an executable memory program that steers a frozen VLA, beating end-to-end memory-augmented training on RoboMemArena.","key_machinery":"The central object is the executable heuristic program P=(C,V,U), a code-space memory that holds a plan, current stage, bindings, counts, and persistent state. It does its work through memory-conditioned steering: the active stage's constraint reward $R_{\\rho_t}$ is injected into the VLA's flow-matching denoising as a gradient term, so the same frozen policy produces actions consistent with memory, and PACE closes the loop by voting over proprioceptive latches and multi-frame VLM judgments before advancing the stage.","core_discovery":"The central claim is that the history-dependent component of a manipulation task can be factored out of the policy and realized as an executable memory program. The paper formalizes memory-dependent tasks through observation aliasing: different histories produce the same observation but require incompatible actions, so a Markovian policy that conditions only on the current observation must average over action modes. HyMeS learns a motor policy by imitation in weight space and, separately, learns a program P=(C,V,U) in code space that selects constraints, verifies stage events, and updates memory; steering modifies the flow-matching velocity as $$\\hat{v}=v_{\\$\\theta$^\\star}(a_\\tau,\\tau|o_t,\\ell)+\\lambda_t\\nabla_{a_\\tau} R_{\\rho_t}(a_\\tau,o_t;s_t)$$ so that each action chunk follows the current memory state while policy weights stay fixed. On 12 RoboMemArena tasks it raises cumulative success from 52.5% to 66.2% and task success from 41.3% to 60.1% over pi0.5, and on a real SO-101 robot it raises task success from 25.7% to 57.1% with identical policy weights and demonstrations.","pith_inferences":["A testable extension would hold out the development rollouts from the evaluation episodes and measure the performance drop; the paper does not state that the refinement episodes were disjoint from the 160 evaluation episodes.","The same hybrid separation might be applied to state estimation or world modeling: any discrete, inspectable state could live in code while continuous motor competence stays in weights.","The approach inherits the base policy's motor limits, so its applicability is bounded by the competence of the pretrained VLA rather than by the memory mechanism; stronger base policies should widen the range of tasks.","Because the memory program is executable code, users could in principle edit or audit the exact rule that caused a failure, which end-to-end memory modules do not offer."],"forward_implications":["Demonstration cost scales with the number of reusable motor skills rather than with the number of history-dependent task configurations, because new memory configurations are handled by editing the program.","A single fine-tuned VLA checkpoint can serve multiple memory-dependent tasks; the memory program is frozen during evaluation and the policy weights never change.","Symbolic memory makes failure localization tractable: failed episodes can be attributed to motor execution, event verification, or memory update, as the paper's failure analysis demonstrates.","The steering interface is additive to any flow-matching VLA, so gains should persist as the base policy improves, provided the base policy retains the required motor competence.","Verified stage transitions convert intermediate progress into full-task success more reliably than end-to-end memory-augmented baselines, as shown by the larger TSR than CSR advantages in counting and sequence tasks."],"supporting_citations":[{"why":"Supplies the pretrained Markovian VLA policy that HyMeS fine-tunes and freezes.","marker":"Physical Intelligence et al. 2025b"},{"why":"Provides the RoboMemArena benchmark, the corrected 12-task protocol, evaluation episodes, and the PrediMem baseline.","marker":"Lei et al. 2026"},{"why":"Introduces the VLS method for injecting differentiable constraints into flow-matching action generation, which HyMeS adapts for memory-conditioned steering.","marker":"Liu et al. 2026a"},{"why":"Defines heuristic learning as the revision mechanism by which the coding agent updates the executable program from rollout feedback.","marker":"Weng 2026"},{"why":"Gives the pi0 flow-matching objective and architecture that the motor-skill fine-tuning objective builds on.","marker":"Black et al. 2024"}],"fun_headline_variants":["Memory as code, not weights: robot success up to 60.1%","HyMeS: memory in code lifts robot task success to 60.1% from 41.3%","Coding memory for robots: 60.1% task success, up from 41.3%","HyMeS: skills in weights, memory in code, beats end-to-end VLA","From 41.3% to 60.1%: robot memory written as a program"],"cache_read_input_tokens":3200,"weakest_assumption_plain":"The headline gains assume the coding agent's rollout-based program refinements were evaluated on episodes separate from the 160 evaluation episodes, but the paper never states this holdout explicitly.","fun_headline_variants_meta":{"raw":{"variants":["Memory as code, not weights: robot success up to 60.1%","HyMeS: memory in code lifts robot task success to 60.1% from 41.3%","Coding memory for robots: 60.1% task success, up from 41.3%","HyMeS: skills in weights, memory in code, beats end-to-end VLA","From 41.3% to 60.1%: robot memory written as a program"]},"model":"deepseek-v4-flash","effort":"low","cost_usd":0.001537,"raw_usage":{"total_tokens":6215,"prompt_tokens":1078,"completion_tokens":5137,"prompt_tokens_details":{"cached_tokens":384},"prompt_cache_hit_tokens":384,"prompt_cache_miss_tokens":694,"completion_tokens_details":{"reasoning_tokens":5014}},"tokens_in":694,"tokens_out":5137,"duration_ms":36259,"temperature":1.0,"reasoning_tokens":5014,"cache_read_input_tokens":384,"cache_creation_input_tokens":0},"cache_creation_input_tokens":0},"created_at":"2026-08-11T17:44:10.614756+00:00","model_set":{"reader":"deepseek-v4-flash"},"falsifier":"Run the development loop on a disjoint set of task instances, freeze the selected program, and evaluate on the 160 episodes; if the task success and cumulative success gains over pi0.5 vanish or shrink substantially, the memory program was fitting evaluation feedback rather than generalizing.","supporting_citations":[],"review_version":1}