PaperlayerView exact revision on arXiv

Source-linked AI summary

GaP: A Graph-as-Policy Multi-Agent Self-Learning Harness For Variational Automation Tasks

Kaiyuan Chen, Shuangyu Xie, Letian Fu, Justin Yu, William Pacini, Sandeep Bajamahal, Hudson Kim, Jaimyn Drake, Daehwa Kim, Haoru Xue, Jonathan Francis, Christian Juette, Peter Schaldenbrand, Muhammet Yunus Seker, Ruwan Wickramarachchi, Uksang Yoo, Guanzhi Wang, Adithyavairavan Murali, Balakumar Sundaralingam, S. Shankar Sastry, Spencer Huang, Yuke Zhu, Linxi "Jim" Fan, Ken Goldberg

arXiv:2607.05369v1cs.ROcs.AIcs.CLcs.LG

TL;DR

Variational Automation tasks require reliable robot behavior under greater object and pose variation than fixed automation, while existing coding and model-free approaches remain limited. GaP generates and rehearses modular robot computation graphs with multiple agents, achieving significantly higher success rates than baselines across eight benchmarks, including 100% success on 25/25 real-world grocery-order trials.

  • Problem

    Variational Automation tasks require reliable robot behavior under greater object and pose variation than fixed automation, while generalist robots and unstructured coding agents remain limited.

  • Method

    GaP uses hierarchical multi-agent coding to generate modular directed computation graphs of perception, planning, and control skills, then rehearses and optimizes them in simulation.

  • Results

    Across eight open VA benchmarks, GaP achieves high success rates that significantly outperform baselines, including 100% success on 25/25 real-world grocery-order trials.

  • Takeaways & Limitations

    Graph-structured agentic robotics supports modularity, multi-agent integration, and self-learning as robot applications and skill libraries become more complex.

  • Takeaways & Limitations

    GaP has not yet reached industry-level reliability or execution speed, and its benchmarks largely cover quasi-static pick-and-place tasks rather than deformable, dynamic, or moving-target scenarios.

Abstract

from arXiv · show

For robots to work reliably in commercial and industrial applications, can recent advances in agentic coding systems combine interpretable robot programming with the open-world adaptability of model-free policies? We focus on "Variational Automation" (VA), a class of tasks that have larger variations in object geometry and pose than fixed automation. Model-free policies often struggle to close the reliability gap for VA tasks, which must be executed persistently and reliably in commercial and industrial applications. Motivated by prior work on Task and Motion Planning (TAMP) and the Robot Operating System (ROS), we introduce Graph-as-Policy (GaP), a multi-agent coding harness that generates directed computation graphs with perception, planning, and control nodes from a Modular Open Robot Skill Library (MORSL). GaP then generates an internal simulation environment to rehearse task instances with different graphs in parallel to iteratively refine the graph structure and parameters to improve success rates and throughput. Evaluation with 8 new open VA task benchmarks, 4 in-simulation and 4 in real-world, suggests that GaP can achieve success rates that significantly outperform baselines. Details, code, and data can be found online: https://graph-robots.github.io/gap

1 Introduction

The paper defines Variational Automation (VA) as persistent task execution under substantial object-geometry and pose variation, where reliable setup and tuning require more human effort than fixed automation. It introduces Graph-as-Policy (GaP), a hierarchical multi-agent harness that generates modular robot computation graphs and autonomously rehearses and optimizes them, evaluated on 8 open VA benchmarks.

  • Motivation: Variational Automation tasks require persistent execution across instances with non-trivial object-geometry and pose variation, unlike fixed automation’s repeated motions.Examples include sorting packages, making café coffee, and building sandwiches in a commercial kitchen.
  • Motivation: VA tasks demand more human setup and tuning effort for reliable performance than fixed automation, despite fixed automation’s high reliability and throughput.Fixed automation effort can be amortized over years of repetitive performance, whereas VA variation increases the tuning burden.
  • Graph-as-Policy: GaP addresses unstructured, hallucination-prone single-agent coding by decomposing robot policies into modular graph nodes managed by specialized agents.Separating graph generation from graph testing also reduces individual agents’ incentives to cheat.
  • Graph-as-Policy: GaP builds executable computation graphs from atomic robot skills, drawing on Task and Motion Planning and Robot Operating System graph structures for modularity, reuse, and composability.Example skill nodes include retrieving camera frames and running inference on a perception input.
  • Self-learning harness: GaP uses an Orchestration Agent and Skill Agents to decompose VA specifications into subgraphs, wire them together, and coordinate autonomous simulation, evaluation, and optimization.The broader system includes an evolving Modular Open Robot Skill Library with 51 initial skills.
  • Evaluation: 8 new open VA benchmarks evaluate GaP across simulated and real settings, including grocery fulfillment, grocery packing, popcorn making, USB-C insertion, and crate washing.The benchmark suite covers six kitchen-item tasks using a Franka arm plus two datacenter or industrial tasks.

