SAGAS: Semantic-Aware Graph-Assisted Stitching for Offline Temporal Logic Planning

arXiv:2512.00775 · cs.RO, cs.SY, eess.SY · Submitted 2025-11-30 · Read on arXiv

Listen

Radio episode about this paper

Transcript

Introduction to the show: ident: Robotics Radio. Generated commentary on the latest robotics and control papers.

Rosa: We're looking at the paper: "SAGAS: Semantic-Aware Graph-Assisted Stitching for Offline Temporal Logic Planning".

Dev: Here's the gist of the paper. SAGAS is a framework designed for offline, model-free robotic planning and execution under Linear Temporal Logic (LTL) specifications, operating without online interaction, task demonstrations, or policy retraining.

Rosa: It achieves this by combining symbolic synthesis with data-driven reachability structure learned from fragmented offline trajectories.

Dev: The core of SAGAS involves an offline phase that constructs a formula-agnostic reachability interface: a weighted latent reachability graph (Hgraph = (V, E, w)), raw-state support sets (Dv), and a frozen low-level policy (pi low) for executing local transitions.

Rosa: During this phase, the system learns a reusable motion substrate by repurposing GAS-style trajectory stitching into this reachability graph.

Title and authors: Rosa: So we're looking at this paper called "SAGAS: Semantic-Aware Graph-Assisted Stitching for Offline Temporal Logic Planning". It’s tackling the problem of planning and executing robots offline, without any online interaction or policy retraining, using only fixed, task-agnostic trajectory fragments.

Dev: Right, so it's dealing with Linear Temporal Logic specifications. That means we're talking about specifying longhorizon robot tasks rigorously using LTL. The trade-off they point out is that model-based synthesis needs accurate labeled transition systems, but learning methods usually require online data or task-specific rewards.

Taro: So the core idea here seems to be combining symbolic synthesis with a reachability structure learned from those offline trajectories. It sounds like they're trying to build something reusable from just fragments.

Rosa: Exactly, and SAGAS first builds this formula-agnostic reachability interface, which is this weighted latent reachability graph, that’s the main data-driven part of it. They also learn raw-state support sets and a frozen low-level policy for executing local transitions during that offline phase.

Dev: That sounds like they’re creating a motion substrate once, something you can reuse later regardless of the specific task you're trying to solve. And then at test time, they use that graph to perform semantic graph augmentation based on the actual LTL formula you give them.

Taro: I wonder how they handle grounding those state-defined propositions from the LTL formula onto this learned graph when it comes to unseen specifications. That’s where the generalization part gets tricky.

Rosa: They achieve zero-shot generalization by shifting the reasoning away from policy learning and into test time through that graph augmentation. They ground the atomic propositions of your LTL specification onto the learned graph, which creates a semantic reachability graph for you to work with.

Dev: And then they optimize a cost-aware objective function, using dataset-supported reachability costs, by searching this product of the semantic graph and a Büchi automaton. That’s how they synthesize that cost-aware accepting prefix–suffix waypoint plan.

Taro: So the high level planning isn't learning a policy; it's synthesizing a path by searching over this combined system. What about the formal guarantee? Is it solid?

Title and authors: Rosa: The formal guarantee is conditional, Dev, which means if that semantic product planner returns an accepting prefix–suffix plan and the physical rollout realizes the planned product transitions or dwell obligations under the task-time label function, then it satisfies your original LTL formula.

Dev: That’s a crucial distinction. It’s not a guarantee of perfect execution from the start, but rather a guarantee that if you follow the plan and it works in practice, the underlying structure is sound for that specific task.

Taro: Speaking of execution, I'm curious about what happens when the robot actually hits trouble during runtime. How does this framework handle the world misbehaving?

Rosa: They incorporate "Guard-aware semantic steering" to bias tracking away from anchors associated with forbidden labels, and they have "Runtime semantic monitoring" to verify that positive literals are being satisfied and negative literals are absent along the executed segments.

Dev: That sounds like they’re building in some kind of runtime safety mechanism directly into the planning process by looking ahead at what's allowed based on the LTL constraints. It’s about steering away from bad areas before you get stuck.

Taro: So it seems like they’re using the structure learned offline to guide a more cautious, yet still goal-oriented, real-time execution strategy. It moves beyond just finding *a* path to finding one that respects the temporal logic constraints during movement.

Rosa: That's right. They successfully synthesize and execute prefix–suffix behaviors zero shot from fragmented data by reusing that fixed, task-agnostic reachability backbone for the physical rollout. That’s a pretty neat way to do it without needing new training data for every single specification you throw at it.

