Research with the Playground

Code As Policy

Astra is waaay too slow. For practical problems in industry, robots simply need to move faster and cannot reason between steps. At the same time, an LLM can take its time to reason through the setup about what needs to be done, and how to handle the uniquenss of a task. This suggests a natural approach: use the LLM for careful reasoning while developing the code, then use that code for fast motion execution.

During setup, Astra could take its time to think, move the arm, and measure what happens. Then it could turn what it learns into a block of code that performs a task quickly and reliably. That’s what we’d love to explore with Code as Policy—and what could make it useful for real-world deployments.

Distillation from Astra

Astra is capable and can generalize to new situations—but it’s reasoning is waaay too slow. Learned robot policies are much faster, but they can fail on edge cases outside their training distribution. That’s where we think Astra could fit in well: using its reasoning to figure out a correction and generate intervention data for the faster policy to learn from, without a person having to manually intervene.

A good analogy here is how humans play basketball. We will often think through every motion at first of how to throw a ball. And after a few repitions it becomes automatic. We think astra can act as a reasoning poilcy, and the motions can be used to tune a smaller and faster robot policy.

An interesting thing is that we already have Astra trajectories in our public dataset. We’d love to see what researchers can learn from that data, and explore whether adding Astra-generated corrections can make a faster policy better over time.

Is the Sim-to-real gap a thing of the past?

Transferring robot behaviors from simulation to reality has long been difficult: policies can learn to rely on details of the simulator that don’t carry over, or get distracted by such details. We think Astra’s reasoning could help it focus on what matters for the task, ignore irrelevant differences.

We’d love to show that the characteristics that cause an LLM-driven policy to fail in sim are the same feaures that will cause failure in the real world. That would make simulation much more useful for developing and testing robot behaviors. The question is how far Astra’s generalization can take us, and where the gap remains.

Experiment with us

We’re building BluPe so more people can experiment with real robots and turn those experiments into more deployments. Tell us which direction interests you, the task you want to try, and what you need to get started. We’d love to discuss how the playground, our collected data, and a jointly designed experiment could support your work. Small experiments and negative results are welcome.

The $100 Ducky Bounty

We’re offering a $100 prize to the first person who stacks three blocks and places a ducky on top using the BluPe playground. We really just want a cool demo.

See the Ducky Bounty post on X.