2 Related Work

The paper situates Variational Automation (VA) between Fixed Automation’s minimal variation and Generalist Robotics’ broad task and environment diversity. It connects GaP to modular robot control, code-generating LLM agents, and self-improving workflows while emphasizing graph structure for persistent VA tasks.

  • Variational Automation: Generalist Robotics performs diverse tasks across highly variable environments, whereas VA focuses on persistent execution of one task under structured object and pose variation.The paper focuses on VA because most robot-learning research targets Generalist Robotics, while robot learning may not be required for Fixed Automation.
  • Variational Automation: VA persistently executes varying instances of a task, with variable object geometry, initial poses, and arrangements, unlike Fixed Automation’s nearly identical instances.Fixed Automation uses objects of identical geometry and minimal environmental, shape, and pose variation.
  • Modular Robot Control Methods: Classical modular systems decompose robotics into sensing, planning, and execution, while ROS uses directed graphs and TAMP combines discrete task planning with continuous motion planning.These approaches provide explicit structure for routing data, managing dependencies, and supporting reliable execution.
  • Modular Robot Control Methods: Code-as-Policy uses agents to generate robot-control code, with extensions including CaP-X, GRAPPA, Maestro, and TiPToP integrating newer LLMs or TAMP.These systems offer alternatives to manually coded model-based methods and purely end-to-end model-free policies.
  • Modular Robot Control Methods: GaP tempers Code-as-Policy flexibility with graph structure, combining pretrained LLM coding agents’ open-world adaptivity with structured, interpretable computation graphs for persistent VA.The cited related systems include ALGARA and CodeDiffuser for open-vocabulary robot-code generation.
  • Self-Improving Agentic Workflows For Robotic Control: Prior self-improving workflows refine generated solutions through execution feedback, while GaP uses multiple LLM agents and simulation experiments to iteratively improve robot computation graphs.CaP-X uses visual differencing, but its VLM feedback can hallucinate and cannot handle geometric or numerical motion-feasibility information.

3 Problem Formulation

The problem formulation defines Variational Automation tasks over known, bounded workcells and object/pose distributions, then casts policy synthesis as finding a directed execution graph that generalizes across the belief space. GaP executes this graph from real-time multi-view observations as a closed-loop robot policy.

  • Assumptions: VA assumes a fixed, known workcell, robot, and sensor configuration, with known ranges of possible objects and initial poses.These assumptions define a bounded operating envelope rather than oracle information, allowing object models and calibrated sensor information.
  • Variational Automation Task Class: A VA task is formalized as T = ⟨L, E, R, O, X, B, J⟩, covering language, environment, robot configuration, objects, poses, belief space, and objectives.The tuple provides the formal structure for describing task behavior, workspace constraints, robot and sensor setup, and task variation.
  • Policy Representation via Directed Execution Graphs: GaP represents the policy π(a | x, T) as a directed computation graph G = (V, E) whose modular nodes encode manipulation, perception, or execution primitives.Edges specify both data flow and execution logic, while nodes are modular atomic functional units.
  • Problem Definition: GaP must synthesize a robust graph G∗ that generalizes across the entire belief space B for every task instance in T.For each instance, the graph executor invokes skill nodes and follows graph data and control edges.
  • Problem Definition: Real-time multi-view observations induce a closed-loop robot policy πG(a | I) through graph execution.The observation I comprises image sets from static and wrist cameras.

4 Graph-as-Policy

