AI guides

LOGIV verifies long-horizon robot execution with task graphs and repairs failures locally

By 机器之心1 viewsSource: 机器之心
LOGIV task-graph verification and causal local repair for long-horizon robot tasks

The framework links planning and execution through explicit conditions and resource relationships. Simulation and small real-robot tests assess recovery while preserving valid remaining plans.

In robot manipulation research, vision-language-action models (VLA) and world action models (WAM) offer different routes to generating robot actions. But when tasks extend from a single pick-and-place to sequential construction and dual-arm coordination, success depends on more than completing the current action. Conditions established earlier must also continue supporting subsequent execution.

Why can an action clearly succeed, yet the overall task fail at the next step? What do robots really lack: stronger action models, or a system that organizes those actions?

Addressing this question, researchers from The Chinese University of Hong Kong, Shenzhen, Singapore's A*STAR, Tsinghua University and other institutions proposed LOGIV, introducing Graph Engineering into the execution architecture of agentic robots. Built on existing VLA and WAM policies, it constructs explicit task graphs, turning conditional dependencies and resource orderings between actions into an execution basis that can be checked, traced and repaired.

LOGIV moves the system's focus from whether an action has finished to whether the remaining plan still holds. Through graph-dependency verification and causal local repair, a robot can restore necessary support after detecting failed conditions, preserve usable plans and continue toward the goal. Without adding new trainable components to this layer, the task graph can genuinely participate in the robot's execution decisions.

Article illustration

Article illustration

  • Paper: LOGIV: Graph-Verified Execution with Causal Local Repair for Long-Horizon Robot Tasks
  • Full paper: https://arxiv.org/abs/2610.40016
  • Project website: https://enqiao-lu.github.io/logiv-project/
  • Code and demonstrations: https://github.com/Enqiao-Lu/LOGIV

Tackling long-horizon execution: from actions to dependencies

Having a robot build a block bridge sounds simple: position supports on both sides, pick up a beam and place it on top. But what if picking up the beam accidentally knocks a support out of place?

The grasp succeeded, and the earlier placement really was completed, yet the next step no longer has the conditions it needs. Continuing the plan may place the beam on a support point that no longer exists. This is a hidden problem in long-horizon physical interaction: completion of an action is history, but the conditions it creates can fail at any time. If a system records only task progress without checking whether those conditions still hold, past success can conceal present risk.

Written as a to-do list, a long task tells a robot what to do first and next. Organized as a task graph, it also lets the robot ask what the next step actually depends on, and which later actions cannot proceed if a condition fails. LOGIV therefore brings Graph Engineering to the execution layer, organizing tasks as a directed acyclic graph containing two types of dependency.

  • Task nodes: high-level subtasks such as grasping and placement, as well as the task's starting point and final goal.
  • Condition-support edges: record which action establishes a condition needed by a later action, such as support blocks being in place before a beam can be installed.
  • Resource-ordering edges: record the order in which resources such as arms and grippers are used, along with modeled conflicts between actions.

The graph connects planning and actions and provides a basis for recovery. After a support block shifts, the system can trace downstream effects along the failed condition-support relationship without treating the entire task as a failure.

Article illustration

Figure 1: after a support block is knocked out of place, LOGIV restores the failed supporting condition and preserves usable subsequent beam operations. Source: Fig. 1 of the paper.

Connecting VLA and WAM into a closed execution loop

If Graph Engineering organizes long tasks, who performs the underlying actions? LOGIV provides a clear division of work. The upper layer selects subtasks based on the current state and task dependencies, converting high-level actions into natural-language instructions. The lower-level policy executes using instructions and visual observations, then the upper layer checks the action's effects and conditions needed by the remaining plan. The end of one action becomes the starting point for the next judgment.

The paper pairs the framework separately with three execution models to test whether it works across different policy approaches.

  • π0.5 serves as the VLA execution model, mapping visual observations and task instructions to robot actions.
  • AHA-WAM and Light-WAM serve as two WAM execution models, performing upper-layer-specified operations under their respective policy architectures.

As Figure 2 shows, LOGIV builds an independent task-organization and recovery layer above VLA and WAM, connecting different execution policies to a unified planning, verification and repair loop. They need not be retrained into one large model, and no additional trainable components are introduced for the framework. The architecture has been validated with task-fine-tuned π0.5, AHA-WAM and Light-WAM. Its dependency checks and local repairs can be reused across policies; adding new tasks requires matching task models, perceptual information and execution interfaces.

Article illustration

Figure 2: LOGIV sits above the underlying VLA or WAM policy, checking states, nodes and graph dependencies before and after execution and entering repair after a failure is confirmed. Human assistance shown in the figure is a future evaluation direction; the experiments reported in the paper did not enable it. Source: Fig. 3 of the paper.

In implementation, LOGIV realizes the Figure 2 architecture through three linked stages: task-graph construction, online verification and local repair.

1. Task-graph construction: compile an action sequence into a dependency graph

The system first uses a predefined PDDL task model to describe action preconditions, expected effects and available objects. Fast Downward generates an action sequence, which the independent validator VAL checks for action parameters, preconditions and the final goal. Only validated plans are compiled into task graphs, explicitly identifying which conditions later actions depend on and which actions provide those conditions.

2. Online verification: continuously check actions and supporting conditions

During execution, LOGIV connects observations to the task graph through State Gate, Node Gate and Graph Gate. State Gate combines visual observations, robot state and executor feedback to establish current task facts. Node Gate checks preconditions before actions and expected effects afterward. Graph Gate further checks dependencies to determine whether completed actions still provide valid support for the remaining plan. Together, they verify before and after execution, both judging current-operation success and detecting condition changes that affect later tasks.

