Frontier Radar | LOGIV: a completed action does not mean its conditions still hold; checking support step by step on a PDDL task graph and repairing only the affected part when it fails

LOGIV checks conditions left by completed actions on a PDDL task graph and repairs locally. Authors: +10.67/+15.33 pp clean success; real robots 12/30→17/30.

Left-to-right timeline diagram with the title “LOGIV: local repair, step by step” at the top and a source line at the bottom. Five numbered circular nodes are arranged in sequence and connected by arrows, each with a short text below it. Step 1, Scope: replace only an action whose own effects failed; step 2, Back-step from the goal through kept actions: g_rep; step 3, Plan repair fragment ΔP from the current state; step 4, VAL checks ΔP + kept plan; failure: replan or widen; step 5, Rebuild the graph; completed actions are not replayed.
LOGIV’s repair steps after a confirmed failure (Algorithm A-B in the paper): first the replacement scope is fixed, initially replacing only a just-executed action whose own effects failed, while unfinished actions that depend on a missing precondition or invalidated support stay in the retained plan; then the system works backward from the goal g through the retained actions to find the conditions g_rep that must hold before they resume; the planner generates a repair fragment ΔP from the current state; VAL checks whether ΔP followed by the retained plan reaches the goal, replanning within the same scope if the failure lies inside the fragment and widening the scope to a retained action and its unfinished causal successors if the failure lies there; finally the task graph is rebuilt and execution resumes from the earliest ready node. Each failure allows at most three repair rounds, and repair is not guaranteed to be minimal or complete. Drawn from Section III-C and Appendix A-B of arXiv 2610.40016 (authors’ description); the numbers and arrows show only the order of steps, not a ranking, and the diagram contains no measurements.

The preprint LOGIV (arXiv 2610.40016, 2026-10-29; authors from CUHK-Shenzhen, A*STAR, Caltech, NUS, HKUST, COCO Matrix and NTU) tackles a problem in long-horizon tasks that is easy to overlook: once an action is complete, the conditions it left behind do not necessarily stay true. A support placed while building a bridge can be knocked out of position while the robot grasps the beam. “Place the support” still counts as done, but the support that “place the beam” needs is gone. LOGIV adds an execution and repair layer with no trainable parameters on top of an existing VLA or world action model (WAM) policy. It compiles a PDDL plan into a task graph, uses visual and robot feedback to check those conditions step by step during execution, replaces only the affected part when one fails, and validates the entire continuation with VAL before execution resumes. All numbers below are author-reported [R]; this site has not reproduced them.

The problem: “completed” and “still holds” are two different things

The paper starts from the point that reliable long-horizon execution has to track both whether an action has completed and whether its results continue to hold. LOGIV’s key design keeps the two apart: a node’s completion status is one thing, and whether the support it provides to later actions is currently valid is another. When that support fails, the completed node is not reopened, and the unfinished actions that depend on it stay in the plan; repair only has to re-establish their prerequisites. The paper illustrates this with the BiCoord build_bridge task (Fig. 1): after a support is displaced, LOGIV repairs only the support operations, keeps the beam operations, and resumes on the updated task graph.

The authors say explicitly that they do not treat dependency tracking itself as a new planning principle. It builds on existing work in causal-link monitoring and plan repair; what is new is using visual state assessment to update these producer–consumer dependencies and then choosing a local repair scope from them.

Building the task graph: two kinds of edges, one reference order

The input is a PDDL Domain (reusable operators with their parameters, preconditions and effects) and a Problem (objects, initial state S0 and goal g). LAMA-first in Fast Downward searches for a sequence of grounded operators, and VAL independently checks action bindings, preconditions, modeled effects and the final goal. If the check fails, VAL returns the location and reason; that sequence is excluded and the search runs again. Graph construction starts only after validation passes:

  • Causal edges. For each precondition of each operator, the compiler looks back for the nearest operator that produces that condition with no intervening invalidation, and adds an edge labeled with the condition. Conditions supplied by S0 originate at a START node, and goal conditions link to a GOAL node. The paper points out that “causal” here means condition support in the PDDL sense, not a learned causal model.
  • Resource edges. These keep the ordering for exclusive resources such as an arm or a gripper, and for modeled interference (one operator invalidating a condition another one requires or establishes).

Both edge types follow the order of the reference plan P, so the graph is acyclic and P is one of its topological orders. The paper also cautions that other topological orders need not be valid, so execution order is checked online.

Three checks during execution