GaP converts natural-language automation objectives into MORSL-based computation graphs and self-learns their topology and parameters through parallel simulation rehearsals before physical deployment. Its rehearsal loop samples task variations, analyzes execution failures, and updates the graph iteratively.

  • Graph synthesis: GaP partitions a natural-language objective into semantic segments and maps them to MORSL atomic skills to synthesize an initial computation graph.The Make Popcorn example includes segments such as turning a knob and picking up a popcorn pan.
  • Deployment: After self-learning, GaP sends the optimized computation graph to an external interpreter for repeated execution on the physical robot.Simulation-based refinement occurs before deployment.
  • Graph synthesis: MORSL skills declare inputs, outputs, semantic parameters, and pre-conditions, enabling agents to decide when to invoke skills and how to wire them into graphs.The initial library contains 51 skills spanning perception and grasp planning, among other capabilities.
  • Rehearsal-based graph optimization: GaP uses Isaac simulation to render perception inputs, simulate physics, compute contacts, and compare robot-object states before and after rehearsal nodes for feedback.These state differences help infer motion outcomes during iterative graph improvement.
  • Rehearsal-based graph optimization: The optimization algorithm samples N task instances from belief space B, performs parallel rollouts, analyzes failures, and applies an LLM-driven graph update across M iterations.The belief space represents distributions over object poses, initial states, and workspace kinematic configurations.

5 Experiments

GaP is evaluated on eight variational-automation benchmarks spanning simulation and real-world tasks with positional, geometric, and long-horizon variation. Across these evaluations, GaP improves robustness through structured graph generation, self-learning, ROS integration, and coordinated multi-arm execution.

  • Benchmark suite: The evaluation introduces 8 VA benchmarks, comprising 4 simulation and 4 real-world tasks, including grocery fulfillment, grocery packing, popcorn making, cable insertion, and crate washing.Six benchmarks are inspired by LIBERO, while task variations include object swaps, permutations, continuous X-Y pose variation, and mixed conditions.
  • Positional robustness: 0.20 is the lowest success rate reported for baseline VLA models on LIBERO-PRO with positional variance, whereas GaP maintains robust success across variations.π0.5 and MolmoAct2 perform well on LIBERO-object without pose variation but degrade under positional perturbations.
  • Sim-to-real transfer: 100% (25/25) is GaP’s real-world success rate for Fulfill Grocery Orders, compared with TipTop’s 8/25 trials.TipTop fails to find feasible motion plans for cubic objects, tall baskets, and varied object orientations, while GaP identifies objects and baskets accurately.
  • Ablations: 0.93–0.99 is the full GaP success-rate range for Fulfilling Grocery Orders and Packing Grocery Items, while graphless generation and single-agent authoring each reduce success rates to zero.The graphless variant fails through syntax or interface mismatches, and the single-agent variant fails static structural verification before execution.
  • Self-learning: 94% in simulation and 90% (18/20) in real trials are achieved after self-learning improves the popcorn policy from an initial 33% success rate.Self-learning replaces the original grasp skill after simulator-detected pan-grasp failures and adds an oriented-bounding-box grasp planner.
  • ROS and coordinated execution: 0.93 (121/130) is GaP’s success rate across cable-insertion trials, while its coordinated crate-washing policy achieves 0.953 (143/150) versus 0.987 (148/150) for a hand-engineered graph.For crate washing, average cycle times are 179.13 s for GaP and 176.47 s for the hand-engineered graph.

6 Conclusion · Appendix · A More Related Work

GaP positions graph-structured agentic robotics as a bridge between engineering and model-free VLA policies, while acknowledging that reliability, throughput, and task coverage remain below industry needs. The related-work appendix situates this direction against Generalist Robotics and self-improving LLM workflows.

  • 6 Conclusion: GaP’s graph-structured agentic robotics bridges Good Old Fashioned Engineering and model-free VLA policies.The approach supports modularity, multi-agent integration, and self-learning.
  • 6 Conclusion: Ablation experiments show that GaP facilitates modularity, multi-agent integration, and self-learning.
  • 6 Conclusion: More sophisticated agent harnessing will be required as robot applications become more complex and skill libraries grow.
  • 6 Conclusion: GaP’s execution reliability is not yet at industry levels despite significantly improving success rates over baselines.Additional self-learning and parameter tuning are required.
  • 6 Conclusion: 500 units per hour (7 seconds per instance) remains an industry standard that GaP’s execution times are still well below.Reducing VLM inference requests and IK motion planning time is identified as necessary.
  • A More Related Work: Generalist Robotics involves varied tasks across homes with considerable environmental variation and objects having variable geometry and highly variable initial poses.This contrasts with Factory Automation, where environmental and object variation is minimal.
  • A More Related Work: Outside robotics, LLMs support dynamic coding, complex software integration, and API orchestration within self-improving agentic workflows.Structured agentic workflows can autonomously synthesize solutions for open-ended tasks, with Voyager iteratively writing, refining, and executing Minecraft skills.

