Systematically Exploring the Capabilities of GPT-6 Astra as Embodied Policies

arXiv:2609.38537 · cs.RO · Submitted 2026-09-29 · Read on arXiv

Listen

Transcript

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

Rosa: Today's paper: "Systematically Exploring the Capabilities of GPT-6 Astra as Embodied Policies".

Dev: As a diligent researcher, I have meticulously analyzed both provided texts concerning GPT-6 Astra's capabilities as an embodied policy.

Rosa: First, who's behind it and why it matters.

Title and authors: Rosa: So we're diving into the paper "Systematically Exploring the Capabilities of GPT-six Astra as Embodied Policies," which looks at how this system works outside of a controlled lab setting. Dev, what are your initial thoughts on what this paper is really trying to show us about Astra?

Dev: Well, Rosa, it seems like the authors are really mapping out exactly where this embodied policy shines and where it hits its limits when we move from simulation to real-world execution. They're testing Astra across six different domains: gripper manipulation, dexterous manipulation, mobile manipulation, navigation, locomotion generation, and humanoid loco-manipulation.

Taro: I’m curious about the overall scope; does this paper just show that it can do a lot of things on paper or is it actually demonstrating usable control? I want to know if this is something we can trust for complex physical tasks.

Rosa: That’s exactly what we need to figure out, Taro. The authors are using a hybrid control approach where Astra either generates commands directly or cooperates with a learned policy, and they're looking at the success rates across those different modes to see which one performs better in practice.

Dev: Right, and the results show that the hybrid control mode generally outperforms direct control across several manipulation tasks, for example achieving a forty-eight percent success rate on the RoboDojo subset for gripper manipulation compared to just thirty-seven point eight one for direct control.

Taro: That's interesting because it confirms the value of having that policy guidance, but I wonder if that guidance is always helpful when things go wrong in the physical world? What happens when the world doesn't behave according to Astra’s assumptions?

Rosa: That’s a key question for me, Taro. The paper points out specific areas where reliability drops off sharply; for instance, in locomotion, dense motion-reference generation was completely unreliable—none of five sequential attempts on a single obstacle course reached the goal.

Dev: And that unreliability is exactly what worries me from an engineering standpoint. We’re seeing issues with generating useful action decisions versus actually producing the physical effect in those dense motion reference tasks, which is a major gap for real-time control.

Taro: If the system can't reliably generate motion references for locomotion, how does that affect its ability to handle unexpected obstacles or dynamic environments? Can it recover from those failures effectively?

Title and authors: Rosa: The paper shows that Astra still leads in navigation tasks, achieving a ninety-two percent success rate on RxR instruction following and an eighty-two percent success rate on HMthree dee object search, though they admit that this high performance comes with substantial detours.

Dev: That navigation strength is impressive, but those detours suggest it might not be the most efficient way to get around things in a tight space, which impacts the loop rate we need for fast physical response times.

Taro: So, while it’s good at finding the path, if that path requires too much searching or maneuvering around obstacles instead of direct movement, that’s a functional limitation we have to consider for autonomous operation.

Rosa: It seems the whole point of this paper is to give us a balanced view of Astra's current capabilities across these six areas, showing where the policy assistance helps and where it doesn't.

Dev: And looking at the control modes table in page one, you can see how Direct Control uses only Astra-generated commands with analytic control, whereas Hybrid Control combines that with a learned task policy or whole-body controller to review proposals or supply motion references.

Taro: That distinction between the two modes is important; it shows that simply having an LLM suggest something isn't enough, and you need that learned policy to actually execute the physical movement correctly.

Rosa: Exactly, and when we look at humanoid loco-manipulation, Astra does very well with thirteen out of thirty HumanoidBench tasks when using those pretrained whole-body controllers.

Dev: But that success is heavily dependent on those pre-trained controllers; if the controller itself isn't robust, Astra’s guidance might not save it from catastrophic failure during complex movements.