Dev: It’s powerful because you don't need to design a reward function specifically tailored to the LTL formula; you just ground the propositions, and the search engine figures out how to satisfy them using the graph structure. That’s a huge simplification for deployment.

Taro: What about where this is still limited? I mean, if you're testing it in a completely novel environment that wasn't represented in those offline trajectory fragments, does it still work reliably?

Rosa: The paper points out that the formal guarantee is conditional on the physical realization of those planned product transitions under the task-time label function. And they also highlight that physical realization is a dominant failure source, suggesting stronger local execution mechanisms are really crucial for reliability.

Title and authors: Dev: So while the high-level synthesis is sophisticated, if you have a weird dynamic interaction not captured in the graph structure, the physical system might fail to follow the plan even if the plan itself was theoretically sound. That’s where things get tough on trials.

Taro: I think that's fair. And I also see their limitation being tied to how much support is present in that offline graph; if it doesn't contain enough support for a new region, the system won't be able to ground those new task space regions effectively at test time.

Rosa: Exactly, so the success hinges on having sufficient data coverage in that initial offline phase. But overall, SAGAS shows a way to separate the complex temporal reasoning from online policy learning by using this graph-based search mechanism instead.

Dev: It’s a framework for moving toward more robust offline planning for complex temporal constraints without needing constant interaction with the environment or retraining policies for every new specification.

Taro: This work feels like it's laying groundwork for systems that can plan sequences of actions based on high-level temporal logic, even when the specific sequence hasn't been seen before in a training dataset.

Rosa: So to wrap up, SAGAS is a framework that combines symbolic synthesis with learned reachability to perform offline, model-free robotic planning under LTL specifications. It shows how you can shift reasoning from policy learning to test time graph augmentation and symbolic search for zero-shot generalization.

Dev: And the key improvement there is synthesizing those cost-aware accepting prefix–suffix waypoint plans by augmenting the latent reachability graph with task relevant proposition semantics and applying Büchi product search over that semantic graph and the Büchi automaton.

Taro: For me, it’s a big step toward having systems that can handle complex temporal behavior over data-supported regions while reusing a fixed motion backbone without needing task-specific reward design.

Rosa: That’s the essence of it, linking offline data structure learning directly to symbolic temporal logic satisfaction through test time augmentation and search. We’ll see how this plays out in more complex real-world scenarios soon.

The paper's summary: Rosa: So to recap, SAGAS is this new way of planning robot movements offline under Linear Temporal Logic specifications by using a learned reachability graph and then grounding those logic rules onto it at test time for search.

Dev: Right, so what makes this different from just learning a policy directly? It shifts the heavy lifting from trying to learn how to do the task online to building this structure once offline and then doing symbolic searching when you need a plan.

Rosa: Exactly. The paper shows they create this formula-agnostic reachability interface first, which is this graph that’s built from fragmented offline data. Then, at test time, they perform semantic graph augmentation by mapping the LTL propositions onto that learned graph to get a semantic reachability graph for planning.

Dev: That’s the core improvement on my side. It means you don't need to design a specific reward function just because you have an LTL formula; you just ground the state definitions, and then this product of your semantic graph and a Büchi automaton does the cost-aware prefix-suffix search for you.

Rosa: And they get this reusable motion substrate too, which is this fixed low-level policy learned from trajectory stitching. That way, you don't retrain that low level policy every time you change the high level LTL specification.

Dev: The formal guarantee is conditional, which means if the planning search finds a plan and the physical robot actually follows it under the task-time label function, then it satisfies your LTL. But they also show how to handle runtime issues using guard-aware steering to steer away from forbidden labels while monitoring for positive and negative literals being satisfied during execution.

Rosa: It’s interesting because even with this structure, the paper admits that physical realization is still a big failure source; if the robot doesn't follow the planned transitions correctly in practice, the plan won't work.

Dev: That makes sense from a control loop standpoint. So, what does this mean for real-world deployment? It suggests you can synthesize structured temporal behavior zero shot from just a few fragments of data by reusing that fixed backbone for the physical rollout.

Rosa: It means you decouple the complex temporal reasoning—the LTL stuff—from the online policy learning process, moving it into a test-time search phase instead. This opens up possibilities for planning complex sequences without needing constant interaction with the environment or retraining policies for every new specification you throw at it.