B Integrating ROS with GaP in Cable Insertion Benchmark

GaP integrates ROS skills through an intermediate interface that executes sequential robot nodes and reports execution status. In the cable insertion benchmark, it generated compatible graphs for varied insertion prompts, achieving a 0.93 success rate across 130 trials while supporting long-horizon subgraphs.

  • ROS integration: GaP exposed four ROS nodes—align to port, touch port, insert, and extract—through an intermediate skill interface that triggers them sequentially.The interface creates a temporary orchestrator node to communicate with each target ROS node and waits for success, failure, or data signals.
  • Benchmark results: 0.93 success rate (121/130) was achieved across 130 cable-insertion trials spanning five individual, ordered, and index-based port prompts.The prompts covered individual ports 1, 2, 4, 5, and 7; ascending and descending orders; and odd- or even-indexed ports.
  • Graph generation: GaP connected atomic ROS skills into insertion graphs and generated subgraphs for extended long-horizon tasks.Figure B.1 shows GaP using the atomic skills in a compatible graph and in a subgraph for inserting the cable into even-numbered ports.
  • Failure modes: The insertion policy failed when vision-based candidates lay outside the contact-search zone, depth estimates caused partial insertion, or lighting conditions varied.The contact-based fallback searched a 1 × 1 cm2 area in 2 mm steps after an initial vision failure.

C Sample Generated Graphs … C.4 Wash Crates

The appendix presents generated computation-graph examples for grocery fulfillment, grocery packing, VLA-policy execution, and crate washing. These graphs expose service-call success/failure routes and concrete perception, motion, release, policy, navigation, alignment, and respawn operations.

  • C Sample Generated Graphs: Generated graphs include service-call scripts with explicit success and failure routes across the showcased tasks.The repeated graph structure exposes separate success and failure routing.
  • C.1 Fulfill Grocery Orders: C.1 Fulfill Grocery Orders uses DINO-VLM perception followed by object-bound computation, approach-above motion, waypoint movement, and descend-release placement.The graph includes perceive_dino_vlm, FilterAndComputeOB, approach_above, waypoint_move, and descend_release operations.
  • C.2 Pack Grocery Items: The packing graph ends with a descend-release operation that places the item.The result node is labeled release (descend_release) placed.
  • C.3 Fulfill Grocery Orders with VLA Policy: C.3 Fulfill Grocery Orders with VLA Policy uses an approach-above-tar step before a run_policy node that succeeds.The generated graph explicitly connects approach_above_tar to run_policy.
  • C.4 Wash Crates: C.4 Wash Crates includes a GoToPoseBoth operation that reaches an intermediate pose and another that achieves alignment.The result nodes are labeled go_mid and go_aligned.
  • C.4 Wash Crates: The crate-washing graph also contains a RespawnTopCrate implementation node.This node is labeled respawn_top_crate (RespawnTopCrate).

C.5 Make Popcorn … bimanual crate lift

The merged sections show popcorn execution through perception, motion, placement, and service-call routing, while MORSL provides typed composable skills for diverse grasping, transport, tracking, and bimanual manipulation. Its library spans single- and multi-detector perception, hierarchical subpart localization, collision-aware and specialized grasping, container placement, and a phased two-arm crate lift.

  • C.5 Make Popcorn: Make Popcorn executes perception, alignment, rotation, waypoint motion, lifting, release, synthesis, and success/failure routing through named graph subroutines.The listed execution elements include perceive_gemini_er, cart_align, rotate_90, move_above, lift_and_align, release, synthesize_on_stov, and service-call success/failure routes.
  • D MORSL Library: MORSL defines skills with shared metadata and typed inputs and outputs, supporting composite subgraphs, atomic classes, and primitive gRPC methods.The common type system includes Se3Pose, OrientedBoundingBox, PointCloud, and Mask.
  • perception multi: Multi-detector perception runs three detectors on one observation and uses a VLM disambiguator to choose the best mask when detectors disagree.It is described as the most robust but slower single-shot perception option.
  • perception subpart: Hierarchical subpart perception detects a parent, crops to its box, segments the named subpart, then uncrops and fuses depth for small affordances.Examples include a pan handle, drawer pull, or mug rim.
  • track object: Object tracking seeds from a text prompt on the first frame, polls the observation stream, advances until termination, and frees tracker state on exit.The output is a stream of tracked-mask snapshots.
  • grasp curobo obb; grasp moe; grasp short axis; grasp direct ik: MORSL offers collision-aware OBB grasp planning, mixture-of-experts grasping for non-centroid targets, geometry-locked short-axis grasping, and planner-free direct-IK grasping.The methods cover top-down collision-free candidates, diffusion-plus-OBB-sweep proposals, narrow-dimension jaw closure, and pre-rotate/descend/close execution.
  • transport to drop: Transport-to-drop moves a held object above a destination container and releases it, optionally localizing a natural-language sub-region with a VLM before computing the drop pose.Its inputs include container and target geometry, masks, and the end-effector pose at grasp.
  • bimanual crate lift: The bimanual crate-lift skill side-grasps handle bars with both arms and raises the crate in lock-step through open, approach, insert, close, lift, and settle phases.The skill uses baked waypoints and returns completion plus final left and right world positions.

