{"id":"949cb99e-f26f-4d9b-8fd1-d8867eeb59b5","arxiv_id":"2511.04758","paper_version":2,"verdict":"CONDITIONAL","confidence":"MODERATE","novelty_score":6.0,"correctness_risk":"medium","formal_verification":"none","parameter_count":4,"one_line_summary":"ScheduleStream extends sampling-based task and motion planning with durative actions and temporal scheduling so a bimanual robot can plan and execute parallel arm motions, roughly halving makespan versus sequential planning.","lead":"This paper introduces ScheduleStream, a planning framework that lets a robot's arms move at the same time instead of one at a time, while deciding both which actions to take and how to execute them. It is the first general-purpose (domain-independent) version of this capability, and it uses GPU-accelerated collision and motion checks to make parallel multi-arm planning fast enough for real bimanual robots.","discovery_kind":"new_method","skeptic_critique":{"model":"deepseek-v4-flash","headline":"Algorithm 2's temporal compilation is asserted without proof; safety depends on exact swept-volume checks that Section V replaces with approximate sphere sampling, and EAGER-STREAM's 'provable' completeness requires unjustified stream totality assumptions.","rationale":"The reader's verdict was CONDITIONAL, identifying the temporal reduction as the weakest assumption. I agree but sharpen the concern to two specific unproven points: (1) the event-time check's sufficiency for ongoing conditions, and (2) the approximation in collision checking. The first is a correctness gap in the formal description; the second is a concrete risk that executed schedules may collide. The EAGER-STREAM completeness claim is a separate omission. These do not, by themselves, refute the empirical results — the simulated comparisons might still hold with a different collision checker — so I do not recommend REJECT. The conditionality is appropriate until a proof of the reduction and a safe collision-checking guarantee are provided. Agreement with the reader is partial because the reader emphasized conservatism (rejecting safe schedules) whereas I emphasize the potential unsoundness of the approximation and the missing proof.","tokens_in":13840,"tokens_out":16407,"duration_ms":167235,"concrete_test":"On the smallest task (Franka Assigned 2), pre-enumerate all IK/motion stream outputs for a fixed seed, run Algorithm 2 with exhaustive event-order search, and independently verify each returned schedule with an exact mesh collision checker (e.g., FCL) and a brute-force optimal temporal planner (e.g., a MILP over start/end times). If any exact-collision check fails, the approximate sphere-based ArmCollision is unsound. If the brute-force optimum is strictly lower than Algorithm 2's makespan, the temporal reduction is incomplete. For completeness of EAGER-STREAM, run it on a finite domain where all stream outputs are enumerated; if a solvable instance is not solved after all outputs are processed, the 'provably solve' claim is false.","verdict_should_be":"UNCHANGED","load_bearing_attack":"The central claim rests on the reduction in Section IV-B (Algorithm 2): every valid schedule is claimed to be representable as an interleaving of start/end events, and the extracted schedule (lines 7–13) is assumed to satisfy the durative-action semantics. The paper gives no proof. The `OverCondition` is checked only at event instants; it is not shown that this ensures `collision_cond` holds over the entire overlap interval. In Section V, collision checking is replaced by a union of inflated inscribed spheres 'greedily sampled for a given computation budget' — an approximation that can miss collisions if the sphere set does not cover the mesh. If a planned parallel move passes the approximate check but collides in exact geometry, the output schedule is invalid. Separately, the assertion in Section IV-C that EAGER-STREAM will 'provably solve' solvable problems assumes each stream generator eventually enumerates every needed constant; the paper never states or justifies this for the randomized/GPU samplers used. Without these two supports, the framework's core promises (general-purpose, correct, parallel schedules) are not established.","agreement_with_reader":"partial"},"referee_report":{"model":"deepseek-v4-flash","summary":"The paper introduces ScheduleStream, a Python-based, domain-independent framework for Task and Motion Planning & Scheduling (TAMPAS) with sampling operations. The language extends PDDL-style planning with durative actions, procedural predicates, and stream generators. The paper proposes two algorithms — EAGER-STREAM and LAZY-STREAM — that alternate between scheduling and stream sampling, and it applies them to multi-arm manipulation with GPU-accelerated samplers. Simulated experiments on Franka and SO100 tasks compare ScheduleStream against sequential-only and strict hierarchical baselines, reporting higher success rates and roughly half the makespan for the lazy/GPU variant. Real-world bimanual demonstrations on a Kinova platform are also presented.","tokens_in":153,"tokens_out":1988,"duration_ms":93009,"significance":"If the framework and algorithms are correct, ScheduleStream would be a meaningful advance: it is the first domain-independent TAMP system that outputs asynchronous schedules with overlapping durative actions, and it demonstrates practical GPU-accelerated planning for multi-arm manipulation. The empirical core is strong: Ours+GPU matches Sequential success (99% vs. 99%) while approximately halving average makespan, and the strict Hierarchical baseline collapses on non-downward-refinable problems, consistent with known limitations. The paper also contributes a reusable Python implementation and real-world validation. However, several formal claims — particularly the correctness of the temporal compilation, the safety of the approximate collision checking, and the 'provably solve' completeness assertion — are not adequately supported. These issues are load-bearing for the claimed generality and correctness of the approach.","major_comments":[{"comment":"The paper asserts, without proof, that any sequential plan over compiled start/end actions corresponds to a valid durative schedule. Specifically, the compiled start action checks OverCondition at the start instant, and the end action checks OverCondition again, but no argument shows that checking only at these event instants suffices to guarantee that ongoing conditions such as collision_cond hold continuously over the entire overlap interval. A counterexample may exist where trajectories intersect between the start and end events but not at the instants. A formal correctness theorem relating plans in the compiled problem to valid schedules is needed, or a proof that the event-time checks are conservative.","section":"IV-B, Algorithm 2"},{"comment":"The paper replaces exact swept-volume collision checks with a union of inflated inscribed spheres that are 'greedily sampled for a given computation budget' (Section V). This is an approximation with no stated coverage guarantee. If the sampled spheres do not cover the robot mesh, the sphere-based check can miss collisions, potentially producing a schedule that is unsafe when executed. Since the central claim includes producing correct parallel schedules, the authors need to either use a conservative sphere cover (e.g., with formal bounds) or provide evidence that the approximation is safe for the demonstrated domains. Without this, the safety of the output schedules, especially in real-world deployment, is not established.","section":"V"},{"comment":"The text states that EAGER-STREAM 'will provably solve ScheduleStream problems if a solution exists.' This claim requires assumptions about the stream generators: they must eventually enumerate every constant needed for a solution, and the schedule subroutine must be complete for finite problems. The paper does not state or prove these assumptions for the randomized and GPU-based samplers used in Section V. As written, the 'provably solve' assertion is unsupported and should be replaced with a precise theorem under explicit completeness assumptions, or qualified to probabilistic/demonstrated completeness.","section":"IV-C"}],"minor_comments":[{"comment":"In the introductory running example, the goal description says 'arm2 to hold object arm2'; this appears to be a typo for 'obj2'. Please correct.","section":"III, running example"},{"comment":"The phrase 'first general-purpose framework' is strong. Related work (e.g., temporal planning literature, DaSH, and Hartmann & Toussaint) addresses related settings. The novelty claim should be more carefully positioned to avoid overclaiming.","section":"Abstract / I"},{"comment":"The caption of Table II notes that Hierarchical makespans are averaged only over solved problems (denoted *), but the text in Section VI-A does not clearly explain this until later. Consider moving the explanation to the caption or the first mention. Also, 'Hierarchal' is a typo in the table caption.","section":"VI-A, Tables I and II"}],"recommendation":"major_revision","confidential_remarks":null},"author_rebuttal":null,"desk_editor":{"model":"deepseek-v4-flash","letter":"ScheduleStream is worth your time. It is the first domain-independent TAMP framework I know that outputs asynchronously overlapping schedules rather than serial plans, and it does so by adding durative actions and lazy stream grounding on top of the PDDLStream-style machinery. The empirical case is made: Tables I and II show roughly half the makespan at matched success for the GPU version versus a serial baseline, and the real bimanual demos lend credibility. The GPU-accelerated samplers are a genuine step beyond cuTAMP.\n\nWhat the paper does well: the architecture is clean, the ablations are the right ones (sequential and strict hierarchical), and the lazy scheduling algorithm is a sensible way to defer expensive stream calls until they are needed. The distinction between schedules and plans is made clearly, and the problem is well-motivated.\n\nSoft spots, in order of severity. First, the conclusion claims 'higher success rates' over sequential-only, but Table I shows Sequential at 99% average, Ours at 91%, Ours+GPU at 99%. That is an overclaim and should be corrected. Second, the temporal reduction in Algorithm 2 is asserted, not proven. The paper says every schedule can be represented as an interleaving of start/end events and that checking conditions at event instants suffices. That is plausible in this domain because the ongoing conditions are pairwise swept-volume tests that are time-invariant once trajectories are fixed, but the authors don't say that. They should, or prove it. Third, the swept-volume checks in Section V replace exact geometry with greedily sampled inscribed spheres; that can miss collisions, and the paper doesn't acknowledge the risk. Fourth, EAGER-STREAM's 'provably solve' requires a completeness assumption on stream generators that is never stated. Minor issues: no error bars, seeds, or failed-run definitions, and no code/data release.\n\nNone of these sink the paper. The central contribution is real and the experiments support it. The overclaim in the conclusion is a simple fix, and the theoretical gaps can be closed with a formal argument or explicit assumptions.\n\nRecommendation: accept for peer review after a round that addresses the correctness claims and the conclusion. This deserves a serious referee.","headline":"A genuinely new framework for multi-arm TAMP scheduling with strong empirical results, but the theoretical claims outrun the proofs and one conclusion misreads its own table.","tokens_in":14619,"tokens_out":3186,"would_cite":true,"duration_ms":31804,"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":"ScheduleStream extends task and motion planning from serial plans to asynchronous parallel schedules, roughly halving multi-arm makespan at matched success rates.","keywords":["task and motion planning","temporal planning","scheduling","durative actions","lazy stream sampling","GPU acceleration","bimanual manipulation","multi-arm robots"],"falsifier":"Run ScheduleStream-certified parallel schedules for a suite of bimanual problems in a high-fidelity simulator that detects exact mesh contact; any certified schedule that produces a collision during overlapping motion falsifies the safety model. Separately, for small problems where optimal makespan can be found by exhaustive search, compare ScheduleStream's makespan against the optimum: if it never approaches the optimum's factor of two improvement over serial, the headline claim fails.","tokens_in":13634,"feed_emoji":"🤖","tokens_out":5764,"duration_ms":56561,"temperature":0.7,"pith_summary":"Most task and motion planning (TAMP) systems output serial plans in which only one robot arm moves at a time. This paper argues that planning should instead produce schedules: sets of timed actions that let multiple arms move asynchronously in parallel. It introduces ScheduleStream, a general-purpose planning language and algorithms that combine discrete search with continuous samplers to find such schedules. In simulation, the approach roughly halves makespan compared with serial-only planning while keeping success rates near 99 percent, and the authors demonstrate the system on a real bimanual robot. If the claims hold, ScheduleStream would be the first domain-independent TAMP system whose output is an asynchronous multi-arm schedule.","feed_headline":"ScheduleStream halves makespan for multi-arm task planning","feed_subtitle":"A general-purpose planner that outputs asynchronous, overlapping arm motions instead of one-arm-at-a-time serial plans.","key_machinery":"The central object is the hybrid durative action: a timed action with start and end events, ongoing conditions, and a duration function. The load-bearing mechanism is the temporal compilation (Algorithm 2) that reduces scheduling to sequential search over start/end events, converting any event-order plan into an asynchronously overlapping schedule. Supporting machinery: lazy stream generators that create placeholder constants and bind them only when needed, and event-time swept-volume predicates (ArmCollision, ObjCollision) that conservatively certify overlapping motions. GPU batching accelerates the samplers that produce configurations, grasps, and trajectories.","core_discovery":"ScheduleStream's central claim: task and motion planning can be extended to asynchronous schedules by modeling actions as durative actions with start/end events, ongoing conditions, and parameter-dependent duration. The paper compiles durative actions into paired start/end actions so sequential search yields a timed schedule, with safety certified by conservative swept-volume checks at event times. Continuous parameters come from lazy streams; GPU-batched samplers accelerate collision, IK, and motion checks. On five bimanual benchmarks, the lazy GPU planner matches serial success (~99 percent) while halving makespan (first solution 2.0 vs 3.4 s; best 1.5 vs 3.1 s), and the same planner drive","pith_inferences":["Inference: the temporal compilation may transfer to other hybrid planning problems — drone fleets, mobile manipulators, or construction robots — wherever actions have durations and overlapping execution is beneficial.","Inference: because the swept-volume checks are conservative, the reported makespans are upper bounds; a planner with tighter, time-indexed collision checking could find shorter schedules, so the halving is a lower bound on the possible gain.","Inference: the lazy-stream design could accept learned samplers (neural IK, learned motion generators) as drop-in stream generators, connecting this planning approach to learning-based robotics.","Inference: the large gap between eager and GPU-accelerated lazy runtimes suggests search efficiency, not just sampler speed, is the key bottleneck; anytime search or parallel search could extend the tradeoff curve."],"forward_implications":["Any TAMP domain expressed with durative actions and streams can in principle be scheduled, not just the benchmark manipulation tasks shown.","Problems that are not downward refinable — where a high-level schedule fails at the motion level — remain solvable because scheduling and sampling alternate with backtracking.","GPU-batched sampling brings parallel-schedule planning down to about two seconds to a first solution, making it usable on real robots.","Serial planning appears as a special case: ScheduleStream on the same problems yields schedules with roughly half the makespan at equal success rates.","A single domain-independent planner can replace application-specific multi-arm coordination code for bimanual tasks."],"fun_headline_variants":["GPU planner cuts multi-arm task makespan in half","ScheduleStream: parallel arm motion, half the time","New planner schedules robot arms in parallel, not serial","Multi-arm TAMP with GPU samplers slashes makespan","ScheduleStream: async arm movements, 50% faster plans"],"cache_read_input_tokens":2304,"weakest_assumption_plain":"The load-bearing premise is that every feasible parallel schedule can be represented as an interleaving of discrete start/end events and that the conservative swept-volume checks evaluated at those event times certify safety; if this event-time certification or its sphere approximation misses a collision, a planned parallel execution could collide.","fun_headline_variants_meta":{"raw":{"variants":["GPU planner cuts multi-arm task makespan in half","ScheduleStream: parallel arm motion, half the time","New planner schedules robot arms in parallel, not serial","Multi-arm TAMP with GPU samplers slashes makespan","ScheduleStream: async arm movements, 50% faster plans"]},"model":"deepseek-v4-flash","effort":"low","cost_usd":0.00016,"raw_usage":{"total_tokens":1072,"prompt_tokens":747,"completion_tokens":325,"prompt_tokens_details":{"cached_tokens":256},"prompt_cache_hit_tokens":256,"prompt_cache_miss_tokens":491,"completion_tokens_details":{"reasoning_tokens":244}},"tokens_in":491,"tokens_out":325,"duration_ms":3659,"temperature":1.0,"reasoning_tokens":244,"cache_read_input_tokens":256,"cache_creation_input_tokens":0},"cache_creation_input_tokens":0},"created_at":"2026-08-03T23:36:16.283650+00:00","model_set":{"reader":"deepseek-v4-flash"},"falsifier":"Run ScheduleStream-certified parallel schedules for a suite of bimanual problems in a high-fidelity simulator that detects exact mesh contact; any certified schedule that produces a collision during overlapping motion falsifies the safety model. Separately, for small problems where optimal makespan can be found by exhaustive search, compare ScheduleStream's makespan against the optimum: if it never approaches the optimum's factor of two improvement over serial, the headline claim fails.","supporting_citations":[],"review_version":1}