Taro: Speaking of failure modes, I’m thinking about what happens when the world misbehaves in a way that breaks the current policy assumptions; does Astra have an internal mechanism to detect that and adapt its strategy?

Rosa: The authors suggest ways to improve this, which is where the paper gets really forward-looking, focusing on making the system smarter about when to intervene versus when to step aside.

Dev: I saw some suggestions in the improvements section that call for implementing state-aware intervention logic specifically for dexterous manipulation, meaning Astra needs a way to verify physical preconditions before suggesting a change improvement two.

Title and authors: Taro: That makes sense; it means the AI can't just guess a fix and try it; it has to check if the grasp is actually secure or if the finger contacts are plausible before taking action.

Rosa: And that leads us into the computational side, because we can’t ignore how much processing power this demands for real-world use.

Dev: Right, and the paper shows that inference latency is a big issue; for a thirty-second locomotion run, physics pausing required two hundred fifty model calls averaging about forty seconds each.

Taro: That latency sounds prohibitive for fast, reactive control loops; if you need a response in milliseconds for a physical interaction, waiting forty seconds just to get feedback isn't feasible.

Rosa: It really highlights the trade-off between getting high-level reasoning from Astra and maintaining the low latency required for real-time physical movement.

Dev: And token consumption is another practical hurdle; the RoboDojo Hybrid setup reached six hundred twenty-four point eight million tokens, which shows the significant computational cost associated with policy assistance even when learned policies are doing most of the heavy lifting.

Taro: So, to summarize this section, it’s clear that while Astra is a powerful reasoning engine for guiding robot actions, the practical deployment is constrained by reliability in dense motion generation and significant computational demands for real-time operation.

Rosa: It gives us a very concrete picture of what Astra can do right now across manipulation and locomotion tasks, but also clearly points out the areas where we need to focus our improvements.

Dev: And those suggested improvements are critical; shifting from direct command generation to hybrid policy review, for example, seems like the most promising path toward achieving more robust control improvement one.

Taro: I agree with Dev; making Astra act as a reviewer rather than just a raw command generator seems like it addresses the issue of reliable physical control directly.

Rosa: So we’ve covered where Astra excels, where it struggles physically, and what the authors themselves suggest we need to build next.

Dev: Before we wrap up this discussion on "Systematically Exploring the Capabilities of GPT-six Astra as Embodied Policies," I want to mention how these findings connect with other work, like OGPO, which is focused on one-step generation for real-time control background context.

Taro: That’s a good point; if we can figure out how to manage the latency issue mentioned in this paper by using techniques from OGPO or FlowDPG, we might bridge that gap between high-level reasoning and rapid physical execution.

Title and authors: Rosa: It certainly feels like the path forward involves moving away from just generating raw commands and toward a more integrated, policy-guided system.

Dev: Exactly, we need that structure where Astra proposes targets or modifies proposals while a frozen controller handles the execution of the bulk of the motion improvement one.

Taro: I’m just thinking about the long-term vision; if we can implement those state-aware intervention logics, we open up possibilities for truly autonomous systems to handle unpredictable physical situations without constant human oversight.

Rosa: That sounds like a huge step toward making these robots genuinely useful in unstructured environments, which is what field robotics is all about.

Dev: It’s a big undertaking, though, because of the token consumption and latency concerns we discussed earlier; we need efficient methods to make this kind of reasoning accessible in real-time applications improvement three.

Taro: So, the paper gives us a solid foundation on what Astra can do as an embodied policy today while clearly outlining the next set of challenges that researchers need to tackle to get it ready for true autonomy.

Rosa: Indeed, "Systematically Exploring the Capabilities of GPT-six Astra as Embodied Policies" has given us a very detailed roadmap for where we are in this research area.

Dev: It’s a comprehensive look at the capabilities and limitations, showing us that hybrid control is currently the most effective way to leverage this kind of model for manipulation tasks.