For scheduling, among the actions whose predecessors are complete, the system picks the earliest one in P whose execution conditions hold and passes it to the low-level policy as a natural-language instruction along with the current image. Each node is checked once before and once after execution:

  • State Gate: a VLM (GPT-4o, at most 512 output tokens per call) extracts facts about the current action and its dependencies from the image, and combines them with robot state and actuator feedback into a symbolic state. If the evidence is insufficient, the system acquires new images, adjusts the viewpoint or repeats the check, with at most three additional observations; if a fact still cannot be confirmed, the result is UNRESOLVED and execution stops.
  • Node Gate: before execution it checks preconditions, and a confirmed unmet precondition returns a failure with PRECONDITION_FAILURE; after execution it checks the expected effects, and only when they pass is the node marked complete.
  • Graph Gate: before execution it checks resource predecessors and condition support; after execution it checks whether the support provided by START and by every completed action still holds for the remaining actions and GOAL.

So if the support is knocked out of place while the beam is grasped, repair is triggered with EFFECT_FAILURE even though the grasp itself succeeded. The failure record contains the failure type, the node, the unmet condition and the failed edge.

Repair: what to keep, what to replace, how to validate

The first step of repair separates “affected actions” from “actions that must be replaced.” The affected actions are the unfinished action at which the failure was detected, or the unfinished actions that directly depend on the invalidated support, plus their unfinished causal successors. Initially, only a just-executed action whose own effects failed is replaced. An action with a missing precondition is retained, and repair first restores that precondition. When support from a completed action is invalidated, the action still counts as complete and its consumers are retained as well.

The remaining unfinished actions form the retained plan P_keep. Starting from the goal g, the system works backward through these retained actions in reverse order to determine the conditions g_rep that must hold before they resume. If a retained action deletes a condition that is still required, or if contradictory conditions appear, the requirement is judged infeasible. The paper’s example: a retained “grasp the beam” action needs gripper_empty and itself produces holding(beam), so the repair only has to free the gripper before the grasp and does not need to establish holding(beam) in advance.

Next, the planner generates a repair fragment ΔP from the current state that achieves g_rep, places it in front of P_keep, and VAL checks whether the full continuation reaches g. If the failure lies inside the repair fragment, the system replans within the same scope, and a repeated candidate ends repair. If it lies at a retained action, the replacement scope widens to that action and its unfinished causal successors. A planning failure, a timeout or a failure that cannot be located falls back to a deterministic rule in the paper’s appendix. Once validation passes, the task graph is rebuilt: completed actions stay complete and are not replayed, and their still-valid effects are represented by the current state and a new START node.

The budgets are specific: 30 s per planning call and 5 s per VAL call; at most three local repair rounds and four VLM calls per failure, beyond which the episode ends; human assistance is disabled in all experiments. The authors state that passing VAL only shows the plan is consistent with the symbolic model and the supplied state, and does not guarantee accurate perception or physical success; repair is also not guaranteed to be minimal or complete.

Results: two simulation benchmarks, three real-robot tasks

Setup. Ten dual-arm tasks each were selected from RoboTwin V2 and BiCoord, with ten predefined initial states per task, giving 100 episodes per benchmark and setting. The clean setting runs each initial state once. The perturbed setting reuses the same initial states and injects one recoverable disturbance at a predefined event; the disturbance type and trigger are fixed within each task. In move_can_pot, for example, the pot is shifted laterally by 10–15 cm after the can is grasped and lifted. The three execution backbones, π0.5, AHA-WAM and Light-WAM, were each fine-tuned task by task on the ten tasks of each benchmark, using expert demonstrations without the evaluation-time perturbations. The three comparison methods, VeriGraph-PDDL, LERa-PDDL and VLM-RP-BT, are versions the authors adapted from the ideas of the original methods, not unmodified implementations of the original systems.

Without perturbations (C). Mean success across the three backbones rises from 71.67% to 82.33% on RoboTwin V2 and from 42.33% to 57.67% on BiCoord. The authors’ explanation is that the robot still encounters state deviations and action failures even when no disturbance is injected.

With perturbations (P). The table puts the backbone alone, the highest of the three adapted comparison methods, and LOGIV side by side (numbers from the paper’s Table I; the “strongest adapted baseline” column was picked out by this site):

BenchmarkBackboneBackbone aloneStrongest adapted baselineLOGIV
RoboTwin V2π0.53258 (VLM-RP-BT)60
RoboTwin V2AHA-WAM6080 (VLM-RP-BT)83
RoboTwin V2Light-WAM5870 (VLM-RP-BT)72
BiCoordπ0.53145 (VLM-RP-BT)48
BiCoordAHA-WAM4348 (LERa-PDDL and VLM-RP-BT tied)53
BiCoordLight-WAM3946 (VeriGraph-PDDL)49

