Lately, a growing number of people in the field feel that manipulation policy learning has hit some kind of bottleneck — or, to borrow a phrase, that we have entered a plateau. Plenty of startups and labs can put together convincing demos, but if you look closely, many of these models might overfit and generalize poorly — especially on precise, contact-rich tasks (as opposed to the "grasp a novel object and drop it in a box" demos that look impressive on video but ask very little of the policy). Under the hood, most models might be adapted from π 0.5-style architectures, or follow a vision-language backbone (e.g., Qwen-based encoder) bolted to a flow-matching action head.
Because the current VLA architecture has become stereotyped, people are beginning to branch out. Some are diversifying the output, asking the model to generate both future states and actions — the "world model," or what the field sometimes calls a dynamics model, in the spirit of the Dreamer-style approach. Others are pouring their effort into richer data, or into a more powerful encoder. Whatever the direction, the mood is unmistakable: the field is struggling to make a better model work, and some have reached a rather bitter conclusion — that policy learning, though it sits at the very center of robotics, is somehow just not sexy.
Is the current VLA model good enough? The short answer might be no. We ran a deliberately simple experiment: four blocks on a table, and the robot has to grasp the one indicated by a laser pointer. We collected ten demonstrations per block. The result was almost no spatial generalization — the diffusion-based policy essentially collapsed on this setup. (Full write-up on this experiment to follow.) That's a striking failure for a task a child would find trivial, and it's exactly the kind of result that never makes it into the demo reel.
What is the current stage? On scaling
Although the building blocks of robot learning are far from proven, many are betting on scaling up. So the honest question is: why should this unverified recipe scale at all? Nobody actually knows, and we won't until we have enough data, a big enough model, and — just as importantly — a good enough benchmark to measure progress against. These are the directions most people are working on right now, but under uncertainty.
That said, it is worth being skeptical about whether scaling up the data, the sensor modalities, and the attention blocks is really the answer for the current stage. In my humble opinion, the scaling laws that transformed language modeling do not copy over to robotics as cleanly as we'd like — and the reason may be simple: an LLM is trained autoregressively, with a cross-entropy objective, to model the distribution of the next token. This is the only verified scale-up method. However, today's popular "VLA" is trained on the current observation, with an MSE objective, to regress the next action chunk. These are fundamentally different animals. It's also worth naming a downstream cost of this design: because the policy emits an action chunk with no proper distribution over it, and because the VLA base model isn't yet powerful enough, reinforcement learning can't be applied efficiently. RL needs a stochastic policy with a tractable log-probability to push on; a deterministic MSE regressor simply doesn't give you one, and the likelihoods of diffusion and flow policies are expensive or intractable. The very thing that made LLMs improvable after pretraining — cheap, well-defined reward optimization — is missing here.
Robotics as a complex system
The whole of robot learning can be viewed through the interaction between an end effector and the physical world. The data that captures this interaction has two essential properties: physical trajectories and semantic meaning. From that data we do policy learning to acquire skills, and then we compose skills with planning and reasoning to solve real tasks.
This layered pipeline — hardware, interaction, data, skills, planning — is exactly what distinguishes robotics from most other areas of machine learning. It is a genuine complex system, and that carries an uncomfortable corollary: a bug can hide in any part of the process, not just in the model.
The headaches
With that framing in place, here are the headaches I keep running into.
The first headache: data. Robot data is expected to carry both useful physical trajectories and dense semantic labels. This is expensive — painfully so — but at least the path forward is visible. We have teleoperation, we have simulation, we have hand-held devices; none of it is easy, but none of it is a mystery either. Data is a headache we know how to keep chipping away at.
The final headache: planning and reasoning. Here the evidence is clearer and the problem more stubborn. We do have some genuinely good skills now — so why can't we solve real-world complex tasks? Almost any real task requires reasoning and dynamic planning (e.g., recover from failure, change behaviors/skills accordingly), not just reactive execution. Consider a deceptively simple question: can a policy start and terminate itself automatically? Does it know the preconditions and the effects of its own behavior? Today's policies are largely reactive and mute on these points. They have no explicit notion of "this skill applies when X holds and achieves Y" — the kind of precondition/effect reasoning that classical planning made central, and that our end-to-end models have quietly thrown away. Without it, long-horizon composition falls apart.
The most overlooked headache: action representation for policy learning. This, I think, is the deepest and least discussed of all — the overlooked link. We scale the data, we scale the model, we pretrain and we post-train, and everything looks methodologically correct. Yet at the very end of this elaborate pipeline, what does the model actually do? It "nearly" regresses a low-dimensional, unconstrained vector. It feels like the body of models and data keeps bulking up — but the point of leverage has collapsed.
Why is that a problem? Because the output space of robotic action is far larger and stranger than it appears. A language model predicts along essentially one dimension — the next token from a discrete vocabulary, leveraging all human data. An end-effector pose lives in six dimensions or more. The curse of dimensionality, in this specific geometric form, is another bitter lesson robotics people have yet to fully absorb.
So — is it sexy?
Maybe the demos have made manipulation policy learning look easy while hiding how hard it really is. But I'd argue the opposite of the bitter conclusion. The fact that data, planning, and action representation are all unsolved at the same time is exactly what makes this the most interesting problem in the field. The bitter lessons aren't a reason to look away. They're a map of where the real work is.
Recently, we proposed Action Map Policy — a step toward a new action representation and model paradigm for policy learning — and Retriever, a closed-loop system for planning and reasoning. They are firm steps toward confronting these headaches.