Taro: We’re excited about what these authors have laid out because it moves the conversation from just capability demonstration to actually defining a practical system architecture that can handle real-world surprises improvement four.

Rosa: Absolutely, and I think the implications here are that we need to start designing systems with this kind of policy guidance in mind, not just as a research experiment but as a core component.

Dev: So, to wrap up our thoughts on this paper, we see Astra as a strong reasoning engine that needs better physical execution coupling and more efficient inference methods before it can move into truly high-frequency applications.

Taro: We're really looking forward to seeing how the community implements those suggested changes, especially around handling unexpected physical deviations in navigation and dexterity.

Rosa: And that’s where we’ll be tuning in next time as we discuss these developments further.

The paper's summary: Rosa: So, we've just been looking at the raw data from that Astra paper, and now we’re going to talk about what all that means for us in the real world, right?

Dev: Exactly. The core summary shows that Astra isn't just a clever idea; it actually performs well in certain manipulation areas like gripper control when you use hybrid control, but it totally struggles with reliably generating motion references for locomotion.

Rosa: It really paints a picture of where the AI is strong—cooperating with learned policies—and where it's still weak, especially when things get physically messy or require precise continuous control, like in-hand rotation.

Dev: And that reliability issue is huge for us because if the motion generation isn't dependable, you can't trust it for high-frequency control loops; we’re talking about latency and physical effects not matching up.

Taro: But I see the potential in its reasoning capabilities, especially how it handles navigation and instruction following with that high success rate on RxR tasks, even though those paths are a bit long.

Rosa: That’s where we see the promise for long-horizon planning; Astra seems to be excellent at figuring out the high-level sequence of steps needed to reach a goal, even if the execution needs refinement.

Dev: The token consumption figures are also pretty alarming, reaching over six hundred million tokens in one setup, which means that even when it’s helping with learned policies, the computational cost for that kind of policy assistance is substantial.

Taro: So the implication is that we can use this kind of model as a high-level planner or a correction layer, but we absolutely need to build in those safeguards we discussed—like state-aware intervention logic—to prevent it from making dangerous assumptions when the physical world throws us a curveball.

Rosa: Precisely; this paper gives us a clear roadmap for what’s next, showing that the path forward isn't just about bigger models but about better architectural designs that couple high-level reasoning with reliable physical execution.

Dev: I agree; we need to focus on those hybrid control methods where Astra reviews proposals instead of just sending raw commands, because that seems to be the most effective way to get better success rates in manipulation tasks.

Taro: It really shows that the future isn't just about brute force reasoning; it’s about making sure the AI knows exactly when to yield control back to a more specialized physical controller.

Rosa: And that's what we need to keep watching—how these researchers integrate those suggestions, like dynamic resource management and structured task decomposition, into actual deployable systems.

Dev: Right, because if you can tackle the latency issue by compacting observations or switching control modes dynamically when things get tight, then these embodied policies could actually become viable for real-time applications.

The paper's improvements: Rosa: So, we’ve seen where Astra is currently falling short in its physical execution, and now we’re looking at the suggestions from the authors on how to make it more robust for real-world use, right?

Dev: The paper points out that a big step forward would be shifting from just direct command generation to a hybrid policy review system where Astra proposes targets and a learned controller handles the heavy lifting.

Rosa: That makes sense; it addresses the core issue we saw with reliability by having Astra act as an intelligent editor rather than just a raw instruction generator.

Dev: Exactly, and I think implementing state-aware intervention logic for dexterous manipulation is critical because it means Astra has to verify physical preconditions before suggesting a change, which should reduce those catastrophic failures we’ve seen in contact changes.

Taro: I like that idea of verification; it suggests the AI needs a way to check if the proposed correction actually solves the physical problem before committing to an action, which is something we need for true autonomy.

Rosa: And on the computational side, the authors suggest developing dynamic resource management strategies to handle those huge inference latencies that plague locomotion tasks when they run in real-time.