Dev: I think that’s where this is really useful. It’s a framework for moving toward more robust offline planning for complex temporal constraints without needing constant interaction with the environment or retraining policies for every new specification. We should talk next about how they benchmark this against those other papers we looked at, like MolmoBot and FlowPilot.

The paper's improvements: Rosa: So, looking at how they improve SAGAS, it seems like they are focusing on making that test time search even more robust and flexible for different environments than just grounding propositions on a static graph structure.

Dev: Right, so the main point is shifting the reasoning to be more data-driven during that semantic augmentation phase. They introduce this idea of using soft labels and anchor nodes when grounding state definitions onto the learned graph.

Rosa: That lets you introduce new regions into your task space at test time, as long as that initial offline graph has enough support nearby. It makes the system less brittle if you’re moving to a slightly different setting.

Dev: And they also refine the cost-aware search by using soft-label screening during that prefix-suffix search. That helps keep the plan from getting stuck in bad areas of the semantic graph while it’s looking for an acceptable path.

Rosa: It sounds like they are trying to make sure that even when you're searching over this product system, you’re not just blindly following paths but actively steering toward better ones based on the learned costs.

Dev: Exactly. That ties into the execution side where they use guard-aware semantic steering, which biases tracking away from anchors associated with labels that are forbidden by your LTL constraints during actual motion.

Rosa: So it’s not just about making a good plan offline; it’s about making the robot execute that plan safely in real time by steering its movement based on those logical constraints.

Dev: And they also have runtime semantic monitoring, which checks every segment of the executed path to verify that positive literals are actually being met and negative literals aren't appearing where they shouldn't. That provides a layer of verification for the formal guarantee.

Rosa: It’s interesting because this whole system relies on having good data coverage initially; if the offline graph doesn't have enough support in a new area, those improvements might not help much at test time.

Dev: That’s the caveat they stress—the success really hinges on that initial data collection phase being thorough enough to cover the areas you expect to operate in. So, this work shows how to build a system that can handle complex temporal behavior over data-supported regions while reusing a fixed motion backbone without needing task-specific reward design.

Rosa: It’s like you get a powerful planning engine that's already trained on general movement patterns, and then you just tell it the logic for your specific task at the very last second. We should talk next about how they benchmark this against those other papers we looked at, like MolmoBot and FlowPilot.

Conclusion: Tom: So to wrap up, SAGAS is this framework that uses learned reachability graphs and test time graph augmentation to do offline planning under Linear Temporal Logic specifications by using a reusable motion substrate for the physical execution part.

Rosa: Yeah, it shows how you can shift the reasoning from policy learning to test time graph augmentation and symbolic search for zero shot generalization. It’s about separating the complex temporal logic from online policy learning.

Dev: The implication is that you can synthesize cost aware accepting prefix suffix waypoint plans by augmenting the latent reachability graph with task relevant proposition semantics and applying Büchi product search over that semantic graph and the Büchi automaton. That’s a big step for deployment because you don't need task specific reward design.

Taro: I just keep thinking about how much it relies on having good data coverage in that initial offline phase; if the offline graph doesn't have enough support in a new area, those improvements might not help much at test time.

Rosa: That’s true, and they admit that physical realization is still a big failure source; so even with this sophisticated search, you still need strong local execution mechanisms for reliability.

Dev: So the formal guarantee is conditional, meaning if the robot doesn't follow the planned transitions correctly in practice under the task time label function, it won't satisfy your original LTL formula. But they also have guard aware steering and runtime monitoring to help manage that risk during execution.

Taro: It’s a solid approach to handling failure modes gracefully, using those guards to steer away from forbidden labels while constantly checking for positive literals along the executed path. That makes the system much more resilient than just finding any path.

Rosa: So this paper, SAGAS: Semantic-Aware Graph-Assisted Stitching for Offline Temporal Logic Planning, is really demonstrating how to link offline data structure learning directly to symbolic temporal logic satisfaction through test time augmentation and search. It’s a framework that shows you can plan complex sequences zero shot from fragmented data by reusing a fixed backbone.

Dev: It moves the planning heavy lifting out of the online policy loop and into a test time symbolic search, which is essential for real-time constraints we deal with every day. We should probably look at how they compare these results against MolmoB0T and FlowPilot next to see where this fits in terms of performance on actual locomotion tasks.

Taro: I’m curious if this structure holds up when the physical world presents dynamics that aren't well-modeled by the initial offline trajectory fragments; I want to see how it handles those surprises.

Shanghai Jiao Tong University

cs.RO, cs.SY, eess.SY

Submitted: 2025-11-30

