Long-horizon embodied task planning via graph-informed action generation

Abstract

A method for long-horizon task planning in an embodied agent environment parses a current observation using a scene parser to generate a scene graph processed by a Graph Neural Network embedder to produce a current scene embedding vector. A lookahead simulator simulates execution of valid actions using a Planning Domain Definition Language-based forward dynamics model to produce action-observation pairs provided to a Large Language Model agent. An experience retriever compares the current scene embedding vector against an experience memory bank and, upon finding a match within a predefined threshold, retrieves a relevant experience comprising a goal, a textual description of a matched state, and a ground-truth action sequence. A loop detector identifies previously visited states and generates a loop warning. The Large Language Model agent processes a structured prompt comprising these components to select and execute an action, while a state-transition graph builder maintains a memory graph of state transitions.

Description

Attorney Docket No.4502-90900 (6000811PCT01)Long-Horizon Embodied Task Planning via Graph-Informed Action GenerationTECHNICAL FIELD

[0001] The present disclosure relates to artificial intelligence systems for autonomous task planning and execution, and more particularly to systems and methods for long-horizon task planning in embodied agents using graph-based memory architectures and neural network embeddings to guide action selection in complex environments.BACKGROUND

[0002] Embodied agents operating in physical or simulated environments must execute extended sequences of interdependent actions to satisfy high-level goals. Such environments are typically characterized by discrete but large action spaces, physical constraints on object manipulation, and concurrent processes whose completion may depend on the passage of simulated time.

[0003] Large language models (LLMs) have demonstrated strong zero-shot reasoning capabilities across a wide variety of tasks and have been applied to embodied planning due to their ability to interpret natural language instructions, reason about object relationships, and generate structured action sequences. Prompting techniques such as Chain-of-Thought and Tree-of-Thoughts decompose complex goals into intermediate reasoning steps, while frameworks such as ReAct integrate environmental feedback into a sequential reasoning-acting loop by interleaving linguistic reasoning traces with executable actions. Retrieval-Augmented Generation (RAG) has further extended LLM-based planners by enabling agents to query external knowledge stores at inference time rather than relying solely on parametric knowledge encoded during training.

[0004] Graph-structured knowledge representations have been shown to improve retrieval quality relative to flat text corpora by explicitly encoding relational structure among entities, including spatial relationships, hierarchical dependencies, and temporal orderings, that prose representations cannot compactly express. Graph Neural Networks (GNNs) have been developed to learn continuous, low-dimensional embeddings of graph-structured data by iteratively aggregating and transforming representations from local neighborhoods, enabling downstream tasks such as classification, similarity search, and anomaly detection over graph-structured inputs.Attorney Docket No.4502-90900 (6000811PCT01)SUMMARY

[0005] The disclosed embodiments provide a technical solution to a technical problem using graph-informed long-horizon task planning. For example, the system and method of the present disclosure address two fundamental limitations of conventional long-horizon embodied task planning: computational cost and planning coherence. By replacing accumulated interaction history with a graph-in-graph memory architecture, the system maintains approximately constant compute cost per reasoning step regardless of task length, in contrast to conventional approaches whose transformer self-attention costs grow quadratically with interaction count. The experience memory bank enables smaller, resource-efficient language model backbones to recover substantial performance by leveraging successful trajectories collected from larger models, reducing deployment cost without proportional sacrifice in planning quality. The GNN-based scene embedding architecture produces compact, structure-aware state representations that support accurate threshold-based retrieval and loop detection, as confirmed by the clear intratrace clustering and inter-trace separation demonstrated in the embedding heatmaps.

[0006] On the planning quality side, the combination of one-step lookahead simulation and loop detection enables the agent to reason proactively rather than reactively. Unlike greedy filtering methods that eliminate candidate actions based on immediate value and thereby preclude efficient parallel plans, the lookahead simulator presents complete action consequence information to the language model, enabling identification of strategies that require temporary setbacks to achieve superior long-horizon outcomes. Experimentally, the system achieves improvements of up to 19 percentage points over the strongest baseline on synchronous tasks and up to 37 percentage points on asynchronous tasks, where parallel process management is most critical, while simultaneously requiring significantly less computation for long-horizon planning than conventional history -based frameworks.

[0007] A first aspect relates to a method for long-horizon task planning in an embodied agent environment, the method comprising: parsing a current observation using a scene parser to generate a scene graph; processing the scene graph using a Graph Neural Network (GNN) embedder to generate a current scene embedding vector; simulating, by a lookahead simulator using a Planning Domain Definition Language (PDDL)-based forward dynamics model, execution of each of a plurality of valid actions to produce a set of action-observation pairs, wherein all action-observation pairs are provided to a Large Language Model (LLM) agent without greedy pre-filtering; comparing, by an experience retriever, the current scene embedding vector against scene embedding vectors stored in an experience memory bank and, when a matchAttorney Docket No.4502-90900 (6000811PCT01)within a predefined threshold T is found, retrieving a relevant experience comprising an associated goal, a textual description of a matched state, and a ground-truth action sequence from the matched state to successful goal completion; comparing, by a loop detector, the current scene embedding vector against a session memory and generating a loop warning identifying a detected loop when a current state has been previously visited; processing, by the LLM agent, a structured prompt comprising the current observation, the valid actions, the action-observation pairs, the relevant experience when retrieved, and the loop warning when generated to select an action; executing the selected action; and adding, by a state-transition graph builder, a node corresponding to the current scene embedding vector and a directed edge corresponding to the selected action to a memory graph.

[0008] Optionally, in any of the preceding aspects, another implementation of the aspect provides that the GNN embedder implements a Graph Attention Network (GAT) architecture that computes attention-weighted aggregations of neighbor node features during message passing, wherein learned attention weights determine a relative importance of each neighbor to each node, and wherein a global mean pooling operation followed by normalization is applied to final node embeddings produced by the GAT architecture to produce the current scene embedding vector as a fixed-dimensional representation that is invariant to a number of nodes in the scene graph.

[0009] Optionally, in any of the preceding aspects, another implementation of the aspect provides that the GNN embedder is trained using a composite loss function comprising a triplet loss term and a uniformity loss term, wherein the triplet loss term encourages embeddings from a same task trajectory to be proximate and embeddings from different trajectories to be distant, and wherein the uniformity loss term acts as a regularization term that spreads embeddings across an embedding space to prevent representational collapse by minimizing a mean squared cosine similarity among all unique embedding pairs within a training batch.

[0010] Optionally, in any of the preceding aspects, another implementation of the aspect provides that training triplets are formed by sampling an anchor embedding from a first scene in a task sequence, sampling a positive embedding from a same task sequence one step later, and sampling a hard-negative embedding from a different task sequence within a training batch.

[0011] Optionally, in any of the preceding aspects, another implementation of the aspect provides that the experience memory bank is implemented using a library index to enable efficient similarity search over stored scene embedding vectors, and wherein the experience memory bank is populated with successful experiences collected from a first LLM backbone of greater capability for use in guiding a second LLM backbone of lesser capability.Attorney Docket No.4502-90900 (6000811PCT01)

[0012] Optionally, in any of the preceding aspects, another implementation of the aspect provides that each historical successful task execution experience stored in the experience memory bank comprises a goal and a sequence of state-action-description transitions, each transition comprising a scene embedding vector, a textual description of a state, and an action taken at a respective step.

[0013] Optionally, in any of the preceding aspects, another implementation of the aspect provides that retrieving the relevant experience comprises retrieving the associated goal, the textual description of the matched state, and the ground-truth action sequence from the matched state to successful goal completion, and wherein the relevant experience is prepended to the structured prompt as a one-shot example of a successful trajectory from a structurally similar state.

[0014] Optionally, in any of the preceding aspects, another implementation of the aspect provides that simulating execution of each valid action is limited to a one-step lookahead depth of d = 1 without recursive multi-step rollout, a computational cost of which grows as O(e) per timestep in contrast to multi-step lookahead at depth d > 1, which grows exponentially as O(eAd).

[0015] Optionally, in any of the preceding aspects, another implementation of the aspect provides that the structured prompt does not include an accumulated interaction history from prior timesteps, such that a compute cost per interaction remains approximately constant with respect to growing interaction count because only a reasoning output from an immediately preceding interaction is retained in the structured prompt, in contrast to history-based approaches whose compute cost grows with each additional interaction due to an accumulating history length.

[0016] Optionally, in any of the preceding aspects, another implementation of the aspect provides that the structured prompt instructs the LLM agent to generate a response comprising: a Reasoning field containing step-by-step analysis including goal identification, required stack order determination, flexible ingredient preparation strategy, workspace availability checking, robot holding state identification, and a complete action plan; an Action field specifying the selected action using exact wording from the valid actions; a Summary field providing a concise environment description and proposed action in fewer than 150 words; and a Current Progress field representing completed sub-tasks or a current assembly configuration.