Values are in %. LOGIV is above all three comparison methods in all six groups, and the same holds for condition restoration (R). This site reads two things from this. First, in five of the six groups, most of the gain over the backbone is already achieved by the strongest adapted baseline (in the BiCoord plus AHA-WAM group it is an even split); LOGIV’s margin over the strongest one is 2–5 percentage points. Second, each cell is 100 episodes, so 2 percentage points corresponds to 2 episodes (this site’s conversion), and the text we read gives no confidence intervals or significance tests for the simulation results. The paper also notes that R’s denominator is each method’s own set of eligible disturbance events, which may differ between methods, so R should be read alongside P.

Real robots. On two dual-arm platforms, π0.5 and π0.5 + LOGIV use the same checkpoint and the same demonstrations, with ten trials per task under matched initial layouts; a trial succeeds only when the full instruction is completed. No disturbances were injected in the real-robot trials.

  • pick_tomato (Astribot S1): 7/10 → 9/10, with recovery from empty grasps and early releases.
  • build_blocks (Astribot S1): 3/10 → 5/10. When a later reach displaced a block already placed, the Graph Gate detected that a condition required by the remaining placements no longer held, and repair restored only that block.
  • insert_cable (AgileX Piper): 2/10 → 3/10. Most remaining failures were a plug that was aligned but did not seat, which depends on the contact precision of the low-level policy rather than on the plan.
  • Overall 12/30 (40.0%) → 17/30 (56.7%). The authors themselves state that with ten trials per task the confidence intervals are wide, so this is a trend.

Ablations (the ten RoboTwin V2 tasks, π0.5, 100 episodes per setting):

  • The authors state that removing the State Gate, the Node Gate or the Graph Gate lowers all three success measures, but the text we read gives numbers only for removing the Graph Gate: perturbed-task success falls from 60% to 48%, which the authors call the lowest perturbed-task success among the variants. Removing uncertainty handling (UNRESOLVED) lowers condition restoration from 72% to 59%.
  • Without causal tracing, selecting repair nodes by their position in the linear plan: the modified-node fraction stays at 24.6%, but clean-task success falls from 72% to 61% and perturbed-task success from 60% to 52%. The authors conclude that which nodes are chosen matters, not only the size of the modified region.
  • Replacing local repair with replanning all remaining actions: the modified-node fraction becomes 100%, still-valid completed actions executed again rise from 0.2 to 1.6 on average, and perturbed-task success falls to 54%.
  • Without VAL validation of the repaired plan: condition restoration falls from 72% to 62%, and perturbed-task success from 60% to 57%.

How this relates to the course and other Frontier Radar posts

In the terms of Physical AI Lab 0.3: See, Think, Act, LOGIV changes the slower layer of “think.” It does not touch how the low-level policy generates actions; it decides what to hand the policy next, what to check after execution, and which part of the plan to change after an error. In Frontier Radar | RESETTLE, recovery happens at the action interface of a frozen policy; in LOGIV, it happens at the symbolic plan layer. Frontier Radar | SCOPE uses PDDL planning failures as an offline signal for generating training data, whereas LOGIV uses PDDL and VAL online during execution. Frontier Radar | Cracking Mobile Manipulation looks at success dropping once subtasks are chained, and relies on attributing failed episodes after the fact; LOGIV’s failure record states the node, the condition and the edge at run time. These works differ in benchmarks, backbones and disturbances, so their numbers cannot be compared with each other.

LOGIV’s result tables are good practice for the method in Physical AI Lab 1.8: Evaluation: how stable is a 2–5 point gap when each cell has 100 episodes? The real-robot 12/30 and 17/30 are two counts under matched layouts, so one can ask how many pairs improved and how many got worse; the paper’s real-robot table gives only per-task totals.

Limitations

  • This is an arXiv preprint; all numbers are author-reported [R], and this site has not reproduced them. The paper’s first page lists a GitHub repository and a project page; this site has not opened them to check their contents.
  • The method depends on a PDDL specification written in advance and held fixed: deterministic logical preconditions and effects, and typed object parameters. The text we read does not discuss what happens when the specification is wrong or misses a condition; as this site understands it, a new task needs at least a new Problem, and the Domain must also be extended when the new task needs operators or conditions that the original Domain lacks.
  • Each simulated episode has only one disturbance, predefined and recoverable, with its type and trigger fixed within a task. No disturbances were injected in the real-robot trials; condition restoration on real robots appears only in the text describing build_blocks and is not counted separately.
  • Every backbone was fine-tuned task by task on the ten selected tasks; Table A1 lists the selected subset, not all tasks in either benchmark. The three comparison methods are the authors’ adaptations, and how they were implemented determines how fair the comparison is.
  • The paper does not report the runtime or resource cost of online checking and repair; the authors list it as future work. The VLM is GPT-4o, and the text we read gives no results with other models.
  • The simulation results have no confidence intervals; on real robots each task has ten trials, and the authors note the confidence intervals are wide. None of these results is a hardware safety validation.

Links