Updated: 2026-11-12

Project page: https://cps-sjtu.github.io/SAGAS

License: http://creativecommons.org/licenses/by-nc-sa/4.0/

Importance score: 100/100

The gist: SAGAS is a framework designed for offline, model-free robotic planning and execution under Linear Temporal Logic (LTL) specifications, operating without online interaction, task demonstrations…

Key concepts

Latent Reachability Graph (Hgraph)
This is a learned, formula-agnostic graph structure derived from offline trajectories. It represents possible state transitions and their associated costs without needing to know the specific LTL formula beforehand. It serves as a reusable motion substrate that captures the fundamental physical possibilities of the robot's movement based on collected data.
Semantic Reachability Graph (Hsem_{\phi})
This graph is created at test time by grounding propositions from an LTL formula onto the learned Hgraph. It adds task-specific meaning to the physical graph, showing which states satisfy or violate the required temporal logic properties ($\phi$). This semantic layer allows high-level planning to reason about temporal constraints directly on the learned structure.
Product System ($\mathcal{P}_{\phi}$)
This is a search space formed by combining the semantic reachability graph (Hsem_{\phi}) with a Büchi automaton ($B_{\phi}$). The Büchi automaton encodes the temporal logic constraints. Searching this product system allows the planner to find a plan that satisfies both the physical reachability and the required temporal logic properties simultaneously.
Guard-aware Semantic Steering
This is an execution technique where tracking is biased away from physical locations (anchors) that are associated with forbidden states or negative literals in the LTL specification. This steering mechanism uses runtime monitoring to ensure the robot actively avoids regions that violate temporal constraints during execution.

Terminology

Summary

SAGAS is a framework designed for offline, model-free robotic planning and execution under Linear Temporal Logic (LTL) specifications, operating without online interaction, task demonstrations, or policy retraining. p. 0

Where the paper says it

cn Abstract Linear Temporal Logic (LTL) provides a rigorous framework for specifying longhorizon robotic tasks, yet existing approaches face a trade-off: model-based synthesis relies on accurate labeled transition systems, whereas learning-based methods often require online interaction, task-specific rewards, or specification-conditioned training. We study LTL-specified robotic planning and execution in a stricter offline, model-free setting, where the agent is given only fixed, task-agnostic trajectory fragments, with no dynamics model, task demonstrations, or online data collection.

It achieves this by combining symbolic synthesis with data-driven reachability structure learned from fragmented offline trajectories. p. 0
Where the paper says it

To address this setting, we propose SAGAS, a framework that combines the compositionality of symbolic synthesis with the data-driven reachability structure learned from offline trajectories. SAGAS first learns a reusable latent reachability graph and a frozen goal-conditioned executor from fragmented offline data.

The core of SAGAS involves an offline phase that constructs a formula-agnostic reachability interface: a weighted latent reachability graph (Hgraph = (V, E, w)), raw-state support sets (Dv), and a frozen low-level policy (pi low) for executing local transitions. p. 3

Where the paper says it

The offline phase constructs a formula-agnostic reachability interface from the fixed trajectory dataset. This interface consists of three reusable objects: a weighted latent reachability graph Hgraph = (V, E, w), raw-state support sets {Dv}v∈V for graph nodes, and a frozen low-level policy πlow for executing local graph transitions.

During this phase, the system learns a reusable motion substrate by repurposing GAS-style trajectory stitching into this reachability graph. p. 1
Where the paper says it

Second, we repurpose GAS-style trajectory stitching into a reusable motion substrate for temporal-logic planning, decoupling offline reachability learning from task-time symbolic reasoning. Third, we introduce a task-time semantic graph augmentation and cost-aware product-synthesis procedure over the learned latent graph, grounding state-defined propositions and optimizing accepting prefix–suffix waypoint plans using dataset-supported reachability costs.

At test time, SAGAS instantiates the symbolic layer to perform task-time semantic graph augmentation. p. 1

Where the paper says it

Given a new LTL task, SAGAS instantiates the symbolic layer only at test time. It augments the latent reachability graph with task-relevant proposition semantics, converting the reusable motion graph into a data-supported labeled abstraction suitable for automata-guided search.

This involves grounding state-defined propositions from the LTL formula onto the learned graph, resulting in a semantic reachability graph (Hsem phi). p. 1
Where the paper says it

