{"id":"f76ff244-6001-403f-9c6a-dd0b581bf602","arxiv_id":"2501.16539","paper_version":1,"verdict":"REJECT","confidence":"HIGH","novelty_score":5.0,"correctness_risk":"medium","formal_verification":"none","parameter_count":3,"one_line_summary":"An LLM with function-calling builds TAEMS-style hierarchical task trees, and a heuristic search converts them into multiple robot task assignments, shown on four qualitative missions.","lead":"This paper builds a mission planner that uses a large language model, guided by hand-designed subroutines, to break a high-level goal into a tree of tasks for a team of robots with different abilities. A heuristic then turns the tree into several feasible task schedules, demonstrated on qualitative examples such as reuniting a lost child with a parent.","discovery_kind":"new_method","skeptic_critique":{"model":"deepseek-v4-flash","headline":"Algorithm 1's greedy pruning can discard all resource-feasible assignments, undermining the claimed guarantee of mission completion under resource constraints.","rationale":"The paper's central claim is that the framework 'effectively generates optimized schedules' and 'ensuring that missions are completed while adhering to system resources and constraints' (Sections III-B and VI). The reader's weakest assumption concerns the completeness of the designer-provided subtree library and the LLM's adherence to it. That is a legitimate scope concern, and the paper's own restaurant example (Fig. 5e) supports it. However, a more fundamental, internal correctness issue sits in Algorithm 1: the greedy pruning at each tree node ranks partial alternatives solely by summed utility and discards all but the top ρ before resource interactions with sibling subtrees are considered. This can eliminate the only resource-feasible combination for a parent node, so the algorithm may return no assignment even when a valid one exists. The paper's limitation section acknowledges possible suboptimality but does not acknowledge this incompleteness, while Algorithm 1 is presented as ensuring mission completion under constraints. This concern is load-bearing because it applies even when the LLM constructs a perfect tree and when the subtree library is complete; it directly contradicts the 'ensuring' language in the central claim. The concrete test above would settle it with a minimal counterexample. Because the concern reinforces the already negative verdict rather than overturning it, I recommend leaving the reader's verdict unchanged.","tokens_in":10203,"tokens_out":5750,"duration_ms":59493,"concrete_test":"Implement Algorithm 1 exactly as specified with ρ=1 and resources R={r1,r2}. Define a root AND node with children T1 and T2. T1 is XOR of primitive actions p1 (robot r1, utility 1.0) and p2 (robot r2, utility 0.1). T2 is XOR of q1 (robot r1, utility 1.0) and q2 (robot r2, utility 0.1). Use the resource check from the paper: each robot may be assigned at most once. Run the algorithm. If task_alt at the root is empty, or if the returned assignment violates the resource constraint, the feasibility guarantee of Algorithm 1 is falsified. This test isolates the pruning step from LLM and tree-construction issues.","verdict_should_be":"UNCHANGED","load_bearing_attack":"Algorithm 1 (Section III-B) prunes to the top ρ alternatives by utility at every node before resource interactions with sibling subtrees are known. Because pruning is purely utility-ranked and does not preserve resource diversity, it can discard the only resource-feasible combination for a parent AND node. The paper's limitation section (V) concedes suboptimality but not incompleteness, while the text claims the algorithm ensures missions are completed while adhering to resources (Section III-B, Algorithm 1). Concretely, with ρ=1, two XOR children whose highest-utility alternatives both require the same robot, the cartesian product at the parent fails the resource check and the algorithm returns no alternative, even though a lower-utility pair is feasible. Thus the central guarantee is not established; this is an internal correctness gap independent of LLM behavior.","agreement_with_reader":"partial"},"referee_report":{"model":"deepseek-v4-flash","summary":"The paper proposes a mission-planning framework for heterogeneous multi-robot teams. It exposes a library of predefined subtree routines and APIs to an LLM, which uses function calling to construct a hierarchical AND/XOR tree whose leaves are robot-executable primitive actions. A heuristic recursive algorithm (Algorithm 1) then enumerates and prunes alternative multi-robot task assignments, followed by topological sorting for precedence constraints. The pipeline is demonstrated on four missions: reuniting a lost child, helping a woman with heavy luggage, saving a city from a monster, and rescuing a cat from a burning building; a fifth mission (recommending Italian restaurants) is shown as an incomplete tree. The paper claims that the framework effectively generates optimized schedules, adheres to robot constraints and capabilities, and is flexible and scalable across a wide range of missions.","tokens_in":10340,"tokens_out":6353,"duration_ms":65273,"significance":"If made to work reliably, the idea of constraining LLM hierarchical planning through capability-grounded subtree routines and API function calling is a useful and timely contribution to high-level mission planning for heterogeneous multi-robot teams, particularly for CD[ST-MR-TA] problems. The paper is clearly written, and the detailed function-call trace for the lost-child example makes the proposed interaction concrete and easy to follow. The paper also deserves credit for explicitly acknowledging several failure modes in Section IV and for being candid about the heuristic nature of the decomposition algorithm. However, the current evidence is far weaker than the claims: the results are four qualitative examples, two of which are admitted failures, with no quantitative metrics, no baselines, no ablations, and no closed-loop execution. In addition, Algorithm 1 has a load-bearing completeness gap that is not captured by the stated limitation of suboptimality. The contribution is therefore a promising prototype rather than an established framework.","major_comments":[{"comment":"","section":"Section III-B, Algorithm 1"},{"comment":"","section":"Section IV"},{"comment":"","section":"Section IV, Table I"},{"comment":"","section":"Section III-A and Section V"}],"minor_comments":[{"comment":"","section":"Section IV and Fig. 4"},{"comment":"","section":"Fig. 1 caption"},{"comment":"","section":"Algorithm 1"},{"comment":"","section":"Section II, Eq. (1)"},{"comment":"","section":"Section IV"},{"comment":"","section":"Section V"}],"recommendation":"major_revision","confidential_remarks":"The reader's reject verdict is understandable given the lack of quantitative evaluation and the admitted failures, but I see the main issues as fixable within a revision: add a systematic evaluation with baselines and ablations, fix the resource-aware pruning gap in Algorithm 1 (or weaken the guarantee claim), and temper the generalization claims. The core idea is worth pursuing, but the current manuscript is not yet ready for acceptance."},"author_rebuttal":null,"desk_editor":{"model":"deepseek-v4-flash","letter":"Two things to know. The core idea is genuinely a new combination: LLM function-calling to assemble TAEMS-style hierarchical trees from a fixed library of capability-specific subtree routines, then a heuristic enumerator to produce MRTA alternatives. That is a sensible architecture, and it is more than a restatement of prior work. But the paper does not demonstrate its headline claim of \"effectively generates optimized schedules.\" The evidence is four qualitative examples, two of which the authors themselves flag as failures (cat rescue has an infeasible \"Display message to cat\" action; restaurant recommendation tree is incomplete). There are no baselines, no quantitative metrics, no closed-loop runs, no released code. On that basis alone, the effectiveness claim is not supported.\n\nI also think the reader's take is right, and I would sharpen one point. Algorithm 1 prunes to the top ρ alternatives by utility at every node before resource interactions with sibling subtrees are known. With ρ=1, two AND children whose highest-utility alternatives both require the same robot will produce a cartesian product that fails the resource check, and the algorithm returns no alternative—even though a lower-utility pair is feasible. So the paper's claim that the algorithm ensures missions are completed under resource constraints is not just unproven; it is false for the stated algorithm. The limitation section concedes only suboptimality, not incompleteness. That is an internal correctness gap independent of LLM behavior.\n\nCredit where earned. The subtree-routine API design is thoughtful; enforcing that every leaf terminates in a predefined subtree is a legitimate way to constrain LLM hallucination. The authors are transparent about the failed cases and about reliance on designer-provided routines. The paper is readable and the pipeline is plausible.\n\nWho gets value: researchers working on LLM-based task decomposition in multi-robot systems will find this a useful reference, and the failure cases are instructive. But as a stand-alone contribution the evaluation is too thin, and the completeness gap in Algorithm 1 needs to be addressed. I would not cite it as a demonstrated method; I might bring it to a reading group as a cautionary example.\n\nRecommendation: I would not desk-reject this outright—the architecture and the failure analysis are worth referee time. But I would expect the review to come back with major revision: close the resource-feasibility gap (or state the guarantee accurately), add quantitative evaluation with baselines, and release code and data. My own verdict would be reject in current form, accept only after substantial revision.","headline":"A plausible LLM+TAEMS pipeline that is well-described but under-evaluated, with a real completeness bug in the pruning algorithm; deserves review but not acceptance as is.","tokens_in":10875,"tokens_out":2363,"would_cite":false,"duration_ms":24857,"reading_group":"maybe","serious_thinker":"yes","would_accept_peer_review":true},"rs_alignment":null,"lean_confirmation":null,"pith_extraction":{"msc":[],"pacs":[],"model":"deepseek-v4-flash","headline":"The paper claims that a large language model, guided by structured APIs and predefined subtree routines, can turn a high-level mission objective into a hierarchical task tree, and that a recursive heuristic can decompose that tree into…","keywords":["mission planning","multi-robot task allocation","heterogeneous robot teams","large language models","hierarchical task trees","LLM function calling","task decomposition","MRTA"],"falsifier":"Run the pipeline on a mission whose required capability is absent from the subtree library, such as 'Recommend best Italian restaurants in the area,' and observe whether the LLM-built tree terminates: the paper's own Fig. 5e shows it does not, which would falsify the claim that the framework generalizes to any mission expressible with the library. A second check is to execute the cat-rescue alternative A2 and see whether the social robot's primitive 'Display message to cat' actually causes the cat to follow it.","tokens_in":10024,"feed_emoji":"🤖","tokens_out":6497,"duration_ms":62300,"temperature":0.7,"pith_summary":"The paper claims that a large language model can take a high-level mission objective and assemble a hierarchical task tree by calling custom tree-construction APIs, with every branch ending in a designer-provided subtree routine tied to a robot capability. A recursive heuristic then decomposes the tree into several alternative per-robot schedules, each an assignment of primitive actions to specific robots that respects capability constraints and precedence relations. The authors argue this pipeline removes human task decomposition from multi-robot mission planning and generalizes across diverse real-world missions using the same small library of subtrees. They demonstrate it on missions such as reuniting a lost child with its mother, helping a pedestrian with luggage, saving a city from a monster, and rescuing a cat from a fire, while reporting a restaurant-recommendation mission where the tree fails to terminate. If the claim holds, mission planners could specify only the goal and let the model plus subtree library produce executable team plans.","feed_headline":"LLM-built task trees turn mission goals into robot schedules","feed_subtitle":"Same capability subtrees and APIs let one pipeline handle search, rescue, transport, and more.","key_machinery":"The load-bearing object is the hierarchical tree: round non-primitive nodes and rectangular primitive nodes connected by AND (all children required) or XOR (exactly one child required) logical constraints, with optional precedence edges between tasks. Around it sit the designer-written subtree routines—functions such as Follow(agent, resources) that inject a capability-based subtree including the primitive actions of every suitable robot—and the API set the LLM calls to construct and inspect the tree. The final piece is the recursive MRTA alternative algorithm, which builds action sets from primitive nodes upward, sums utilities over each alternative, checks resource consumption, and prunes to the top $\\rho$ alternatives. Together these pieces convert an open-ended natural-language objective into a finite set of executable, resource-feasible per-robot task lists.","core_discovery":"The central discovery is that LLM function-calling can be constrained well enough to build structured task hierarchies instead of free-form plans. Given a set of robot capabilities, the designer writes a library of subtree routines, such as follow, search, reach, transport, and combinations; each routine attaches a fixed subtree that lists the primitive actions available to every robot with the relevant capability. The LLM calls provided APIs to initialize the tree, add subtasks with AND or XOR logic, and attach subtrees, so every leaf is an executable primitive rather than a hallucinated step. Algorithm 1 then computes multi-robot task allocation alternatives recursively from the leaves upward, summing a per-action utility $u_a(i)=\\alpha q_a(i)-\\beta d_a(i)-\\gamma c_a(i)$, enforcing resource feasibility, pruning to the $\\rho$ best alternatives to avoid combinatorial explosion, and topologically sorting each assignment to respect precedence. The authors claim this yields multiple optimized schedules that align each task with the constraints and capabilities of the individual robot, and that the same routines and APIs transfer across missions.","pith_inferences":["A testable extension is to add an explicit completeness check before execution: verify that every branch of the LLM-built tree terminates in a known subtree and flag missions outside the capability library as infeasible rather than letting the LLM hallucinate.","The utility-only pruning criterion makes schedule quality depend on the designer-chosen utility weights; measuring plan quality across varied $\\alpha,\\beta,\\gamma$ settings would reveal how much of the result is carried by the tree structure versus the scoring function.","The admitted infeasible 'Display message to cat' primitive in the cat-rescue alternative suggests that restricting subroutine arguments to object types the robot can actually act on would reduce the number of unusable schedules the pipeline emits.","Since the paper leaves replanning for mission failures to future work, a natural next step is a closed-loop version where execution failures trigger the LLM to rebuild the affected subtree; this could be tested by injecting task failures into the current pipeline."],"forward_implications":["Mission specification can become a natural-language goal plus a reusable subtree library, removing the need for a human to hand-decompose each new mission into tasks.","Robot selection and team formation happen inside tree construction, because each subtree includes nodes only for robots with the relevant capability; the same tree therefore encodes who does what.","Because the algorithm outputs multiple alternatives, a human or higher-level controller can choose among them, avoiding alternatives whose primitive actions are infeasible in the real world.","The same predefined subtree routines and APIs support different mission domains, so adding a new mission does not require new planning code as long as the needed capability has a subtree.","Precedence constraints are handled by topological sorting, so schedules emitted by the pipeline are ordered consistently with inter-robot dependencies."],"supporting_citations":[{"why":"Defines the MRTA taxonomy and identifies complex missions of type CD[ST-MR-TA] that the paper targets.","marker":"[16]"},{"why":"Supplies the task-hierarchy representation that motivates the hierarchical tree structure.","marker":"[29]"},{"why":"Details the quality-duration-cost utility model used to score primitive actions.","marker":"[30]"},{"why":"Provides the large language model whose function-calling behavior the framework relies on.","marker":"[13]"},{"why":"Supplies the chain-of-thought prompting method used to stabilize LLM tree construction.","marker":"[36]"},{"why":"Provides the topological sort algorithm used to order each robot's tasks by precedence.","marker":"[35]"},{"why":"Previous approach using hierarchical trees for heterogeneous multi-robot mission planning that the paper contrasts with its LLM-automated version.","marker":"[28]"}],"fun_headline_variants":["LLM-crafted trees plan robot missions","Hierarchical LLM trees guide robot teams","Mission planning via LLM-built tree structures","LLM tree builder schedules heterogeneous robots","From goals to schedules: LLM task trees"],"cache_read_input_tokens":3200,"weakest_assumption_plain":"The framework assumes a small, designer-fixed set of subtree routines can express every mission the team will face, and that the language model will only combine them into executable plans; the restaurant example and the infeasible 'display message to cat' primitive show both halves can fail.","fun_headline_variants_meta":{"raw":{"variants":["LLM-crafted trees plan robot missions","Hierarchical LLM trees guide robot teams","Mission planning via LLM-built tree structures","LLM tree builder schedules heterogeneous robots","From goals to schedules: LLM task trees"]},"model":"deepseek-v4-flash","effort":"low","cost_usd":0.000154,"raw_usage":{"total_tokens":1162,"prompt_tokens":849,"completion_tokens":313,"prompt_tokens_details":{"cached_tokens":384},"prompt_cache_hit_tokens":384,"prompt_cache_miss_tokens":465,"completion_tokens_details":{"reasoning_tokens":247}},"tokens_in":465,"tokens_out":313,"duration_ms":3961,"temperature":1.0,"reasoning_tokens":247,"cache_read_input_tokens":384,"cache_creation_input_tokens":0},"cache_creation_input_tokens":0},"created_at":"2026-08-10T12:30:09.463933+00:00","model_set":{"reader":"deepseek-v4-flash"},"falsifier":"Run the pipeline on a mission whose required capability is absent from the subtree library, such as 'Recommend best Italian restaurants in the area,' and observe whether the LLM-built tree terminates: the paper's own Fig. 5e shows it does not, which would falsify the claim that the framework generalizes to any mission expressible with the library. A second check is to execute the cat-rescue alternative A2 and see whether the social robot's primitive 'Display message to cat' actually causes the cat to follow it.","supporting_citations":[{"cited_title":"TAEMS: A framework for environment centered analysis & design of coordination mechanisms,","cited_arxiv_id":null,"evidence_quote":"Supplies the task-hierarchy representation that motivates the hierarchical tree structure."},{"cited_title":"The TAEMS white paper,","cited_arxiv_id":null,"evidence_quote":"Details the quality-duration-cost utility model used to score primitive actions."},{"cited_title":"Distributed mission planning of complex tasks for heterogeneous multi-robot systems,","cited_arxiv_id":null,"evidence_quote":"Previous approach using hierarchical trees for heterogeneous multi-robot mission planning that the paper contrasts with its LLM-automated version."}],"review_version":1}