Dev: That latency issue is a major practical hurdle; if a thirty-second run takes forty seconds to process every few steps, it just won't work for fast physical interaction loops, so compacting observations or switching to sparse targets under time pressure seems like the right engineering move.

Taro: If we can solve the latency problem by making the system smarter about when to pause and when to rely on pre-computed motion references, that opens up possibilities for much faster, more responsive physical actions.

Rosa: We also see a recommendation for developing task-specific policy adaptation through experience refinement, which means Astra should keep a memory of its successes and failures so it can adjust its high-level instructions without needing a full model retraining.

Dev: That external memory mechanism is smart; it allows the system to learn from novel environments simply by revising its guidance notes based on what actually worked in practice, instead of having to retrain the entire policy.

Taro: So it’s moving toward a system that builds its own long-term strategy based on accumulated experience in a way that doesn't require constant human intervention or massive retraining efforts.

Rosa: Exactly; this points toward a system that can actually adapt to the messy reality of physical tasks over time, which is what field robotics demands.

Dev: It’s exciting because it tackles the token consumption problem by making the interaction more efficient, though we still have to find ways to keep that reasoning accessible within those tight latency windows.

Conclusion: Rosa: We've covered a lot about GPT-six Astra as an embodied policy, and now we need to wrap up by looking at what this whole study means for the field.

Dev: Basically, Astra shows promise in certain manipulation tasks through hybrid control, but its real-world applicability is currently limited by issues with motion reference generation and significant computational demands for low latency.

Taro: I think the biggest takeaway is that we have a powerful reasoning engine that needs much better coupling with specialized physical controllers to handle the unpredictability of the world.

Rosa: That’s right; this paper, "Systematically Exploring the Capabilities of GPT-six Astra as Embodied Policies," really shows us that simply having a smart brain isn't enough if you don't nail the execution layer.

Dev: I agree; we need those architectural improvements—like state-aware intervention and dynamic resource management—before this kind of policy assistance can be trusted in time-critical applications.

Taro: It really highlights the next big challenge for autonomy: moving from high-level planning to robust, reliable physical control that doesn't break when things get unexpected.

Rosa: That’s a huge implication for field robotics; if we can solve these coupling issues, Astra could become a really useful tool in unstructured environments instead of just a lab experiment.

Dev: I hope so; but until we address the latency and physical effect reliability, deploying this kind of policy-assisted system in anything requiring quick physical reaction times seems risky.

Taro: We're definitely excited about what the authors have shown, especially how they outlined those specific improvement areas for task adaptation and structured decomposition.

Rosa: I think that roadmap is incredibly valuable because it tells us exactly where the research needs to focus next to get Astra out into the real world reliably.

Dev: It’s a good summary of its current state; we need more work on making those policy suggestions translate directly into stable, low-latency physical motion.

Taro: I look forward to seeing how other teams tackle those adaptation methods, because that's where you get true learning in complex scenarios.

Galbot Team

cs.RO

Submitted: 2026-09-29

Updated: 2026-09-29

Code: https://github.com/jessicayin/tactile_skin_model

License: http://creativecommons.org/licenses/by/4.0/

Importance score: 79/100

The gist: As a diligent researcher, I have meticulously analyzed both provided texts concerning GPT-6 Astra's capabilities as an embodied policy.

Key concepts

Embodied Policy: This refers to an AI system like GPT-6 Astra that takes high-level goals and translates them into specific, physical actions for a robot. It means the AI isn't just planning in text; it's directly controlling a physical body to perform tasks like grasping or walking.
Hybrid Control: This is a method where GPT-6 Astra works alongside another learned policy or controller. Instead of Astra doing everything, it interacts with an existing system—either by suggesting changes to its plan or by providing detailed motion references that help a frozen controller execute the movement more accurately.
Dense Motion Reference Generation: This is the ability of the AI to create a continuous stream of precise movement instructions for a robot. In this study, Astra failed at this; it could not reliably generate these detailed, step-by-step physical commands needed for smooth, obstacle-avoiding locomotion.
Locomotion Reliability: This measures how consistently the AI can successfully move a robot through challenging environments without failing. The paper found that Astra's ability to generate movement plans is inconsistent in this area, meaning its proposed actions often lead to failure when physically executed.