Third, we introduce a task-time semantic graph augmentation and cost-aware product-synthesis procedure over the learned latent graph, grounding state-defined propositions and optimizing accepting prefix–suffix waypoint plans using dataset-supported reachability costs. Finally, on LTL task suites constructed from the OGBench AntMaze and HumanoidMaze domains, we show that SAGAS synthesizes and executes prefix–suffix behaviors zero-shot from fragmented offline data, improving finite-lasso execution success and execution cost over three baselines, especially on hard specifications.

The high-level planning then optimizes a cost-aware objective function, J graph(gamma) = lambda Cost(gamma pre) + (1 - lambda) Cost(gamma suf), using dataset-supported reachability costs. p. 2
Where the paper says it

Since the true execution cost is unavailable during offline planning, the method below optimizes a graph-based surrogate of (2) using dataset-supported reachability costs and evaluates execution cost from realized rollouts. This formulation separates task-time symbolic planning from reusable execution: new formulas and label functions determine the high-level prefix–suffix plan Γ, while the low-level executor is learned once from D and reused without task-specific retraining.

This optimization is performed by searching the product of the semantic graph and a Büchi automaton (P phi = Hsem phi times B phi), synthesizing a cost-aware accepting prefix–suffix waypoint plan. p. 3
Where the paper says it

It augments the offline reachability graph with task-relevant proposition semantics, producing a semantic reachability graph suitable for automata-guided search. SAGAS then searches the product of this semantic graph and the Büchi automaton Bϕ to synthesize a cost-aware accepting prefix–suffix waypoint plan.

The framework's key innovation lies in shifting formula-specific reasoning from policy learning to test-time graph augmentation and symbolic search. This allows zero-shot generalization to unseen LTL specifications without requiring task-specific reward design or policy retraining. p. 0

Where the paper says it

For each new LTL formula, it performs task-time semantic graph augmentation to ground state-defined propositions on the learned graph, and applies Büchi product search to synthesize a cost-aware accepting prefix–suffix waypoint plan executed by the frozen executor. By shifting formula-specific reasoning from policy learning to test-time graph augmentation and symbolic search, SAGAS enables zero-shot generalization to unseen, data-supported LTL specifications without task-specific reward design, policy retraining, or online interaction.

The formal guarantee is conditional: if the semantic product planner returns an accepting prefix–suffix plan and the physical rollout realizes the planned product transitions or dwell obligations under the task-time label function, then the induced trajectory satisfies the original LTL formula. p. 3
Where the paper says it

At task time, a new LTL formula induces proposition semantics that lift this graph into a semantic reachability abstraction for Büchi-product search. The resulting accepting prefix–suffix waypoint plan is executed by the frozen policy and checked by a runtime label monitor.

The execution protocol incorporates Guard-aware semantic steering, which biases tracking away from anchors associated with forbidden labels, and Runtime semantic monitoring to verify satisfaction of positive literals and check for negative literal absence along executed segments. The framework handles complex LTL structures by searching over an implicit product system (P phi) that combines learned reachability and logical transition guards. p. 5

Where the paper says it

The semantic reachability graph Hsem ϕ serves as the transition system for high-level planning: its edges provide learned surrogates for offline dataset-supported reachability, while its soft labels and anchors provide semantic evidence for enabling automaton guards. The resulting search has the usual automata-theoretic product structure, but it optimizes logical progress together with learned reachability-cost surrogates.

Experiments on OGBench locomotion domains demonstrate superior performance, achieving 71. p. 8

Where the paper says it

SAGAS repurposes graph-assisted trajectory stitching into a reusable reachability substrate, augments the learned latent graph with task-time proposition semantics, and performs cost-aware Büchi product search to synthesize accepting prefix–suffix waypoint plans executed by a frozen low-level policy. Experiments on LTL task suites constructed from OGBench locomotion domains demonstrate zero-shot planning and execution of diverse temporal-logic tasks from fragmented offline data, improving finite-lasso execution success and capped execution cost over baselines.

8% SR and 0.30 NCC on AntMaze and 57. p. 7
Where the paper says it

Table 1: Aggregate results over 8 AntMaze and 6 HumanoidMaze environments. SR is finitelasso execution success rate; NCC is normalized capped cost.

4% SR and 0.45 NCC on HumanoidMaze overall, outperforming baselines like LF-GAS, especially in hard tasks where the gap is largest. p. 1
Where the paper says it

Third, we introduce a task-time semantic graph augmentation and cost-aware product-synthesis procedure over the learned latent graph, grounding state-defined propositions and optimizing accepting prefix–suffix waypoint plans using dataset-supported reachability costs. Finally, on LTL task suites constructed from the OGBench AntMaze and HumanoidMaze domains, we show that SAGAS synthesizes and executes prefix–suffix behaviors zero-shot from fragmented offline data, improving finite-lasso execution success and execution cost over three baselines, especially on hard specifications.