D.2 Primitive skills (one per gRPC method) … geometry svc.BuildWorldConfig

The primitive-skill library exposes gRPC methods spanning open-vocabulary perception, segmentation and tracking, visual querying, grasp generation, motion planning, geometric reasoning, and collision-world reconstruction. These methods convert image, point-cloud, pose, and planning inputs into detections, masks, grasps, trajectories, geometric primitives, and WorldConfig outputs.

  • D.2 Primitive skills (one per gRPC method): Perception primitives detect queried objects, segment by text, point, or box, and track prompted objects across frames.OWL-ViT returns bounding boxes, labels, and scores; SAM variants return masks, scores, and boxes or tracker state.
  • sam3 tracker.InitTracker: Tracker initialization accepts text, box, or point prompts, while updates advance the session and return masks, boxes, confidence, and object presence.The tracker is stateful and seeded with one frame; each update consumes a new image.
  • molmo.Query: Visual-query skills return object pixels, free-form text, or boolean answers using Molmo or configurable VLM backends.Molmo.PointPrompt identifies pixel coordinates for a named object; Query and QueryYesNo support optional images and multiview use where specified.
  • graspgen.PlanFromPointCloud: Grasp primitives generate or score 6-DoF poses from segmented clouds, depth images, or scene clouds using GraspGen, Contact-GraspNet, and M2T2.Outputs include grasp poses, scores, and contact points; GraspGen.ScoreGrasps aligns scores with caller-provided candidates.
  • curobo.PlanToGraspPoses: Motion skills plan collision-free trajectories to grasp poses or grasped-object targets, solve geometric IK, plan single-pose or linear Cartesian motion, and validate collisions.Validation supports both the robot alone and a grasped object, returning success, failure information, and collision details.
  • curobo.ValidateJointTrajectoryGrasped: Collision validation and trajectory-generation methods expose success and trajectory outputs, with pyroki.PlanLinear using 20 waypoints and dt 0.02.The linear planner is CPU-based and interpolates between two poses; grasped-object validation attaches the object at the first waypoint.
  • geometry svc.FilterAndComputeOBB: Geometry skills derive oriented bounding boxes, top-down or front grasp candidates, and selected grasp poses from point-cloud geometry.FrontGraspFromOBB additionally returns pre-grasp pose, approach direction, and slide axis for handle manipulation.
  • geometry svc.BuildWorldConfig: Back-projection methods convert depth, masks, or pixels into camera- or world-frame points, while BuildWorldConfig reconstructs a named collision-mesh world for planners.BuildWorldConfig accepts camera observations, object masks, reconstruction parameters, optional robot state and target OBB, and returns WorldConfig plus mesh names.

geometry svc.ComputeDropPosition

geometry svc.ComputeDropPosition computes a drop point above a container while accounting for clearance and object height.

  • geometry svc.ComputeDropPosition: ComputeDropPosition determines a drop position above a container.It accounts for clearance and object height.
  • geometry svc.ComputeDropPosition: The service accepts a container obb represented as an OrientedBoundingBox.The container geometry is provided through the container obb input.
  • geometry svc.ComputeDropPosition: The service uses a clearance value of 0.05 and the object z extent, returning a Vec3 drop point.The output is the computed drop point.