[0017] Optionally, in any of the preceding aspects, another implementation of the aspect provides that the loop warning identifies a specific action sequence forming the detected loop and is incorporated into the structured prompt to enable the LLM agent to recognize and avoid repetitive unproductive action cycles.Attorney Docket No.4502-90900 (6000811PCT01)

[0018] Optionally, in any of the preceding aspects, another implementation of the aspect provides, upon successful task completion, adding the memory graph to the experience memory bank as a new historical successful task execution experience, enabling future retrieval by the experience retriever for subsequent task executions.

[0019] Optionally, in any of the preceding aspects, another implementation of the aspect provides that the session memory is constituted by nodes of the memory graph, such that each node added to the memory graph by the state-transition graph builder is simultaneously registered in the session memory for subsequent loop detection comparisons by the loop detector.

[0020] Optionally, in any of the preceding aspects, another implementation of the aspect provides that when no distance between the current scene embedding vector and any stored scene embedding vector is within the predefined threshold T, the structured prompt is processed by the LLM agent without a retrieved relevant experience, using only the current observation, the valid actions, the action-observation pairs, and the loop warning when generated.

[0021] Optionally, in any of the preceding aspects, another implementation of the aspect provides that the structured prompt further comprises an Error Feedback field when a previous action was syntactically incorrect or did not exist in the valid actions, wherein the Error Feedback field does not check semantic correctness, should neither reinforce nor discourage a current strategy, and requires the Current Progress field to revert to a state prior to the previous action.

[0022] Optionally, in any of the preceding aspects, another implementation of the aspect provides that the structured prompt specifies that a player can hold only a single item at a time, that an item must be placed on a station to perform an action on the item, that a station must contain a single item to perform an action on the item, that items can only be stacked on top of one another, that a container must contain a meal to have items added to the container, that a meal can be transferred between containers, and that items may take several steps to cook, fry, or boil, during which the LLM agent can leave a station and perform other tasks.

[0023] Optionally, in any of the preceding aspects, another implementation of the aspect provides that the embodied agent environment is an asynchronous task environment in which certain actions require multiple timesteps to complete, and wherein after initiating such a time-delayed action the LLM agent is enabled by the action-observation pairs to identify and execute parallel preparation actions rather than waiting idly.

[0024] Optionally, in any of the preceding aspects, another implementation of the aspect provides that the GNN embedder is trained such that scene embedding vectors from within a same task sequence exhibit smaller pairwise Euclidean distances than scene embedding vectors from different task sequences to produce a clear block-diagonal separation structure in pairwiseAttorney Docket No.4502-90900 (6000811PCT01)distance heatmaps and distinct intra-trace and inter-trace distance distributions and to support accurate threshold-based retrieval by the experience retriever and threshold-based loop detection by the loop detector.

[0025] Optionally, in any of the preceding aspects, another implementation of the aspect provides that the experience memory bank is populated with successful experiences collected from a first LLM backbone of greater capabihty for use in guiding a second LLM backbone of lesser capability on synchronous benchmark tasks.

[0026] Optionally, in any of the preceding aspects, another implementation of the aspect provides that the method achieves superior performance on synchronous tasks and asynchronous tasks compared to ReAct and ReCAP baselines across multiple LLM backbone models.

[0027] A second aspect relates to a computing device, comprising: a memory storing instructions; and one or more processors coupled to the memory, the one or more processors configured to execute the instructions to cause the computing device to implement the method in any of the disclosed aspects.

[0028] A third aspect relates to a non-transitory computer readable medium comprising a computer program product for use by a computing device, the computer program product comprising computer executable instructions stored on the non-transitory computer readable medium that, when executed by one or more processors, cause the ingress network node to execute the method in any of the disclosed aspects.

[0029] A fourth aspect relates to a computing device, comprising: means for parsing a current observation using a scene parser to generate a scene graph; processing the scene graph using a Graph Neural Network (GNN) embedder to generate a current scene embedding vector; means for simulating, by a lookahead simulator using a Planning Domain Definition Language (PDDL)-based forward dynamics model, execution of each of a plurality of valid actions to produce a set of action-observation pairs, wherein all action-observation pairs are provided to a Large Language Model (LLM) agent without greedy pre-filtering; means for comparing, by an experience retriever, the current scene embedding vector against scene embedding vectors stored in an experience memory bank and, when a match within a predefined threshold T is found, retrieving a relevant experience comprising an associated goal, a textual description of a matched state, and a ground-truth action sequence from the matched state to successful goal completion; means for comparing, by a loop detector, the current scene embedding vector against a session memory and generating a loop warning identifying a detected loop when a current state has been previously visited; means for processing, by the LLM agent, a structured prompt comprising the current observation, the valid actions, the action-observation pairs, the relevant experience whenAttorney Docket No.4502-90900 (6000811PCT01)retrieved, and the loop warning when generated, to select an action; means for executing the selected action; and means for adding, by a state-transition graph builder, a node corresponding to the current scene embedding vector and a directed edge corresponding to the selected action to a memory graph.

[0030] For the purpose of clarity, any one of the foregoing embodiments may be combined with any one or more of the other foregoing embodiments to create a new embodiment within the scope of the present disclosure.

[0031] These and other features will be more clearly understood from the following detailed description taken in conjunction with the accompanying drawings and claims.BRIEF DESCRIPTION OF THE DRAWINGS

[0032] For a more complete understanding of this disclosure, reference is now made to the following brief description, taken in connection with the accompanying drawings and detailed description, wherein like reference numerals represent like parts.

[0033] FIG. 1 is a schematic diagram illustrating an example system architecture for graph-informed long-horizon task planning according to an embodiment of the present disclosure.

[0034] FIG. 2 is a bar chart illustrating average steps required to complete Robotouille synchronous benchmark tasks for Graph-in-Graph (GiG) and baseline frameworks using Qwen3-235B-A22B-Instruct-2507-FP8, where dots indicate the horizon length of each task type.

[0035] FIG. 3 is a bar chart illustrating average steps required to complete Robotouille asynchronous benchmark tasks for GiG and baseline frameworks.

[0036] FIG. 4 is a bar chart illustrating average steps required to complete Robotouille synchronous benchmark tasks comparing GiG with and without an experience bank, along with baseline frameworks.

[0037] FIG. 5 is a line chart illustrating compute cost in floating-point operations as a function of interaction step count for GiG and baseline frameworks across a range of branching factors.

[0038] FIG. 6 is a bar chart illustrating average tokens generated per step, stratified by successful and failed tasks, across multiple language model backbone architectures.

[0039] FIG. 7 is a dual-panel line chart illustrating compute cost analysis for GiG and baseline frameworks under fixed observation token count (top) and fixed reasoning token count (bottom) with a branching factor of ten available valid actions.Attorney Docket No.4502-90900 (6000811PCT01)

[0040] FIG. 8 is a heatmap and distance distribution plot illustrating pairwise Euclidean distances between graph neural network scene embeddings from two synchronous task sequences, demonstrating intra-trace clustering and inter-trace separation.

[0041] FIG. 9 is a heatmap and distance distribution plot illustrating pairwise Euclidean distances between graph neural network scene embeddings from two asynchronous task sequences, demonstrating intra-trace clustering and inter-trace separation.

[0042] FIG. 10 is a diagram illustrating a first portion of a system prompt template provided to the language model agent for Robotouille embodied task planning, including agent role definition, input format specification, response format requirements, environment rules, and recipe knowledge.

[0043] FIG. 11 is a diagram illustrating a second portion of the system prompt template provided to the language model agent for Robotouille embodied task planning, including detailed reasoning instructions, action selection constraints, summary formatting requirements, and progress tracking specifications.

[0044] FIG. 12 is a method for long-horizon task planning in an embodied agent environment according to an embodiment of the disclosure.

[0045] FIG. 13 is a schematic diagram of a network apparatus according to an embodiment of the disclosure.DETAILED DESCRIPTION

[0046] It should be understood at the outset that although an illustrative implementation of one or more embodiments are provided below, the disclosed systems and / or methods may be implemented using any number of techniques, whether currently known or in existence. The disclosure should in no way be limited to the illustrative implementations, drawings, and techniques illustrated below, including the exemplary designs and implementations illustrated and described herein, but may be modified within the scope of the appended claims along with their full scope of equivalents.

[0047] Disclosed herein are systems and methods for long-horizon task planning for embodied agents operating in environments where action sequences may span tens to over one hundred steps, where sub-task dependencies are non-linear, and where concurrent processes introduce ordering and resource -contention constraints that serial planning strategies cannot efficiently handle.

[0048] Prior Approaches and Their Limitations