The failure mode analysis indicates that physical realization rather than high-level synthesis is the dominant failure source, suggesting that stronger local execution mechanisms are crucial for reliability. p. 8
Where the paper says it

2% of SAGAS failures are caused by the absence of a feasible product prefix or suffix; most failures instead arise from low-level execution issues such as locomotion stalling or overturning. This indicates that the main remaining bottleneck is long-horizon low-level realization by the frozen executor, rather than missing proposition witnesses or large-scale failure of high-level product search.

Furthermore, ablation studies confirm the roles of auxiliary components: soft-label screening improves NCC during product search, while guard-aware steering avoids forbidden regions during execution. p. 6
Where the paper says it

Because negative-literal screening in the semantic graph is node-level, SAGAS also applies a lightweight guard-aware steering bias during local tracking. When the current guard term contains forbidden labels and nearby anchors for those labels are available, the waypoint-tracking direction is adjusted by a bounded repulsive component to guide tracking away from forbidden labeled regions.

SAGAS successfully synthesizes and executes prefix–suffix behaviors zero-shot from fragmented data, demonstrating its ability to synthesize structured temporal behavior over data-supported regions while reusing a fixed, task-agnostic reachability backbone. p. 1
Where the paper says it

Third, we introduce a task-time semantic graph augmentation and cost-aware product-synthesis procedure over the learned latent graph, grounding state-defined propositions and optimizing accepting prefix–suffix waypoint plans using dataset-supported reachability costs. Finally, on LTL task suites constructed from the OGBench AntMaze and HumanoidMaze domains, we show that SAGAS synthesizes and executes prefix–suffix behaviors zero-shot from fragmented offline data, improving finite-lasso execution success and execution cost over three baselines, especially on hard specifications.

Green — the paper says it, and the page is printed. Red — no passage carries it, so treat that sentence as unverified. The same check runs on your own text: check a summary against its source, $5.

Improvements for AI systems

  1. Improved AI systems can perform zero-shot generalization to unseen LTL specifications without task-specific reward design, policy retraining, or online interaction by shifting formula-specific reasoning from policy learning to test-time graph augmentation and symbolic search.

  2. The improved system can synthesize cost aware accepting prefix–suffix waypoint plans by augmenting the latent reachability graph with task relevant proposition semantics and applying Büchi product search over the semantic graph and the Büchi automaton.

  3. The system can leverage a reusable motion substrate learned once from fixed task agnostic trajectory fragments, decoupling offline reachability learning from task time symbolic reasoning to provide a reusable proxy for dataset supported reachability.

  4. The improved system can ground state defined propositions on the learned graph using soft labels and anchor nodes, allowing new task space regions to be introduced at test time provided the offline graph contains sufficient support.

  5. The system can execute plans by employing a frozen low level policy conditioned on a receding direction that is modified by a guard aware steering bias to guide tracking away from anchors associated with currently forbidden labels.

Abstract

Linear Temporal Logic (LTL) provides a rigorous framework for specifying long-horizon robotic tasks, yet existing approaches face a trade-off: model-based synthesis relies on accurate labeled transition systems, whereas learning-based methods often require online interaction, task-specific rewards, or specification-conditioned training. We study LTL-specified robotic planning and execution in an offline, model-free setting, where the agent is given only fixed, task-agnostic trajectory fragments, with no dynamics model, task demonstrations, or online data collection. To address this setting, we propose SAGAS, a framework that combines the compositionality of symbolic synthesis with the data-driven reachability structure learned from offline trajectories. SAGAS first learns a reusable latent reachability graph and a frozen goal-conditioned executor from fragmented offline data. For each new LTL formula, it performs task-time semantic graph augmentation to ground state-defined propositions on the learned graph and applies Büchi product search to synthesize a cost-aware accepting prefix--suffix waypoint plan executed by the frozen executor. This separation of learning and planning enables zero-shot generalization to unseen LTL formulas and new predicates supported by the offline data, without task-specific rewards, additional data collection, or policy retraining. Experiments on LTL task suites constructed from OGBench locomotion domains show that SAGAS achieves higher success rates and lower execution costs than baselines on diverse unseen tasks, with further evaluation in OGBench Scene demonstrating its applicability to robotic manipulation.

Sources

Related papers