Terminology

Benchmark — 23× in this paper · explained in 2 episodes
Verification — 23× in this paper · explained in 2 episodes
Adaptation — 14× in this paper · explained in 1 episode
Cooperation — 9× in this paper · explained in 2 episodes
Actor — 8× in this paper · explained in 3 episodes
Calibration — 8× in this paper · explained in 7 episodes
Alignment — 5× in this paper · explained in 1 episode
Core — 4× in this paper · explained in 2 episodes
Grounding — 3× in this paper · explained in 3 episodes
Provenance — 3× in this paper · explained in 3 episodes
European Conference on Computer Vision — 2× in this paper
Failure Modes — 2× in this paper · explained in 3 episodes
Foundation Model — 2× in this paper · explained in 3 episodes
IEEE International Conference on Robotics and Automation — 2× in this paper
Trace — 2× in this paper · explained in 2 episodes
World Model — 2× in this paper · explained in 7 episodes
Affordance — 1× in this paper · explained in 1 episode
Aggregation — 1× in this paper · explained in 1 episode
Benchmarking — 1× in this paper · explained in 3 episodes
Closed-Loop Control — 1× in this paper · explained in 3 episodes
Consistency — 1× in this paper · explained in 3 episodes
Deep Reinforcement Learning — 1× in this paper · explained in 2 episodes
Embodied AI — 1× in this paper · explained in 2 episodes
Entanglement — 1× in this paper · explained in 3 episodes
Fidelity — 1× in this paper · explained in 2 episodes
Generalization — 1× in this paper · explained in 13 episodes
Hybrid Approach — 1× in this paper · explained in 4 episodes
Hybrid System — 1× in this paper · explained in 2 episodes
Regularization — 1× in this paper · explained in 3 episodes
Reinforcement Learning — 1× in this paper · explained in 4 episodes
Task Decomposition — 1× in this paper · explained in 2 episodes
Transformer — 1× in this paper · explained in 2 episodes
Unified Framework — 1× in this paper · explained in 5 episodes
Zero-Shot Transfer — 1× in this paper · explained in 4 episodes

Summary

As a diligent researcher, I have meticulously analyzed both provided texts concerning GPT-6 Astra's capabilities as an embodied policy. The following synthesis integrates the findings from both sources into a comprehensive, detailed summary suitable for describing this research paper.

This research systematically explores the capabilities of GPT-6 Astra as a general-purpose, embodied policy capable of generating numerical robot actions, extending its utility beyond high-level planning into complex physical control domains. The evaluation framework assesses Astra's performance across six critical manipulation and locomotion tasks: gripper manipulation, dexterous manipulation, mobile manipulation, navigation, locomotion (dense motion reference generation), and humanoid loco-manipulation.

Astra demonstrates significant strengths in certain areas while exhibiting notable weaknesses in others:

Manipulation Strengths: Astra shows promising performance in task-oriented manipulation. In gripper manipulation, the hybrid control approach achieved a 48% success rate on the RoboDojo subset. In dexterous manipulation, hybrid control yielded a 50% success rate across ten experience-guided DexJoCo trials, significantly outperforming baseline methods (pi 0.5 at 44.2% and Direct control at 16.6%).
Navigation Prowess: Astra leads local comparisons in navigation tasks, achieving a 92% success rate on RxR instruction following and an 82% success rate on HM3D object search. However, this high performance comes with a caveat: the search incurs substantial detours.
Humanoid Locomotion: Astra excels in humanoid loco-manipulation, exceeding baseline methods on 13 out of 30 HumanoidBench tasks when utilizing pretrained whole-body controllers.
Mobile Manipulation Weakness: Performance in mobile manipulation is comparatively lower, with hybrid control reaching only 38.7% success on the RoboCasa365 subset.
Locomotion Reliability Issue: A critical failure point identified is locomotion. Dense motion-reference generation proved unreliable; none of five sequential attempts on a single obstacle course reached the goal, indicating a gap between generating useful action decisions and reliably producing physical effects in this domain.