[0049] Prior approaches to long-horizon embodied planning have relied primarily on linear context representations that scale poorly with task horizon. Sequential frameworks such asAttorney Docket No.4502-90900 (6000811PCT01)ReAct maintain a growing history of observations and actions within a large language model (LLM)’s context window and condition each action selection on the full accumulated interaction history. As task horizon increases, this linear history induces context drift in which the model loses track of high-level goals and produces repetitive or incoherent action sequences. These frameworks rely on the LLM to imaginatively predict the consequences of candidate actions rather than grounding action selection in verified state projections, which frequently results in hallucinated transitions that violate the physical constraints of the environment. The growing context also drives progressively increasing floating point operations (FLOPs) consumption per step, since attention computation scales quadratically with sequence length, making sequential frameworks computationally infeasible for very long horizons.

[0050] Hierarchical context-tree approaches such as Recursive Context- Aware Reasoning and Planning (ReCAP) address the backtracking problem by organizing the planning history into a tree structure that supports sub-goal decomposition and failure recovery. However, treebased decomposition imposes an artificial serialization of concurrent processes through a “blocked sibling” constraint: no sibling sub-goal may be initiated until the currently active subgoal is resolved. This serialization is directly contrary to the structure of asynchronous tasks, such as culinary preparation tasks in which multiple ingredients may require simultaneous preparation and time-delayed cooking processes may run concurrently with other sub-tasks. Enforcing the blocked-sibling constraint in such environments causes the agent to wait idly for background processes to complete rather than interleaving productive work, resulting in substantially suboptimal plans. Tree -based approaches also retain the fundamental limitation of imaginative action prediction without physical grounding.

[0051] Standard Retrieval- Augmented Generation (RAG) systems retrieve isolated text chunks by vector similarity and inject the retrieved text into the LLM prompt. Because text chunks do not preserve relational structure among entities, retrieved context fails to capture the spatial and causal dependencies that govern feasibility of actions in embodied environments. Experience retrieval based on flat text similarity therefore frequently surfaces contextually misleading exemplars that share surface-level vocabulary with the current state but differ materially in structural configuration.

[0052] Greedy lookahead methods that pre-filter the action space by selecting the action with the highest immediate value function fail in long-horizon settings where the locally optimal action may foreclose globally optimal parallel strategies. By eliminating actions from consideration before linguistic reasoning is applied, greedy pre-filtering discards actions whoseAttorney Docket No. 4502-90900 (6000811PCT01)long-term value cannot be assessed from one-step reward signal alone. For example, in an asynchronous task in which a patty must be cooked on a stove, a greedy method evaluating the immediate successor states may identify “wait” as the highest-value action following initiation of the cooking process, since waiting logically continues the current sub-task. However, this choice reduces an asynchronous plan to an inefficient synchronous one. The globally optimal policy involves instead executing an action with low immediate reward, such as moving to a preparation station, that enables a more efficient parallel plan by initiating preparation of another ingredient concurrently with the ongoing cooking process.

[0053] Overview

[0054] The present disclosure overcomes these limitations through a Graph-in-Graph (GiG) memory architecture that combines a structurally grounded experience retrieval mechanism, a bounded lookahead simulator grounded in physical transition logic, a graph-based loop detection mechanism, and a session-scoped state-transition graph that enables non-blocking replanning and self-reinforcing cross-session memory accumulation.

[0055] FIG. 1 illustrates the overall system workflow of the GiG framework 100. As shown in FIG. 1, the scene parser 110 processes a current observation 102 to generate a scene graph 112 representing the current environment state. The scene graph 112 is passed through the GNN embedder 120 (a.k.a., GNN Model) to produce a current scene embedding vector 122. The current scene embedding vector 122 is provided to both the experience retriever 140 (a.k.a., experience fetcher) and the loop detector 160. The experience retriever 140 performs similarity matching against stored current scene embedding vectors 122 in the experience memory bank 130, which contains past successful experiences labeled Past Experience 1, Past Experience 2, Past Experience 3, and Past Experience n, to retrieve a relevant experience 142 when a sufficiently similar prior state is found. The loop detector 160 compares the current scene embedding vector 122 against the session memory 162 maintained in the current experience n+1 graph and generates a loop warning 164 when the current state has been previously visited during the current session. The lookahead simulator 150 simultaneously processes the valid actions 152 to produce action-observation pairs 154 representing the simulated consequences of each valid action 152. The LLM agent 170 then receives a structured prompt 172 comprising the current observation 102, the valid actions 152, the action-observation pairs 154, the relevant experience 142 when retrieved, and the loop warning 164 when generated, and produces the selected action 104. The state-transition graph builder 180 adds a node corresponding to the current scene embedding vector 122 and a directed edge corresponding to the selected action 104 to the memory graph 182 after each action selection. The selected action 104 is thenAttorney Docket No.4502-90900 (6000811PCT01)executed in the environment to produce the next current observation 102, and the cycle repeats until task completion or step budget exhaustion.

[0056] Scene Parsing and Scene Graph Construction