geometry svc.ComputeXYDistance … E.1 Pseudo-code

The paper specifies geometry, robot-control, observation, simulation, and video services, then gives rehearsal-based graph optimization pseudo-code that samples task instances, rehearses graphs in parallel, analyzes failures, and updates the graph.

  • geometry svc.ComputeXYDistance: ComputeXYDistance returns the XY-plane Euclidean distance between two Vec3 points.
  • geometry svc.RotateQuatZ90: RotateQuatZ90 rotates a WXYZ quaternion 90◦ about Z for grasp candidates.
  • robot control: Robot-control services support smooth Cartesian pose interpolation, planned joint trajectories, direct joint configurations, and synchronized dual-arm pose or joint motion.The listed controls include Cartesian linear and angular velocity norms, trajectory subsampling and tolerance, joint tolerances and maximum steps, and dual-arm approach and offset inputs.
  • robot control.ApplyPolicyAction / observation.GetObservation: ApplyPolicyAction sends a low-level VLA rollout action, while GetObservation returns RGB-D camera data with calibration and all arm states.The policy action may be a 7-dimensional delta pose and gripper vector, with arm id 0.
  • sim bridge: Simulation services initialize named environments, step MuJoCo once, move blocking to joint targets, and report reward, termination, and task completion.CheckTaskCompletion exposes sub-goal completion rate, while initialization accepts configuration, camera, task, and suite identifiers.
  • sim bridge.SaveVideo: SaveVideo encodes captured frames as an MP4 and returns success, the file path, and frame count, using a default frame rate of 20.
  • E Self-Learning / E.1 Pseudo-code: The rehearsal-based graph optimizer takes a task specification, iteration count M, and parallel rollout count N, and outputs an optimized task graph G∗.It initializes G0 from language and builds a simulation scene before optimization.
  • E.1 Pseudo-code: Each iteration samples N scene instances, rehearses the preceding graph in parallel, analyzes rollout failures, and uses an LLM to update the graph.

E.2 Sample Feedback · F Sample LLM Prompts and Outputs

Sample rehearsal feedback exposes perception, grasp, and placement failures with concrete success metrics and directs graph updates. The accompanying prompts and outputs specify how LLM agents construct validated top-level workflow graphs from MORSL skills.

  • E.2 Sample Feedback: The feedback compares simulated object states and contacts before and after each phase so the LLM can infer graph failures.For example, missing overlap and contact between the pan and stove oriented bounding boxes signals failure.
  • E.2 Sample Feedback: Perception succeeds in all 30 sampled environments, while grasp instability and incorrect pan placement cause downstream failures.The placement node releases the pan away from the burner footprint, producing zero burner coverage.
  • E.2 Sample Feedback: 0.00 terminal coverage is recorded for Iteration 1.The reported stage rates are perceive pan 1.00 (30/30), perceive burner 1.00 (30/30), grasp pan 0.83 (25/30), and place pan 0.57 (17/30).
  • E.2 Sample Feedback: Placement fails because the released pan’s projected bottom footprint does not sufficiently overlap the burner footprint.The feedback recommends revising the placement target and release pose while improving grasp robustness.
  • F.1 Behavior Agent Prompt: The behavior-agent prompt restricts the LLM to producing only the workflow topology, including top-level nodes, edges, conditional routing, and subgraph metadata.Internal nodes and edges are generated separately by the universal subgraph_agent.
  • F.1 Behavior Agent Prompt: The prompt requires a module-level WorkflowSpec named spec, top-level subgraph and end nodes, and conditional edges that route each exit value.The pipeline executes the Python block in a sandbox, serializes spec, and forwards it to per-subgraph generators.

G Sample Generation Outputs

The sample output constructs a subgraph with reusable graph-building primitives, wires observation through perception and filtering to a success exit, and includes output and error-path configuration.

  • Graph construction: The sample imports Subgraph, Ref, START, and END from vos.builder to construct the graph.These primitives support subgraph definition, references, and graph endpoints.
  • Success and failure handling: The graph marks found as a success exit and configures outputs and an on-error path to not_found.The snippets show sg.add_exit("found"), sg.set_outputs(...), and sg.set_on_error("not_found").
  • Graph wiring: The graph wires START through observe, perceive, filter_obb, and found before reaching END.This defines the execution path from observation to object-filtering success.
Loading 2607.05369v1…