The study rigorously compares two primary control paradigms:

Direct Control: This mode utilizes Astra-generated commands executed via analytic control.
Hybrid Control: This mode involves Astra interacting with a learned task policy or whole-body controller—either by reviewing/modifying the proposal or by supplying dense motion references to frozen controllers.

Aggregate performance metrics strongly favor the Hybrid approach:

RoboDojo Aggregate: Hybrid achieved a mean score of 62.60, substantially higher than Direct control's mean score of 37.81.
Dexterous Manipulation: Hybrid scored a mean of 61.6, compared to 44.2 for pi 0.5 and 16.6 for Direct control, highlighting the benefit of policy guidance in complex manipulation tasks.

The conclusion drawn is that while Astra excels at preparing conditions or correcting targets (cooperating with learned policies), it struggles when the task demands precise, continuous physical control (e.g., in-hand rotation). Effective cooperation necessitates Astra recognizing precisely when to intervene and when to yield control back to the policy.

Practical deployment is further constrained by computational demands:

Inference Latency: For a 30-second locomotion run, physics pausing during inference required 250 model calls, with each call averaging 39.86 seconds.
Token Consumption: The study highlights substantial token usage across studies. For the RoboDojo Hybrid setup, the total consumption reached 624.8 million tokens (including cached input). This underscores the significant computational cost associated with policy assistance, even when learned policies supply most of the physical actions.

The research details specific protocols for Astra's operation:

Inference Protocol: Every direct-control rollout mandates using GPT-6 Astra via the Responses API with a fixed developer prompt defining the robot, task conventions, observation fields, action contract, and the requirement to preserve the grasp while making progress toward object-level targets.
Observation Context: At every decision point, Astra receives a rich context: three synchronized RGB views, named joint positions/velocities, current joint target/object pose/velocity, target state, and the host’s contact representation. Allegro supplies tactile readings (16 signed three-axis) or scalar values (48), alongside task-native position and rotation errors.

Improvements for AI systems

Here are specific improvements for AI systems based on the findings of this paper, categorized by the domain where they provide maximum benefit:

)1. Shift from Direct Command Generation to Hybrid Policy Review for Robust Control

The core finding is that useful task decisions are distinct from reliable physical control.

Instead of relying solely on a generative model (like GPT-6 Astra) to produce raw robot commands (Direct Control), implement a hybrid architecture where the LLM acts as a high-level reasoning and correction layer, while specialized, learned policies or whole-body controllers handle low-level execution.
The improved system should function as follows:

Astra proposes numerical targets or modifies an existing policy's action proposal.

A frozen, task-specific RL policy (or a whole-body controller) executes the bulk of the motion based on this proposal.

Astra reviews the resulting feedback and provides targeted corrections (e.g., correcting contact geometry or adjusting targets for subsequent steps).

This hybrid approach is expected to increase success rates in manipulation tasks (e.g., RoboDojo) by leveraging the coordination learned by RL policies while retaining the LLM's ability to handle complex, non-linear task goals and environmental changes.

)2. Implement State-Aware Intervention Logic for Dexterous Manipulation

The paper shows that Astra’s interventions are highly targeted but often fail when a physical precondition is missed (e.g., failing to secure a grasp).