[0057] At each planning step t, the method receives a current observation 102 describing the state of the environment, including the identities, types, current statuses, and spatial relationships of all objects and agents present. A scene parser 110 processes the current observation 102 and generates a scene graph 112, a symbolic graph G = (V, £j in which nodes u in V represent discrete entities such as robots, tables, ingredients, cooking stations, containers, and appliances, and edges e in E represent spatial and relational properties between those entities, such as “on top of,’’ “inside,’’ “directly adjacent to,’’ or “held by.’’ Node-specific features encoding item type and preparation state, including preparation states such as cut, cooked, fried, or boiled, are encoded through a lightweight sentence embedder and stored as initial node feature representationswithin the scene graph 112. The scene graph 112 captures the full relational structure of the observed environment at a single timestep as a static symbolic representation that does not accumulate information across timesteps. A single static scene graph 112 is not capable of capturing the dynamics of the exploration process or the causal relations among the agent’s selected actions 104. To model these dynamics, each static scene graph 112 is treated as a single state in a higher-level graph, forming a chain of transitions la IGGi -> G2-^2 ■■■ n{n l1’ where each edge ai represents the selected action 104 taken by the agent. This chain of transitions forms the memory graph 182 and serves as episodic experience to guide future exploration as well as loop detection.

[0058] In one embodiment, the scene parser 110 is implemented as a deterministic rulebased parser that parses structured environment observations with high precision and zero hallucination risk. In an alternative embodiment, the scene parser 110 is implemented as an LLM-based parser that processes unstructured or noisy natural language environment descriptions and extracts entity and relation information by linguistic inference, rendering the overall framework parser-agnostic and operable in environments whose observation interfaces do not expose structured data formats.

[0059] GNN Embedding

[0060] A GNN embedder 120 receives the scene graph 112 and generates a current scene embedding vector 122, a fixed-length continuous vector ztthat encodes the structural and relational properties of the scene graph 112 in a distance-comparable embedding space. Directly indexing scene graphs 112 is non-trivial; the GNN embedder 120 addresses this byAttorney Docket No.4502-90900 (6000811PCT01)generating a vector embedding for each scene graph 112 that captures its structural relationships efficiently and in a form amenable to distance-based comparison and retrieval.

[0061] The core mechanism of the GNN embedder 120 is message passing. For node u in V in the scene graph 112, the GNN embedder 120 gathers messages from all neighbors v in N(u) based on the neighbor’s features as well as their relationsin E and updates the hidden representation huthrough an update function, expressed as:m® = ®veN(u) (jjOiCh'u-fhV-beu.v)h® = vpfflChiThm’u)

[0062] where m® is the aggregated message for node u at layer 1, cf)1is the message function, ip is the update function, and h® is the updated hidden representation of node u at layer 1.

[0063] The GNN embedder 120 adopts a Graph Attention Network (GAT) architecture, which refines the message-passing process into a single learned weighted aggregation:h®=fw®\veN(u) /

[0064] where au vare learned attention weights that allow the GNN embedder 120 to prioritize more important neighbors during aggregation, W is a learnable weight matrix at layer 1, and sigma is a nonlinear activation function. The attention weights au vare computed by a shared attention mechanism that takes as input the concatenated representations of u and v and produces a scalar logit that is normalized across all neighbors of u by a softmax operation, yielding weights au vthat sum to one for each node u. Following the final message-passing layer, a global mean pooling operation is applied to all final-layer node representations, followed by normalization, to produce the current scene embedding vector 122 zt, a single vector that is invariant to the number of nodes in the scene graph 112, enabling distance-based comparison of scenes with different numbers of entities.

[0065] The GNN embedder 120 is trained using a composite loss function L, which is the weighted sum of a triplet loss term and a uniformity loss term:h Ltriplet+ ALunifOrmj|y N — 1 N 2 = E! [max! (0, |za- zp|2- |za- zn|2+ a)] + A-^y V (1 J)i=l j = i+l 'J'

[0066] During training, a batch of anchor-positive pairs is sampled to form triplets (za, zp, zn). The anchor embedding zais a current scene embedding vector 122 from a static scene graphAttorney Docket No.4502-90900 (6000811PCT01)112 at step tl, and its corresponding positive zpis sampled from the same task sequence at step tl+1. A hard-negative embedding znis sampled from a different task sequence, mined from within the batch. The triplet loss encourages the GNN embedder 120 to produce cunent scene embedding vectors 122 in which intra-sequence distances are substantially smaller than intersequence distances. The uniformity loss term Lumformity acts as a regularization term that spreads current scene embedding vectors 122 across the embedding space to prevent representational collapse, operating on the mean of the squared cosine similarity among all unique sample pairs (zi, Zj) within the batch Z = {za l, ..., za k, zp 1(..., zp k], where N = |Z| is the total batch size. The combined effect of the two loss terms is a GNN embedder 120 that produces current scene embedding vectors 122 in a well-structured metric space where distance reliably reflects structural similarity between scenes, enabling both experience retrieval and loop detection to operate through simple distance thresholding. Scene graph 112 construction and GNN embedder 120 encoding together incur latency of under 150 milliseconds per planning step, which is negligible relative to the multiple seconds for LLM token decoding, resulting in minimal computational overhead from the graph-based encoding pipeline.

[0067] Experimental Validation: Benchmark Overview and Step Efficiency

[0068] FIG. 2 is a bar chart 200 that illustrates the average steps per task on Robotouille synchronous tasks evaluated using the Qwen3-235B backbone model, comparing GiG (success only), GiG (all trials), ReCAP (success only), ReCAP (all trials), ReAct (success only), and ReAct (all trials), with red dots indicating the average horizon length per task type. As shown in FIG. 2, for easy to medium difficulty tasks (Tasks 0 through 6), GiG and baselines demonstrate similar average step counts, closely tracking the average horizon per task type. For more difficult tasks, GiG takes slightly more steps in its completed trials compared to baselines, reflecting its ability to complete tasks on which baselines fail rather than any planning inefficiency. When including non-completed trials, represented by dashed bars where failed trials are assigned a maximum step count of three times the average horizon, the baselines exhibit substantially higher average steps than GiG, underscoring GiG’s overall efficiency when accounting for both successful and failed attempts.

[0069] FIG. 3 is a bar chart 300 that illustrates the average steps per task on Robotouille asynchronous tasks using the Qwen3-235B backbone model, comparing GiG, ReCAP, and ReAct for both successful-only and all-trial step counts, with the red line indicating the average horizon per task type. As shown in FIG. 3, GiG takes fewer steps on average for medium toAttorney Docket No.4502-90900 (6000811PCT01)high difficulty asynchronous tasks, indicating more effective planning in environments where concurrent process management is necessary.

[0070] Experience Retrieval and Experience Memory Bank

[0071] An experience retriever 140 maintains an experience memory bank 130 that stores a collection of M past successful task experiences. Each experience stored in the experience memory bank 130 is associated with a single goal and comprises a sequence of state-actiondescription transitions representing a complete or partial successful trajectory. Each scene graph 112 Gt encountered during a prior planning session is encoded by the GNN embedder 120 to form a compact current scene embedding vector 122 st= F(;NN (GtThis current scene embedding vector 122 St is used as a query to the experience memory bank 130, which stores a set of N past successful experiences M =Each stored experience Ej is associated with a single goal gj and consists of a sequence of Kj state-action-description transitions:

[0072] where sO is the current scene embedding vector 122, dj is the corresponding textual description of the environment state, and 3j ; is the selected action 104 taken at step i of experience j.

[0073] At each planning step, the current scene embedding vector 122 St is compared against all stored current scene embedding vectors 122in the experience memory bank 130 to find the closest match. If a match is found within a predefined threshold T = 0.1, the experience retriever 140 retrieves the relevant experience 142 corresponding to that matched state. The relevant experience 142 comprises three components: the associated experience goal gk, the textual description of the matched state dk,m, and the ground-truth selected action 104 sequence from that point forward:^k-> [ak,m> ^k,m+l> ■■■ > ^k,Kk-l]

[0074] This relevant experience 142 is prepended to the structured prompt 172 as a one-shot exemplar of a successful trajectory from a structurally similar state, grounding the LLM agent 170’s reasoning in proven historical state-action dependencies. To minimize retrieval overhead at scale, the similarity search is implemented using an approximate nearest-neighbor library such as Faiss, which supports efficient nearest-neighbor queries over large collections of fixed-length current scene embedding vectors 122 without exhaustive pairwise comparison.

[0075] Experiences stored in the experience memory bank 130 are not limited to experiences generated by the same model currently executing the planning session. Experiences may be pre-populated from successful completions by larger or higher-capabilityAttorney Docket No.4502-90900 (6000811PCT01)models, for example models with 100 billion or more parameters, and subsequently used to guide smaller or lower-capability models with approximately 30 billion parameters. This crossmodel skill transfer mechanism exploits the structural similarity matching property of the GNN embedder 120 to allow smaller models to benefit from selected action 104 sequences discovered by more capable models without the smaller model independently discovering those solutions. Empirical results confinn that the experience retriever 140 substantially recovers task completion perfonnance for smaller models that would otherwise trail significantly behind larger counterparts: adding the experience retriever 140 yields Pass@l gains of 15% with Qwen3-30B and 7% with Gemini -2.5-Flash-Lite on Robotouille synchronous tasks.

[0076] FIG. 4 is a bar chart 400 that illustrates the average steps per task on Robotouille synchronous tasks evaluated using the Qwen3-3OB backbone model, comparing GiG without the experience retriever 140 (GiG, success only and all trials), GiG with the experience retriever 140 (GiG+Exp, success only and all trials), ReAct (success only and all trials), and ReCAP (success only and all trials), with the red line indicating the average horizon length per task type. The figure excludes Tasks 8 and 9, as no framework successfully completed these tasks using the 30B model. As shown in FIG. 4, the experience retriever 140 not only improves Pass @ 1 task completion rates but also generally reduces the number of steps taken to achieve successful task completion. The slightly higher aggregate average step count for GiG+Exp relative to some baselines on certain tasks is an artifact of the increased success rate: the experience retriever 140 enables task completion on more complex starting environments on which baselines fail entirely, thereby raising the computed average step count for the population of successful completions.

[0077] Bounded Lookahead Simulation and Computational Efficiency

[0078] A lookahead simulator 150 receives the set of valid actions 152 available at the current state and, using a Planning Domain Definition Language (PDDL)-based forward dynamics model encoding the physical transition logic of the environment, simulates the execution of each valid action 152 individually against the current environment state to produce a set of action-observation pairs 154. Each action-observation pair 154 consists of a valid action 152 and the predicted next-state current observation 102 that would result from executing that valid action 152 in the current environment, computed deterministically by the PDDL dynamics model without LLM involvement. This one-step state projection transforms the role of the LLM agent 170 from imaginative prediction of action consequences, which is prone to hallucinated transitions that violate physical constraints, to discriminative selection amongAttorney Docket No.4502-90900 (6000811PCT01)verified, physically grounded projected realities. Formally, the lookahead simulator 150 computes the set of action-observation pairs 154 as:Slook= {(a, Simulator(0, a)) | a G A]

[0079] where O is the current observation 102, A is the set of valid actions 152, and SimulatoriO. a) returns the predicted next-state current observation 102 resulting from executing valid action a in current observation 102 O.

[0080] All action-observation pairs 154 are provided to the LLM agent 170 without greedy pre-filtering: no valid action 152 is eliminated from the structured prompt 172 based on an immediate value function or reward heuristic prior to LLM reasoning. This design preserves the full set of valid actions 152 for evaluation by the LLM agent 170 and enables the LLM agent 170 to identify and navigate complex temporal dependencies that are invisible to one-step reward signal, such as recognizing that initiating a time-delayed cooking process early and interleaving other sub-tasks during the delay is globally superior to waiting until all prerequisites are resolved before initiating the process.

[0081] Lookahead simulation is performed at depth d = 1, meaning each valid action 152 is simulated for exactly one step. This depth is chosen because multi-step rollouts incur exponential computational cost proportional to O(ed), where epsilon is the branching factor equal to the number of valid actions 152 and d is the rollout depth, making depths greater than one computationally prohibitive in environments with large action spaces. The actionobservation pairs 154 are treated as a Markov process in which each planning step conditions only on the current observation 102 and its one-step projections rather than on a growing history of prior steps. Unlike prior works that use extended history windows of up to 64 conversation exchanges, the present framework concisely formulates the structured prompt 172 from the current observation 102, the full one-step action-observation pairs 154, the progress of the task, and a selective summary of the relevant experience 142 from the experience memory bank 130, thereby maintaining bounded context window consumption while providing the LLM agent 170 with complete physical grounding at each step.

[0082] The fixed per-step context size yields a computational efficiency advantage that increases with task horizon. The computational cost for each interaction is composed of two parts: the prefill cost of processing query input and the decoding cost of generating thinking and output tokens, assuming a KV-cache implementation where previous states are preserved.

[0083] For the ReAct baseline, the compute cost for the first interaction (k = 1) is in Eq. 1 :Attorney Docket No.4502-90900 (6000811PCT01)R= (S + O)2+ ^~*(S + 0 + i) [Prefill + Decoding]

[0084] For the second interaction (k = 2), the model attends to the history (S + O + R) while processing the new current observation 102 (O), then generates R tokens is in Eq. 2:RC2= (S + O + R) O + ^(S + 20 + R + i) [Prefill + Decoding]

[0085] For the k-th interaction (general case, k > 1), where the history length is S + (k-l)(O + R) is in Eq. 3:RCk= [S + (k - 1)(O + R)] 0 + [S + kO + (k - 1)R + i]

[0086] where S is the system prompt length, O is the current observation 102 prompt length, and R is the reasoning and output token length. The total compute cost summed over N interactions is in Eq. 4:N(-■total ^-1 d"k=2

[0087] For the GiG framework, the lookahead simulator 150 incorporates epsilon additional current observations 102 derived from one-step lookahead simulation, where epsilon is the branching factor equal to the number of valid actions 152. The compute cost for the first interaction is in Eq 5:RCk= (S + eO)2+ ^~*(S + eO + i) [Prefill + Decoding]

[0088] For the second interaction, the model attends to the history (S + O + R) while processing the new current observation 102 and lookahead current observations 102 (eO), then generates R tokens. Only the most recent reasoning output R is retained to track progress, keeping prefill cost bounded in Eq. 6:RC2= (S + eO + R-J GO + ^~*(S + GO + R + i) [Prefill + Decoding]

[0089] For the k-th interaction (general case), the model attends only to R from the k-1 interaction while processing the new current observation 102 along with the one-step lookahead current observations 102 (eO) in Eq. 7:Attorney Docket No. 4502-90900 (6000811PCT01)RCk= (S + eO + Rk-i) eO + ^~*(S + eO + Rk_! + i) [Prefill + Decoding]i=l

[0090] The total compute cost for GiG summed over N interactions is in Eq. 8:N(-•total=Ci + , Ckk=2

[0091] Because Ck in the GiG framework remains unchanged with respect to growing interactions, GiG’s per-step FLOPs consumption is constant independent of session length. In contrast, the ReAct cost in equation (3) grows linearly with k.

[0092] FIG. 5 is a line chart 500 that illustrates the compute cost in FLOPs as a function of interaction step, comparing GiG at two branching factor settings (epsilon = 5 and epsilon = 10), ReAct, and ReCAP with a context window of 64 exchanges. As shown in FIG. 5, while ReAct’ s FLOPs consumption grows without bound and ReCAP’ s grows until the window is filled and then plateaus, GiG’s FLOPs consumption remains constant per step, falling below that of both baselines at task horizons beyond approximately 20 interaction steps, with the efficiency advantage increasing substantially as the horizon grows.

[0093] FIG. 6 is a bar chart 600 that illustrates the average number of tokens generated per step, comprising both reasoning tokens and output tokens, across three backbone models: Qwen3-235B, Gemini-2.5-Flash, and DeepSeek-Rl-FP4, stratified by successful and failed tasks. As shown in FIG. 6, there is substantial variance in token usage across backbone models. Qwen3-235B generates an average of 1,761 tokens per step on failed tasks and 1,181 tokens per step on successful tasks. Gemini-2.5-Flash generates an average of 1,680 tokens per step on failed tasks and 764 tokens per step on successful tasks. DeepSeek-Rl-FP4 generates an average of 710 tokens per step on failed tasks and 586 tokens per step on successful tasks. Across all three backbone models, failed tasks consistently produce longer reasoning traces than successful tasks, reflecting the LLM agent 170’ s tendency to intensify reasoning effort when confronted with difficult or ambiguous states.

[0094] FIG. 7 is a dual-panel line chart 700 that provides a more detailed compute cost analysis across a range of GiG configurations, illustrated in two panels. The top panel of FIG.7 shows compute cost as a function of interaction step under a fixed current observation 102 token count of O = 1024, comparing ReAct, ReCAP at window sizes L = 64 and L = 128, and GiG at reasoning token counts of R = 1024, R = 2048, and R = 4096, with a fixed available action space of epsilon = 10. The bottom panel of FIG. 7 shows compute cost under a fixed reasoning token count of R = 2048, comparing the same baselines and GiG at currentAttorney Docket No. 4502-90900 (6000811PCT01)observation 102 token counts of O = 512, O = 1024, and O = 2048. Both panels confirm that GiG’s per-step cost remains constant across all tested configurations while baseline costs grow linearly (ReAct) or in a windowed linear fashion (ReCAP), and that GiG requires significantly fewer computing resources for long-horizon tasks across all parameterizations tested.

[0095] In an alternative embodiment, the lookahead simulator 150 may be disabled in environments where a PDDL transition model is unavailable, where the environment is partially observable such that state projections cannot be computed reliably, or where computational constraints preclude simulation. In this alternative embodiment, the LLM agent 170 defaults to reasoning over the memory graph 182 and any relevant experience 142 retrieved from the experience memory bank 130 without the benefit of one-step action-observation pairs 154, relying on historical experience and graph-based loop detection to guide action selection.

[0096] GNN Embedding Separation Properties

[0097] FIG. 8 is a heatmap and distance distribution plot 800 that illustrates the GNN embedding separation properties for two synchronous task sequences. The top portion of FIG.8 shows a heatmap of pairwise Euclidean distances between all current scene embedding vectors 122 from two distinct sequences, labeled Seq 1 (Intra) and Seq 2 (Intra), with intersequence distances labeled as Cross (Inter). The clear block-diagonal structure in the heatmap demonstrates that intra-sequence distances are substantially smaller than inter-sequence distances, confirming that current scene embedding vectors 122 from within the same task sequence cluster together while current scene embedding vectors 122 from different sequences are well-separated. The bottom portion of FIG. 8 shows a density plot of Euclidean distances across all pairs, displaying a bimodal distribution in which the “Within Same Trace” distribution clusters near zero and the “Across Different Traces” distribution clusters at substantially higher values, with a clear separation between the two modes.

[0098] FIG. 9 is a heatmap and distance distribution plot 900 that illustrates the corresponding GNN embedding separation properties for two asynchronous task sequences, showing an analogous block-diagonal structure in the pairwise Euclidean distance heatmap and a similarly distinct bimodal separation between intra-trace and inter-trace distance distributions in the associated density plot, confirming that the trained GNN embedder 120 produces reliably separable current scene embedding vectors 122 in both synchronous and asynchronous task settings.

[0099] LLM Agent, Structured Prompt, and System Prompt

[0100] The LLM agent 170 processes a structured prompt 172 at each planning step. The structured prompt 172 comprises the current observation 102 describing the currentAttorney Docket No.4502-90900 (6000811PCT01)environment state, the valid actions 152 available at the current state, the action-observation pairs 154 produced by the lookahead simulator 150 for each valid action 152, the relevant experience 142 when retrieved by the experience retriever 140, and the loop warning 164 when generated by the loop detector 160. The structured prompt 172 is formulated exclusively from information pertaining to the current planning step and does not accumulate a growing history of all prior current observations 102 and selected actions 104 from earlier steps in the session.

[0101] The LLM agent 170 is configured to produce a structured response comprising four fields: a Reasoning field containing a step-by-step action plan justifying the proposed next selected action 104; an Action field specifying the selected action 104 chosen verbatim from the valid actions 152; a Summary field providing a concise description of the current environment state and the proposed selected action 104; and a Current Progress field tracking the completed sub-tasks and intermediate results achieved up to and including the current selected action 104.

[0102] FIG. 10 is a diagram 1000 that illustrates the first part of the system prompt used to configure the LLM agent 170 for Robotouille tasks. As shown in FIG. 10, the first part of the system prompt defines the role of the LLM agent 170 as a kitchen robot, specifies the structured response format including the Reasoning, Action, Summary, and Current Progress fields, and provides detailed reasoning instructions directing the LLM agent 170 to identify the goal and required recipe, determine the required ingredient stack order, adopt a flexible strategy of processing and immediately placing ingredients rather than preparing all ingredients before beginning to stack, verify ingredient preparation state before placement, check workspace availability before initiating preparation selected actions 104, and identify the robot’s current held item state. The first part of the system prompt further provides a recipe knowledge base defining the correct construction procedure for sandwiches, hamburgers, and soups respectively, specifying for each recipe the required ingredients, the required preparation steps for each ingredient, and the correct bottom-to-top stacking order.

[0103] FIG. 11 is a diagram 1100 that illustrates the second part of the system prompt used to configure the LLM agent 170 for Robotouille tasks. As shown in FIG. 11, the second part of the system prompt provides the detailed rules of the Robotouille environment, specifying that a player may hold only a single item at a time, that items must be placed on a station to perform selected actions 104, that a station must contain a single item to perform a selected action 104, that items may be stacked only on top of one another, that a container must contain a meal to have items added to the container, that meals may be transferred between containers, that items undergoing cooking, frying, orboiling may take several time steps to complete and may be leftAttorney Docket No.4502-90900 (6000811PCT01)unattended while other tasks are performed during the delay, and that goals are intentionally underspecified such that common-sense reasoning is necessary to determine the minimal ingredients and necessary preparation steps.

[0104] Loop Detection

[0105] A loop detector 160 maintains a session memory 162 comprising the set of current scene embedding vectors 122 generated at each prior step of the current planning session, denoted Vsession. At each planning step, the loop detector 160 checks whether the current scene embedding vector 122 eo is already present in the session memory 162 by evaluating the condition eo in Vsession. When this condition is satisfied, indicating that the LLM agent 170 has returned to a state the LLM agent 170 has occupied at an earlier step of the current session, the loop detector 160 determines that a behavioral loop has been detected and generates a loop warning 164. The loop warning 164 identifies the detected loop and includes the sequence of selected actions 104 that produced the repetitive state cycle, providing the LLM agent 170 with explicit evidence that its recent selected action 104 sequence has been unproductive and must be revised. For example, a loop warning 164 may state: “Loop detected! The action chain:[stack bread on tablel -> unstack bread on tablel -> stack bread on table 1] forms a loop.” By injecting the loop warning 164 into the structured prompt 172, the loop detector 160 directly informs the LLM agent 170’s next action selection without any modification to the LLM agent 170’s weights or architecture.

[0106] State-Transition Graph Builder and Memory Graph

[0107] After the LLM agent 170 selects a selected action 104, a state-transition graph builder 180 adds a node corresponding to the current scene embedding vector 122 and a directed edge labeled with the selected action 104 to a memory graph 182. The memory graph 182 is a directed graph G = (VG, EG) built incrementally during the current planning session, in which each node v in VG represents the current scene embedding vector 122 of a distinct environment state encountered during the session and each directed edge (vi, Vj) in EG is labeled with the selected action 104 executed to transition from state Vi to state Vj.

[0108] The full algorithmic representation of the planning loop, shown in Algorithm 1, proceeds as follows. First, the current scene embedding vector 122 is computed: e0= GNN(O). Second, the structured prompt 172 is initialized with the current observation 102 and valid actions 152: P = InitializePrompt(O, A). Third, the loop detector 160 checks for a behavioral loop: if eo in Vsession, then P.add(“Loop: “ + G.GetPath(eO)). Fourth, the lookahead simulator 150 computes the action-observation pairs 154: Slook= {(a,Simulator(0, a)) I a G A], andAttorney Docket No.4502-90900 (6000811PCT01)P.add(“Lookahead: “ + Format(Siook)). Fifth, the experience memory bank 130 is queried: (e, d) = G.FindClosestNode(eo); if d < T, then P.add(“Exp: “ + G.GetGoalPath(e)). Sixth, the LLM agent 170 generates the selected action 104: anext = LLM(P). Seventh, the memory graph 182 is updated: if eprCv is not null, then G. AddNode(eo) and G.AddEdge(eprcv, eo, aprCv). Finally, the selected action 104 anext and the current scene embedding vector 122 eo are returned for the next step.

[0109] The memory graph 182 enables non-blocking replanning by natively representing the branching, non-linear structure of concurrent task execution. Because the memory graph 182 is a directed graph rather than a linear sequence or tree, the memory graph can represent states in which multiple concurrent sub-tasks are active simultaneously and the LLM agent 170 alternates among them across successive steps, for example initiating a boiling process, switching to a cutting sub-task, returning to check the boiling process, and subsequently advancing a separate frying sub-task, without imposing any blocked-sibling constraint or requiring any sub-task to be completed before another is initiated. This graph-native representation of concurrent task execution directly addresses the serialization limitations of tree-based decomposition methods.

[0110] The memory graph 182 serves two concurrent functions. First, during the current session, the nodes of the memory graph 182 constitute the session memory 162 consulted by the loop detector 160 at each step: the loop detector 160 checks whether the current scene embedding vector 122 eo is present in Vsession and, if so, generates the loop warning 164. Second, upon successful completion of the task goal, the memory graph 182, together with the textual state descriptions and selected action 104 sequences encoded in its nodes and edges, is stored into the experience memory bank 130 as a new past successful experience, becoming available to the experience retriever 140 in future planning sessions as a relevant experience 142 to guide the LLM agent 170 through structurally similar states encountered in subsequent sessions.

[0111] The graph-in-graph architecture created by the combination of the scene graph 112 as the inner graph representation and the memory graph 182 as the outer session-level graph creates a self-reinforcing memory system in which each successfully completed session enriches the experience memory bank 130, progressively improving the LLM agent 170’s ability to retrieve structurally relevant experiences and avoid known failure patterns. As the experience memory bank 130 grows, the experience retriever 140 is able to surface relevant experiences 142 with increasing precision, and smaller models benefit increasingly from theAttorney Docket No.4502-90900 (6000811PCT01)cross-model skill transfer enabled by experiences generated by higher-capability models in prior sessions.

[0112] Experimental Validation

[0113] The method has been validated on two challenging benchmarks. Robotouille presents synchronous and asynchronous recipe-completion tasks requiring robots to prepare multi -ingredient dishes within a kitchen environment. The synchronous mode comprises 10 recipe -completion task types spanning horizons of 10 to 63 steps, covering a wide range of complexity from simple two-ingredient sandwiches (Task 0: table->bread->cheese->bread, horizon 10) through compound multi-sandwich recipes (Task 9: simultaneous table->bottombun->patty->cheese->onion(cut)->topbun and table->bread->chicken->lettuce(cut)->tomato(cut)->bread, horizon 57). For each task type, 10 distinct starting environments are generated using benchmark-provided seeds, yielding 100 total synchronous tasks. The asynchronous mode comprises 10 task types spanning horizons of 19 to 82 steps, introducing action delays for cooking operations including filling a pot with water, cooking a patty, frying chicken, and boiling soup, each of which takes multiple time steps to complete while other selected actions 104 may be interleaved. Asynchronous tasks range from simple cooked-ingredient sandwich recipes (Task 0: table->bread->cheese->chicken(cook)->bread, horizon 21) through complex compound recipes requiring simultaneous management of multiple boiling, frying, and cooking processes (Task 9: simultaneous bowl soup, burger, sandwich, and fried onion sub-tasks, horizon 82).

[0114] ALFWorld is a procedurally generated household task benchmark comprising 134 tasks across six task categories: Type 1 (pick an object and place at a receptacle), Type 2 (pick, clean, and place an object), Type 3 (pick, heat, and place an object), Type 4 (pick, cool, and place an object), Type 5 (examine an object under a light source), and Type 6 (pick two objects of the same type and place at a receptacle), with combinatorial object layouts that preclude memorization of specific object positions. Task horizons in ALFWorld range from 5 to 15 steps, with a maximum timeout of 50 steps applied following established benchmark protocol. Unlike Robotouille, ALFWorld environments do not expose the full state of the environment at the outset, requiring the LLM agent 170 to explore the environment based on its reasoning to locate objects that may be hidden in cabinets, shelves, or other locations not initially visible in the current observation 102. Accordingly, pure Chain-of-Thought prompting was excluded from ALFWorld evaluation. GiG achieves overall Pass @ 1 averages of 97% with Qwen3-235B, 91% with Gemini-2.5-Flash, and 97% with DeepSeek-Rl-FP4 on ALFWorld, outperforming ReCAP on all three backbone models.Attorney Docket No. 4502-90900 (6000811PCT01)

[0115] The framework was evaluated using a range of open-source and proprietary backbone models of varying scales, including Qwen3-235B, Qwen3-30B, DeepSeek-Rl, Gemini-2.5-Flash, and Gemini-2.5-Flash-Lite. All open-source models were hosted locally on an 8xH100 NVLink-connected rack and served using vLLM, with inference requests directed to the local serving engine via API calls to eliminate confounding factors from external providers such as undocumented system prompts or hidden tool-use mechanisms. Temperature was set to zero for all evaluations, with a maximum generation length of 4096 tokens per API call. All reported pass rates correspond to strict Pass@l, with no retries permitted except in cases of API-related errors such as service unavailability due to rate limits or service timeout.

[0116] Ablation studies confirm the individual contributions of the lookahead simulator 150 and the loop detector 160 to overall task completion performance. Evaluating on Robotouille synchronous tasks with Qwen3-235B: GiG with the loop detector 160 alone (GiG +LD) achieves 90% Pass @ 1 ; GiG with the lookahead simulator 150 alone (GiG +LA) achieves 80% Pass@l; and GiG with both the loop detector 160 and lookahead simulator 150 (GiG +LD+LA) achieves 93% Pass@l, confirming that the two components contribute complementary and additive benefits. Detailed per-task performance results for GiG and baselines on Robotouille synchronous tasks across all evaluated backbone models are reported for Qwen3-235B, showing GiG achieving 100% Pass@l on Tasks 0, 2, 3, 4, 6, 7, and 8 with an overall average of 93%, outperforming ReCAP at 71% and ReAct at 74%, as well as for Gemini-2.5-Flash (overall GiG average 92%), DeepSeek-Rl-FP4 (overall GiG average 91%), Qwen3-30B with and without the experience retriever 140 (GiG+Exp at 42% versus GiG alone at 27%), and Gemini-2.5-Flash-Lite with and without the experience retriever 140 (GiG+Exp at 26% versus GiG alone at 19%). Detailed per-task performance results on Robotouille asynchronous tasks are reported for Qwen3-235B (GiG at 72% versus ReCAP at 35%, ReAct at 31%, and Chain-of-Thought atO%), Gemini-2.5-Flash (GiG at 66%), and DeepS eek-Rl-FP4 (GiG at 59%). The experience retriever 140 provides the largest proportional benefit to smaller models, and each component contributes independently to overall task completion performance across all evaluated backbone models and task settings.

[0117] FIG. 12 is a method 1200 for long-horizon task planning in an embodied agent environment. In an embodiment, the method 1200 is implemented by a computing device or system according to an embodiment of the disclosure. In an embodiment, the computing device is a computer, a server, and Al platform, or other device configured to implement Al processes. In an embodiment, the method 1200 is implemented during Al processing or when Al content is being generated for a user.Attorney Docket No. 4502-90900 (6000811PCT01)

[0118] In block 1202, the computing device parses a current observation 102 (see FIG. 1) using a scene parser (110) to generate a scene graph (112). In block 1204, the computing device processes the scene graph (112) using a Graph Neural Network (GNN) embedder (120) to generate a current scene embedding vector (122).

[0119] In block 1206, the computing device simulates, by a lookahead simulator (150) using a Planning Domain Definition Language (PDDL)-based forward dynamics model, execution of each of a plurality of valid actions (152) to produce a set of action-observation pairs (154), wherein all action-observation pairs (154) are provided to a Large Language Model (LLM) agent (170) without greedy pre -filtering.

[0120] In block 1208, the computing device compares, by an experience retriever (140), the current scene embedding vector (122) against scene embedding vectors stored in an experience memory bank (130) and, when a match within a predefined threshold T is found, retrieving a relevant experience (142) comprising an associated goal, a textual description of a matched state, and a ground-truth action sequence from the matched state to successful goal completion.

[0121] In block 1210, the computing device compares, by a loop detector (160), the current scene embedding vector (122) against a session memory (162) and generating a loop warning (164) identifying a detected loop when a current state has been previously visited.

[0122] In block 1212, the computing device processes, by the LLM agent (170), a structured prompt (172) comprising the current observation (102), the valid actions (152), the action-observation pairs (154), the relevant experience (142) when retrieved, and the loop warning (164) when generated to select an action (104).

[0123] In block 1214, the computing device executes the selected action (104). In block 1216, the computing device adds, by a state-transition graph builder (180), a node corresponding to the current scene embedding vector (122) and a directed edge corresponding to the selected action (104) to a memory graph (182).

[0124] FIG. 13 is a schematic diagram of a computing device 1000 (e.g., computer, a server, and Al platform, device configured to implement Al processes, etc.) according to an embodiment of the disclosure. The computing device 1300 is suitable for implementing the disclosed embodiments as described herein. The computing device 1300 comprises ingress ports / ingress means 1310 (a.k.a., upstream ports) and receiver units (Rx) / receiving means 1320 for receiving data; a processor, logic unit, or central processing unit (CPU) / processing means 1330 to process the data; transmitter units (Tx) / transmitting means 1340 and egress ports / egress means 1350 (a.k.a., downstream ports) for transmitting the data; and a memory / memory means 1360 for storing the data. In an embodiment, the receiver units (Rx) / receiving means 920Attorney Docket No. 4502-90900 (6000811PCT01)comprise a discrete circuit, integrated circuit, chip set, package, hardware module, electronic device, or other structure capable of receiving signals. In an embodiment, the transmitter units (Tx) / transmitting means 940 comprise a discrete circuit, integrated circuit, chip set, package, hardware module, electronic device, or other structure capable of transmitting signals. The computing device 1300 may also comprise optical-to-electrical (OE) components and electrical-to-optical (EO) components coupled to the ingress ports / ingress means 1310, the receiver units / receiving means 1320, the transmitter units / transmitting means 1340, and the egress ports / egress means 1350 for egress or ingress of optical or electrical signals.

[0125] The processor / processing means 1330 is implemented by hardware and software. The processor / processing means 1330 may be implemented as one or more CPU chips, cores (e.g., as a multi-core processor), field-programmable gate arrays (FPGAs), application specific integrated circuits (ASICs), and digital signal processors (DSPs). The processor / processing means 1330 is in communication with the ingress ports / ingress means 1310, receiver units / receiving means 1320, transmitter units / transmitting means 1340, egress ports / egress means 1350, and memory / memory means 1360. The processor / processing means 1330 comprises a long-horizon embodied task planning module 1370. The long -horizon embodied task planning module 1370 is able to implement the methods disclosed herein. The inclusion of the long-horizon embodied task planning module 1370 therefore provides a substantial improvement to the functionality of the computing device 1300 and effects a transformation of the computing device 1300 to a different state. Alternatively, the long-horizon embodied task planning module 1370 is implemented as instructions stored in the memory / memory means 1360 and executed by the processor / processing means 1330.

[0126] The computing device 1300 may also include input and / or output (UO) devices or I / O means 1380 for communicating data to and from a user. The UO devices or UO means 1380 may include output devices such as a display for displaying video data, speakers for outputting audio data, etc. The UO devices or UO means 1380 may also include input devices, such as a keyboard, mouse, trackball, etc., and / or corresponding interfaces for interacting with such output devices.

[0127] The memory / memory means 1360 comprises one or more disks, tape drives, and solid-state drives and may be used as an over-flow data storage device, to store programs when such programs are selected for execution, and to store instructions and data that are read during program execution. The memory / memory means 1360 may be volatile and / or non-volatile and may be read-only memory (ROM), random access memory (RAM), ternary content-addressable memory (TCAM), and / or static random-access memory (SRAM).Attorney Docket No. 4502-90900 (6000811PCT01)

[0128] Embodiments of the present disclosure provide at least the following technical advantages to technical problems. For example, the system and method of the present disclosure address two fundamental limitations of conventional long-horizon embodied task planning: computational cost and planning coherence. By replacing accumulated interaction history with a graph-in-graph memory architecture, the system maintains approximately constant compute cost per reasoning step regardless of task length, in contrast to conventional approaches whose transformer self-attention costs grow quadratically with interaction count. The experience memory bank enables smaller, resource-efficient language model backbones to recover substantial performance - up to 15% Pass@l - by leveraging successful trajectories collected from larger models, reducing deployment cost without proportional sacrifice in planning quality. The GNN -based scene embedding architecture produces compact, structure-aware state representations that support accurate threshold-based retrieval and loop detection, as confirmed by the clear intra-trace clustering and inter-trace separation demonstrated in the embedding heatmaps.

[0129] On the planning quality side, the combination of one-step lookahead simulation and loop detection enables the agent to reason proactively rather than reactively. Unlike greedy filtering methods that eliminate candidate actions based on immediate value and thereby preclude efficient parallel plans, the lookahead simulator presents complete action consequence information to the language model, enabling identification of strategies that require temporary setbacks to achieve superior long-horizon outcomes. Experimentally, the system achieves Pass @ 1 improvements of up to 19 percentage points over the strongest baseline on synchronous tasks and up to 37 percentage points on asynchronous tasks - where parallel process management is most critical - while simultaneously requiring significantly less computation for long-horizon planning than conventional history-based frameworks.

[0130] While several embodiments have been provided in the present disclosure, it may be understood that the disclosed systems and methods might be embodied in many other specific forms without departing from the spirit or scope of the present disclosure. The present examples are to be considered as illustrative and not restrictive, and the intention is not to be limited to the details given herein. For example, the various elements or components may be combined or integrated in another system or certain features may be omitted, or not implemented.

[0131] In addition, techniques, systems, subsystems, and methods described and illustrated in the various embodiments as discrete or separate may be combined or integrated with other systems, components, techniques, or methods without departing from the scope of the presentAttorney Docket No. 4502-90900 (6000811PCT01)disclosure. Other examples of changes, substitutions, and alterations are ascertainable by one skilled in the art and may be made without departing from the spirit and scope disclosed herein.

Claims

Attorney Docket No. 4502-90900 (6000811PCT01)CLAIMSWhat is claimed is:

1. A method for long-horizon task planning in an embodied agent environment, the method comprising:parsing a current observation using a scene parser to generate a scene graph; processing the scene graph using a Graph Neural Network (GNN) embedder to generate a current scene embedding vector;simulating, by a lookahead simulator using a Planning Domain Definition Language (PDDL)-based forward dynamics model, execution of each of a plurality of valid actions to produce a set of action-observation pairs, wherein all action-observation pairs are provided to a Large Language Model (LLM) agent without greedy pre-filtering;comparing, by an experience retriever, the current scene embedding vector against scene embedding vectors stored in an experience memory bank and, when a match within a predefined threshold T is found, retrieving a relevant experience comprising an associated goal, a textual description of a matched state, and a ground-truth action sequence from the matched state to successful goal completion;comparing, by a loop detector, the current scene embedding vector against a session memory and generating a loop warning identifying a detected loop when a current state has been previously visited;processing, by the LLM agent, a structured prompt comprising the current observation, the valid actions, the action-observation pairs, the relevant experience when retrieved, and the loop warning when generated to select an action;executing the selected action; andadding, by a state-transition graph builder, a node corresponding to the current scene embedding vector and a directed edge corresponding to the selected action to a memory graph.

2. The method of claim 1, wherein the GNN embedder implements a Graph Attention Network (GAT) architecture that computes attention-weighted aggregations of neighbor node features during message passing, wherein learned attention weights determine a relative importance of each neighbor to each node, and wherein a global mean pooling operation followed by normalization is applied to final node embeddings produced by the GATAttorney Docket No. 4502-90900 (6000811PCT01)architecture to produce the current scene embedding vector as a fixed-dimensional representation that is invariant to a number of nodes in the scene graph.

3. The method of claim 1, wherein the GNN embedder is trained using a composite loss function comprising a triplet loss term and a uniformity loss term, wherein the triplet loss term encourages embeddings from a same task trajectory to be proximate and embeddings from different trajectories to be distant, and wherein the uniformity loss term acts as a regularization term that spreads embeddings across an embedding space to prevent representational collapse by minimizing a mean squared cosine similarity among all unique embedding pairs within a training batch.

4. The method of claim 3, wherein training triplets are formed by sampling an anchor embedding from a first scene in a task sequence, sampling a positive embedding from a same task sequence one step later, and sampling a hard-negative embedding from a different task sequence within a training batch.

5. The method of claim 1, wherein the experience memory bank is implemented using a library index to enable efficient similarity search over stored scene embedding vectors, and wherein the experience memory bank is populated with successful experiences collected from a first LLM backbone of greater capability for use in guiding a second LLM backbone of lesser capability.

6. The method of claim 1, wherein each historical successful task execution experience stored in the experience memory bank comprises a goal and a sequence of state-actiondescription transitions, each transition comprising a scene embedding vector, a textual description of a state, and an action taken at a respective step.

7. The method of claim 1 , wherein retrieving the relevant experience comprises retrieving the associated goal, the textual description of the matched state, and the ground-truth action sequence from the matched state to successful goal completion, and wherein the relevant experience is prepended to the structured prompt as a one-shot example of a successful trajectory from a structurally similar state.Attorney Docket No. 4502-90900 (6000811PCT01)8. The method of claim 1, wherein simulating execution of each valid action is limited to a one-step lookahead depth of d = 1 without recursive multi-step rollout, a computational cost of which grows as 0(e) per timestep in contrast to multi-step lookahead at depth d > 1 , which grows exponentially as O(eAd).

9. The method of claim 1 , wherein the structured prompt does not include an accumulated interaction history from prior timesteps, such that a compute cost per interaction remains approximately constant with respect to growing interaction count because only a reasoning output from an immediately preceding interaction is retained in the structured prompt, in contrast to history-based approaches whose compute cost grows with each additional interaction due to an accumulating history length.

10. The method of claim 1, wherein the structured prompt instructs the LLM agent to generate a response comprising: a Reasoning field containing step-by-step analysis including goal identification, required stack order determination, flexible ingredient preparation strategy, workspace availability checking, robot holding state identification, and a complete action plan; an Action field specifying the selected action using exact wording from the valid actions; a Summary field providing a concise environment description and proposed action in fewer than 150 words; and a Current Progress field representing completed sub-tasks or a current assembly configuration.

11. The method of claim 1 , wherein the loop warning identifies a specific action sequence forming the detected loop and is incorporated into the structured prompt to enable the LLM agent to recognize and avoid repetitive unproductive action cycles.

12. The method of claim 1, further comprising, upon successful task completion, adding the memory graph to the experience memory bank as a new historical successful task execution experience, enabling future retrieval by the experience retriever for subsequent task executions.

13. The method of claim 1, wherein the session memory is constituted by nodes of the memory graph, such that each node added to the memory graph by the state-transition graph builder is simultaneously registered in the session memory for subsequent loop detection comparisons by the loop detector.Attorney Docket No. 4502-90900 (6000811PCT01)14. The method of claim 1 , wherein when no distance between the current scene embedding vector and any stored scene embedding vector is within the predefined threshold T, the structured prompt is processed by the LLM agent without a retrieved relevant experience, using only the current observation, the valid actions, the action-observation pairs, and the loop warning when generated.

15. The method of claim 10, wherein the structured prompt further comprises an Error Feedback field when a previous action was syntactically incorrect or did not exist in the valid actions, wherein the Error Feedback field does not check semantic correctness, should neither reinforce nor discourage a current strategy, and requires the Current Progress field to revert to a state prior to the previous action.

16. The method of claim 1 , wherein the structured prompt specifies that a player can hold only a single item at a time, that an item must be placed on a station to perform an action on the item, that a station must contain a single item to perform an action on the item, that items can only be stacked on top of one another, that a container must contain a meal to have items added to the container, that a meal can be transferred between containers, and that items may take several steps to cook, fry, or boil, during which the LLM agent can leave a station and perform other tasks.

17. The method of claim 1, wherein the embodied agent environment is an asynchronous task environment in which certain actions require multiple timesteps to complete, and wherein after initiating such a time-delayed action the LLM agent is enabled by the action-observation pairs to identify and execute parallel preparation actions rather than waiting idly.

18. The method of claim 1, wherein the GNN embedder is trained such that scene embedding vectors from within a same task sequence exhibit smaller pairwise Euclidean distances than scene embedding vectors from different task sequences to produce a clear blockdiagonal separation structure in pairwise distance heatmaps and distinct intra-trace and intertrace distance distributions and to support accurate threshold-based retrieval by the experience retriever and threshold-based loop detection by the loop detector.Attorney Docket No. 4502-90900 (6000811PCT01)19. The method of claim 1, wherein the experience memory bank is populated with successful experiences collected from a first LLM backbone of greater capability for use in guiding a second LLM backbone of lesser capability on synchronous benchmark tasks.

20. The method of claim 1, wherein the method achieves superior performance on synchronous tasks and asynchronous tasks compared to ReAct and ReCAP baselines across multiple LLM backbone models.

21. A computing device, comprising:a memory storing instructions; andone or more processors coupled to the memory, the one or more processors configured to execute the instructions to cause the computing device to implement the method in any of claims 1-20.

22. A non-transitory computer readable medium comprising a computer program product for use by a computing device, the computer program product comprising computer executable instructions stored on the non-transitory computer readable medium that, when executed by one or more processors, cause the ingress network node to execute the method in any of claims 1-20.

23. A computing device, comprising:means for parsing a current observation using a scene parser to generate a scene graph; processing the scene graph using a Graph Neural Network (GNN) embedder to generate a current scene embedding vector;means for simulating, by a lookahead simulator using a Planning Domain Definition Language (PDDL)-based forward dynamics model, execution of each of a plurality of valid actions to produce a set of action-observation pairs, wherein all action-observation pairs are provided to a Large Language Model (LLM) agent without greedy pre-filtering;means for comparing, by an experience retriever, the current scene embedding vector against scene embedding vectors stored in an experience memory bank and, when a match within a predefined threshold T is found, retrieving a relevant experience comprising an associated goal, a textual description of a matched state, and a ground-truth action sequence from the matched state to successful goal completion;Attorney Docket No. 4502-90900 (6000811PCT01)means for comparing, by a loop detector, the current scene embedding vector against a session memory and generating a loop warning identifying a detected loop when a current state has been previously visited;means for processing, by the LLM agent, a structured prompt comprising the current observation, the valid actions, the action-observation pairs, the relevant experience when retrieved, and the loop warning when generated, to select an action;means for executing the selected action; andmeans for adding, by a state -transition graph builder, a node corresponding to the current scene embedding vector and a directed edge corresponding to the selected action to a memory graph.

Images