For example, even if the robot successfully grasps the beam, Graph Gate identifies that the conditions needed for later installation have failed when previously placed support blocks shift, and triggers repair rather than continuing solely on the current action's success record. When visual evidence is insufficient to confirm a state, the system gathers information through re-observation or viewpoint adjustment. If the state cannot be resolved within the observation budget, execution stops, avoiding treating an uncertain state as a satisfied condition.

3. Local repair: restore necessary conditions and preserve valid plans

Once failure is confirmed, LOGIV traces affected dependencies through the task graph and distinguishes affected actions from those that genuinely need replacement, preserving as much of the usable unfinished plan as possible. In bridge building, a shifted support block does not mean the later beam-installation step itself is wrong. The system can therefore retain those operations, reason backward from the final goal through retained actions in reverse order to derive conditions required before execution can resume, then generate a repair segment from the current state.

After generating a repair segment, LOGIV merges it with the retained plan and uses VAL to check whether the complete continuation reaches the final goal under the symbolic model, rather than merely confirming restoration of the immediate failed condition. If validation fails, it replans within the current scope based on the failure location or expands the range of actions to replace. Only after validation passes does it rebuild the task graph and resume, connecting the handling of local problems with progress on the complete task.

Experimental results: multiple underlying policies benefit

The researchers selected 10 dual-arm tasks each from RoboTwin V2 and BiCoord, for 20 tasks in total. Each task used 10 predefined initial states and was evaluated separately without manually injected disturbances and with predefined disturbances.

Article illustration

Figure 3: results for different underlying policies and online-correction methods. C is the complete-task success rate without manually injected disturbances; P is the complete-task success rate under predefined disturbances; R is the rate of restoring failed conditions among valid recoverable events. All values are percentages. Source: Table I of the paper.

1. Benefits with and without disturbances: success rates improve by up to 28 percentage points

As the C columns in Figure 3 show, without manually injected disturbances, adding LOGIV improved complete-task success rates for all three underlying policies on both benchmarks. Average success across the three models rose from 71.67% to 82.33% on RoboTwin V2 and from 42.33% to 57.67% on BiCoord. Calculated from unrounded means, these are gains of 10.67 and 15.33 percentage points, respectively. This shows that LOGIV is not limited to external interference: graph verification and online repair can also handle state deviations and action errors during normal execution, improving complete-task completion rates.

When the environment does deviate from the plan, can LOGIV help the robot finish? The researchers fixed disturbance types and trigger conditions for each task, injecting recoverable disturbances when predefined events occurred. Results appear in Figure 3's P columns: π0.5's RoboTwin V2 success rate rose from 32% to 60%, a gain of 28 percentage points. Compared with three adapted recovery baselines—VeriGraph-PDDL, LERa-PDDL and VLM-RP-BT—LOGIV achieved higher disturbed-task completion and failed-condition recovery rates in every combination of the two benchmarks and three underlying policies. The R columns measure the proportion of valid recoverable events in which failed conditions were restored within budget. R is calculated separately from P's complete-task success rate, testing recovery at two levels: repairing local conditions and completing the final goal.

2. Graph checks and local repair each contribute

Do these gains merely come from running more checks, or does the graph structure genuinely help? The researchers further dissected key components. Under the RoboTwin V2 π0.5 setup, removing Graph Gate reduced disturbed-task success from 60% to 48%. This shows that focusing only on the immediate action misses dependency failures affecting later execution. Replacing local repair with replanning of all remaining actions increased the mean number of re-executions of valid completed actions from 0.2 to 1.6, while disturbed-task success fell to 54%.

Repeating more work does not necessarily mean completing the task better. These results support LOGIV's design choice: first determine what subsequent tasks depend on, then decide where to repair.

Article illustration

Figure 4: ablations of graph-dependency checks, local repair and plan validation. Full is the complete framework; -Graph removes graph checks; -Local replans all remaining actions instead. Source: Fig. 5 of the paper.

Toward real robots: physically testing the execution loop

The researchers also tested tomato grasping, dual-arm block building and Ethernet-cable insertion on the Astribot S1 dual-arm robot and a platform comprising two AgileX Piper arms. This demonstrates that LOGIV works not only in simulation but can also show relatively good results in physical-world scenarios.

First, watch a real demonstration of dual-arm block building.

Article illustration

Video: Astribot S1 dual-arm block building.

Block building shares the difficulty of the earlier bridge example. A later reaching action may knock placed blocks out of position, invalidating support conditions needed next. Detecting such changes, LOGIV repairs the relevant conditions while retaining work that remains valid.

Article illustration

Figure 5: comparison of successful real-robot trials. Each task and configuration had 10 trials, totaling 30 trials per configuration, without manually injected disturbances. Data: Table II of the paper.

Overall success rose from 40.0% to 56.7%, with improvements observed in all three tasks. From empty grasps and premature release to destroyed block-support conditions, deviations in real execution also provided test scenarios for graph verification and repair.

Conclusion: what kind of execution system do robots need?

As VLA and WAM action capabilities keep improving, agentic-robot research faces an unavoidable question requiring an answer: how can these capabilities form a complete task that keeps progressing in a changing environment? LOGIV moves Graph Engineering from task representation to online execution. Its task graph records the conditions each step requires and checks whether they still hold during execution. When a problem appears, it identifies what needs repair, retains usable plans and continues after fixing it. This reduces unnecessary repetition and helps robots complete long tasks more reliably using existing action models.

Robots need models that perform actions better, and systems that can keep working through change to finish the job. LOGIV is turning the latter question into graph engineering that can be constructed, verified and evaluated.

This article comes from "Synced." Author: "Synced."

Related topics

After reading

Join the AINRK community

Read how to join the community and connect with people working in AI.

Community information (opens in a new tab)