Develop an intervention system that prioritizes verifying critical physical states before suggesting action changes.
Specifically, the system should be trained to recognize failure modes identified in Figure 3 (e.g., missed grasps or dropped objects) and only intervene when the proposed correction is physically plausible given the current state and task goals.
The AI's decision loop must explicitly incorporate a verification step (as seen in Section 4.2) to determine if an intervention actually resolves the physical precondition (e.g., confirming object support before proceeding with release).
This will reduce catastrophic failures during contact changes and improve the reliability of tasks requiring sustained object motion and precise finger coordination.

)3. Integrate Dynamic Resource Management for Inference Latency

The paper highlights that inference latency (especially in locomotion, where one 30-second run requires 250 model calls averaging nearly 40 seconds each) is a major practical constraint.

Implement a Context Compaction and Required Observation strategy: Instead of feeding the entire history into the LLM for every step, develop mechanisms to summarize past successful actions or critical state transitions into compact representations before re-querying Astra.
For time-critical tasks (like locomotion), the system should dynamically switch from full review to sparse body targets or rely on pre-computed motion references when latency exceeds a set threshold.
This will make embodied policies viable for real-time, high-frequency control loops where physical feedback demands rapid response times.

)4. Develop Task-Specific Policy Adaptation via Experience Refinement

The study on Humanoid Loco-Manipulation (Section 8.4) demonstrates that Astra can refine its guidance by revising written instructions based on outcomes without changing model weights—a form of in-context learning for guidance.

For complex, long-horizon tasks (like navigation or multi-stage manipulation), the system should maintain a dynamic Guidance Memory that stores successful and failed sequences.
After every major failure, Astra should generate a revised instruction set (notes) to be used in subsequent attempts, effectively adapting its high-level planning strategy based on accumulated experience without requiring costly full model retraining.
This will allow the system to improve performance over time in novel environments or task variations by learning how to better structure its prompts and subgoals.

)5. Utilize Structured Task Decomposition for Complex Behaviors

The success of Hybrid control on tasks like Fold Clothes or Put Bottles Into Dustbin suggests that Astra benefits from breaking down complex goals into manageable sub-subgoals (as seen in Table 22).

Improve the system's ability to decompose high-level instructions into a sequence of verifiable, low-level subgoals.
The AI should be prompted to generate verification checkpoints at every stage of execution, allowing it to pause and verify if the current physical state satisfies the geometric and contact constraints required by that specific subgoal before proceeding.
This structured approach will lead to more reliable task completion, as success is verified incrementally rather than relying on a single, long-horizon prediction.

Abstract

GPT-6 Astra exhibits a remarkable ability to generate numerical robot actions, extending its role beyond high-level planning. To assess Astra's capabilities as general-purpose embodied policies, we conduct comprehensive evaluations across six domains, examining direct control, cooperation with learned policies, and feedback-driven adaptation. In gripper manipulation, Astra can correct task targets and prepare contact conditions for subsequent policy execution; hybrid control with π0.5 achieves 48% success on the evaluated RoboDojo subset. In dexterous manipulation, hybrid control achieves 50% success in ten experience-guided DexJoCo trials, while direct in-hand control struggles to coordinate finger contacts. In mobile manipulation, hybrid control reaches 38.7% success on the evaluated RoboCasa365. In navigation, Astra leads our local comparisons, reaching 92% success on RxR instruction following and 82% on HM3D object search, although search incurs substantial detours. In locomotion, dense motion-reference generation remains unreliable: none of five sequential attempts on a single obstacle course reaches the goal, despite improvements in stability and forward progress. In humanoid loco-manipulation, Astra exceeds baseline methods on 13 of 30 HumanoidBench tasks with pretrained whole-body controllers. These findings reveal a gap between useful task decisions and reliable physical control. Inference latency further constrains practical control: across 50 RoboDojo instances per condition, policy-assisted and direct control consume 624.8 million and 1.132 billion tokens. A 30-second locomotion run requires 250 model calls averaging 39.86 seconds each, with physics paused during inference.