Thirty robots stood outside Poland's Digital Affairs Ministry last week holding signs and reading demands through speakers. The organizer runs a recruitment firm. The robots were built by a company called Delta Robots, and the whole thing doubled as a product demo. Daniel's prompt this week starts from that image, the world getting weird faster than the discourse can keep up, and asks a hard technical question underneath it. When you see one of these machines talking and moving and reacting, what's actually running inside it? Is there one model doing everything, reasoning and speech and facial expression and motor control all at once, or is the thing a stack of separate systems wired together by software glue? And is the field trying to converge on a single unified model for embodied AI, or is that the wrong goal entirely?
The short answer is that right now, almost everything you see is a stack. Separate models, separate components, connected by what the people building them call a harness or middleware. And the field is split on whether that's a temporary condition or the correct architecture.
So the talking robot that makes eye contact and picks up your coffee cup is actually a committee.
A committee with a project manager. And the project manager is usually a vision language model. That's the piece that's changed most dramatically in the past two years. It looks at the scene, listens to what you said, reasons about what to do, and then decides which specialized tool to call. The tool might be a speech module, a navigation policy, or a manipulation controller. The reasoning model never touches the motors directly.
Which is not what people assume when they see the robot move smoothly and answer a question in the same interaction. The coherence is an illusion produced by orchestration.
That's exactly the right way to put it. And the clearest worked example I've seen recently is a system called Ludi, from a company called Ludo Robotics. They took a Unitree G1 humanoid, which is one of those small Chinese humanoids you see in the videos, and put a fine-tuned Qwen vision language model in charge. The model has a fixed tool set: say, navigate, reach, call the manipulation policy, wait. One action per turn. The actual manipulation, the hand closing around the object, is done by a separate vision language action model, a VLA, fine-tuned from NVIDIA's GR00T foundation model.
So the brain says pick up the cup, and then hands the job to a specialist that only knows how to move muscles.
Right. And the Ludi paper says this explicitly. They chose an agentic architecture because natural interaction requires coordinating specialized capabilities over time. They didn't try to train one network to do everything.
What's the latency on that handoff? Because I'd think that's where the whole thing falls apart. A human reaches for a cup while talking, and the motion is continuous. If your reasoning model has to issue a tool call and wait for the result, the robot's going to look like it's buffering.
The VLA runs at thirty hertz and executes about a second of motion per chunk. The speech transcription averages around ninety-five milliseconds. So there's a rhythm to it. The reasoning model thinks, delegates a one-second motion chunk, thinks again. It works, but it's not seamless in the way a person is seamless.
A one-second action horizon is basically a robot that lives moment to moment. No long-term physical plan, just a sequence of short commitments.
And that's the state of the art in deployed systems. The Ludi authors are quite honest about this. They say the integration is operational rather than fully learned. Speech, memory, navigation, manipulation all live in separate components. The system does not learn a unified representation of you, the room, and its own body at the same time.
It's the difference between a system that coordinates parts and a system that understands itself as one thing.
And it's the central tension in the field right now. You've got one camp saying modular is correct, don't fight it, just make the orchestration better. And another camp saying no, the whole point is to train a single foundation model that grounds language and action in one shared representation. Ludo's own roadmap says their next version, Ludi one point oh, is meant to be a foundation model for robots and people. So even the people who built the modular system think the endgame is unification.
But there's a counterargument. You mentioned a paper that says scaling one model alone can't deliver reliable autonomy. What's their case?
The InteractGen work, which argues for multi-agent decomposition. Their position is that a single model trying to handle perception, reasoning, social interaction, and physical control all at once ends up mediocre at all of them. Better to have specialized agents that each do one thing well and coordinate through a shared interface. It's the microservices argument applied to robot brains.
Which is funny, because software architecture already had this fight. Monoliths versus services. The answer turned out to be it depends on what you're building and how fast it needs to change.
And robotics has the added constraint of physics. A web service can take an extra hundred milliseconds and nobody notices. A robot reaching for a glass cannot. That's why Figure's Helix architecture is interesting. They split the problem by timescale. System two is a seven billion parameter vision language model running at seven to nine hertz. It handles scene understanding and language. System one is an eighty million parameter visuomotor policy running at two hundred hertz, conditioned on what system two is thinking. And then Helix oh two added System zero, a kilohertz neural prior trained on over a thousand hours of human motion data.
A kilohertz. That's a thousand decisions per second. What does a body need to decide a thousand times a second?
Balance, mostly. Weight distribution, foot placement, the tiny corrections that keep you upright. That's not reasoning. That's reflex. And the interesting detail is that System zero replaced roughly a hundred and nine thousand lines of hand-written C plus plus. The old way was engineers coding every balance response explicitly. The new way is a neural network that learned it from watching humans move.
So you've got three layers. A slow thinker, a fast mover, and a reflex system. And they're all separate networks. The slow one doesn't know how to balance. The fast one doesn't know what a cup is.
And that's the architecture that makes the demos work. But it's still a stack. When Figure's robot has a conversation while walking, you're watching at least three models running in parallel, plus whatever speech system is bolted on the side.
Which brings us to the facial expression part of Daniel's question. Because that's the thing humans read most. If the robot's face is wrong, the whole interaction feels wrong. Is anyone actually training a model to control facial expressions based on visual cues?
Not in a unified way, as far as I can tell. The systems I've seen are either screen-based faces, literally an LCD panel showing an animated face on a two-degree-of-freedom head, or they're mechanical heads with silicone skin driven by separate components. One prototype I came across uses a face detection model, a face recognition model, a language model for dialogue, and a speech model for voice, all as separate modules. The expression control is not learned end-to-end with the reasoning.
So the robot's face and the robot's brain are not in the same model. The face is a peripheral.
Like a monitor. It displays the output of the social layer, but it doesn't understand what it's displaying. Which is why you get that uncanny mismatch sometimes, where the robot says something warm and its face is doing something slightly off.
The face is the last mile of the illusion and it's the least integrated part.
And nobody's solved it. I found no paper that unifies facial expression control with reasoning and manipulation in one learned model. It's all separate components. The closest thing to unification is happening at the level of body control and reasoning, not the social surface.
Let's talk about Google's entry, because they've been explicit about where they sit in this debate. Gemini Robotics ER two.
That's the embodied reasoning model they launched at the end of July. And the positioning is interesting. It's a vision language model that reasons, talks to humans, plans multi-step tasks, and orchestrates VLA models as tools. But it does not drive motors. Google's own guidance says it should sit above, not replace, robot controllers.
So Google is betting that the reasoning layer stays separate from the control layer. The brain tells the body what to do, but the body has its own nervous system.
For now. And that's a meaningful statement from a company with the resources to try the unified approach if they thought it was ready. They're saying the orchestration model is the product, not the whole robot brain.
But there's a competing vision. You mentioned Pelican Unify and ACE Brain. What are those actually doing?
Pelican Unify uses a single vision language model as both the understanding and reasoning module, and then a unified future generator that jointly produces future videos and actions in one denoising process. The claim is that unification doesn't mean compromise, that you can have one model predict what will happen and what to do about it at the same time. ACE Brain goes further. A single eight billion parameter backbone handling spatial perception, decision making, embodied interaction, and self-monitoring. No separate modules.
Eight billion parameters doing everything. That's smaller than a lot of language models that can barely write a coherent email.
Which tells you how much of the difficulty in robotics is not about raw parameter count. It's about the training data and the architecture. An eight billion parameter model trained on the right embodied data can apparently do a lot. Whether it can do it reliably is another question.
And reliability is where the skepticism lives. There was a deep dive a couple weeks ago that pointed out the best manipulation models solve about half of the tasks in a benchmark called the Humanoid Olympics, and take four to ten times longer than a human. Half success rate, four to ten times slower. That's a research result, not a product.
Physical Intelligence, which is one of the better-funded robotics companies, solved ten of fifteen tasks but only succeeded fifty-two percent of the time. And one of those tasks was turning a sock inside out, which took a hundred and seventy-six demonstrations, about eight hours of human data, to learn. A sock.
The sock is the perfect counterpoint to the robot that runs a hundred meters in eight point eight six seconds. Sprinting in a straight line on a flat track is a dynamics problem. Turning a sock inside out is a manipulation problem. And the manipulation problem is harder.
Theophile Gervet from Genesis AI said manipulation is the core unsolved problem that unlocks ninety percent of the value. And Brian Machado from Bracket Bot said dancing is easier than work because the floor doesn't do anything. The floor just sits there. A sock deforms. A cable flops. A bag of groceries shifts.
So the spectacle demos, the robots boxing and doing backflips and running, are solving the wrong problem. They're impressive because they're visible, but the thing that would actually make a robot useful in a warehouse or a home is the boring, squishy, unpredictable stuff.
Karol Hausman from Physical Intelligence made this point directly. He said people are not very good at judging progress in robotics. Robots do acrobatics that are very difficult for a human, and people think that means they're close to doing everything. But picking up a Coke can turns out to be very, very difficult.
A Coke can is rigid, mostly. It's not even a sock. And it's still hard.
The Galbot warehouse robot, which is one of the better deployment stories, takes about forty seconds per item placed. A human warehouse worker does that in a few seconds. And the Unitree G1, the same robot Ludi uses, overheats after five to fifteen minutes of work and needs ten minutes of rest.
So the robot protest in Warsaw is a nice metaphor, because the robots were reading pre-loaded chants. They weren't spontaneously deciding to protest. The organizer loaded the text, the robots performed. That's the state of the technology. Impressive surface, scripted underneath.
Euronews made exactly that point. Whether a machine reading out a pre-loaded chant counts as protesting at all. The answer is obviously no, but the image works. And the Polish digital affairs minister said uncontrolled AI models in evolving humanoids are a major problem, which is a reasonable thing for a government minister to say when thirty robots are standing outside his building.
The robots were warning about job losses, and the robots were built by the industry that would benefit from the warning. It's a product demo wearing a protest sign.
The organizer runs a recruitment firm. The robots were built by a robotics company. Both based in the same city in Poland. It's not exactly a grassroots movement.
So Daniel's question about whether we're heading toward one model or a stack. The honest answer is that the field is actively split. The deployed systems are modular. The research frontier is pushing toward unification. And the people building the modular systems say the endgame is unified, while other people say unification is a mistake.
And there's a third position emerging, which is that the question itself might be wrong. That what matters is not whether it's one model or many, but whether the interfaces between the components are learned or hand-coded. Ludi's authors said the integration is operational rather than fully learned. That's the real gap. A unified model learns the interfaces. A modular system has engineers writing glue code.
So the trajectory isn't necessarily one model to rule them all. It's more like the glue gets smarter. The boundaries between components become learned rather than specified.
And that's a more interesting way to think about it. Because a single model that does everything is a huge engineering risk. If it fails, you don't know which part failed. But a modular system with learned interfaces gives you the best of both. You can debug the parts, but the parts learn to talk to each other.
The nervous system analogy is hard to avoid. You have a brain, a spinal cord, and reflexes. They're different systems, but they're not glued together with code. They co-evolved. The interface is part of the design.
And that's what System zero in Helix is doing at the reflex level. The neural prior replaced hand-written code. The interface between balance and motion is now learned. That's a step toward the nervous system model, even if the high-level reasoning is still separate.
What about the world model piece? Daniel mentioned it, and it feels like the missing middle. A world model predicts what happens next in the environment. How does that fit into the stack?
World models are the planning layer. A language model predicts the next token. A world model predicts the next state of the world, the next video frame, the next depth map. TesserAct, for example, learns four-dimensional embodied world models that predict RGB, depth, and normal video. The idea is that if you can predict what will happen, you can plan. You can imagine the consequence of an action before you take it.
So the reasoning model says I want to pick up the cup, the world model says if I reach this way, the cup will tip, and the VLA says here are the motor commands for the reach that doesn't tip.
In principle. In practice, world models are still mostly research. They're not in the deployed stacks yet. The simulators are doing a lot of that work right now. You train the robot in simulation, where the world model is just the physics engine.
Which is a cheat, but a useful one. The physics engine is a perfect world model for the simulated world. The problem is transferring that to the real world where nothing is perfect.
And that transfer gap is why the real-world reliability numbers are so low. The robot learned to pick up the cup in a simulation where the cup is always the same, the lighting is consistent, the surface is flat. Then you put it in a kitchen and the cup is wet and the counter is cluttered and the light is from a window.
The sock problem again. Simulation can't easily model a sock.
Deformable objects are the frontier. Rigid objects are solved enough to demo. Soft objects are still research.
Let me ask you the question Daniel's really getting at. If I walk up to a talking robot today and have a conversation, what am I actually interacting with? Walk me through the stack.
You're talking to a speech recognition system that transcribes your voice. That text goes to a language model, probably a vision language model that also sees you through cameras. The language model decides what to say and what to do. If it's just conversation, it sends text to a speech synthesis system. If you ask it to hand you something, it calls a manipulation policy. If it needs to walk, it calls a navigation policy. The facial expression, if there is one, is driven by a separate display system. All of these are connected by software that someone wrote to make them work together.
So the robot that seems to be one coherent being is actually five or six different AI systems in a trench coat.
And the trench coat is the harness. The orchestration layer. That's the thing that makes it feel coherent. When it works, you don't notice the seams. When it doesn't, you get the robot that pauses mid-sentence and then does something slightly wrong.
The pause is the model handoff. The robot is literally waiting for the next tool to respond.
That's the tell. If you watch these demos carefully, you can see the seams. The speech is smooth, the motion is smooth, but the transition between them has a beat. A human doesn't have that beat.
The unified model people are trying to eliminate the beat. Make the whole thing one continuous process.
The modular people are saying the beat is fine, just make it shorter. A hundred milliseconds of orchestration overhead is not the bottleneck. The bottleneck is the manipulation reliability.
Which is a fair point. If the robot drops the cup half the time, shaving fifty milliseconds off the handoff doesn't matter.
The reliability gap is the real story. Everything else is architecture philosophy. The reason you don't see these robots in homes or warehouses at scale is not because the models are too slow or too modular. It's because they fail too often at the physical part.
Rodney Brooks, who's been doing robotics longer than most of these companies have existed, said he's rarely seen a new technology less than ten years out from a lab demo make it into a deployed robot. Ten years from lab demo to deployment.
The demos are getting better faster than the deployment. The gap is widening, not narrowing. The hundred meter sprint robot is a demo. The warehouse robot that places forty items per second is a deployment. They're different worlds.
The sprint robot ran eight point eight six seconds. Usain Bolt's world record is nine point five nine. Last year's fastest robot took over twenty seconds. That's a massive improvement in a year. But it's still a straight line on a track.
The track is flat and empty and the robot doesn't have to touch anything. The moment you add a door handle, the whole thing collapses.
Where does that leave Daniel's question about the trajectory? Is the field heading toward one model?
I think the honest answer is that the field is heading toward fewer models with learned interfaces. Not one model in the near term, but fewer, more integrated ones. The three-layer stack of reasoning, control, and reflex is probably going to persist because the timescales are different. A kilohertz reflex and a ten hertz reasoner are solving different problems. Forcing them into one network would be inefficient.
But the reasoning and the social layer and the manipulation planning might merge. The vision language model that talks to you and the planner that decides what to do could be the same model.
That's already happening. Ludi's reasoning model is the social layer and the planner. It talks and decides. The only thing it doesn't do is move. So you're already down to two models, reasoning and control, plus the reflex layer if you're Figure.
The facial expression is just a display. It's not a model at all in most systems.
Which is the part that would surprise most people. The face, the thing that makes the robot feel alive, is the least intelligent part of the whole stack. It's a screen with an animation.
The soul is a monitor.
The soul is a monitor running a pre-rendered expression loop. And that's probably going to stay true for a while, because the social payoff of a better face is lower than the practical payoff of better manipulation. Nobody's going to buy a robot because it has a more expressive face. They're going to buy it because it can reliably load the dishwasher.
Unless the product is companionship. Then the face is the product.
That's a whole different market. Companion robots are a thing in Japan and increasingly in China. But they're not trying to do manipulation. They're chairs with faces that talk. Different stack entirely.
The answer to Daniel's question is that it depends on what the robot is for. A warehouse robot has one stack. A companion robot has another. A humanoid that does both has the most complicated stack of all, and that's the one that's least ready.
The humanoid is the one everyone's excited about because it's the most legible. It looks like a person, so people assume it thinks like a person. But the thinking is the easy part. The body is the hard part.
The body is a committee of specialists, and the committee doesn't always agree.
The committee's minutes are written in glue code.
Hilbert: You're both missing the scale of it. I used to count these things. Nineteen ninety-seven, I worked for a company that did inventory automation, and part of my job was going into warehouses and counting how many times the picking arm dropped something. We had a clipboard with a form. Every drop, tick. Every mis-grab, tick. Every time the arm just stopped and waited for a human to come fix it, tick. We'd do eight-hour shifts just watching one arm.
What was the rate?
Hilbert: Depends on the product. Boxes, maybe two percent. Anything loose in a bag, ten, fifteen percent. And these were the systems the company was selling as working. That was the word they used. Working.
The fifty-two percent success rate on the Humanoid Olympics is not a new problem. It's the same problem with better cameras.
Hilbert: The cameras got better and the failure rate didn't move as much as you'd think. Because the failure isn't in the seeing. It's in the touching. A bag of flour in nineteen ninety-seven and a sock in twenty twenty-six, same fundamental issue. The robot doesn't know what the thing feels like, so it guesses, and the guess is wrong about half the time.
The feeling part is the missing sensor. Vision language models see, but they don't feel. And touch is the thing that lets humans do manipulation without thinking about it.
Hilbert: We had a guy who could pick a single grape off a bunch without bruising it. He'd been doing it for thirty years. His hands knew things his brain couldn't explain. You can't train a model on that because he couldn't tell you what he was doing. He'd just say, you feel it.
The tacit knowledge problem. The thing that can't be articulated, so it can't be labeled, so it can't be trained.
Hilbert: That's why I don't think the one model thing matters. You can unify all the models you want. Until the robot can feel the grape, it's still going to drop the grape.
That's the strongest argument for keeping the control layer separate. The tactile feedback loop has to run at a speed that a reasoning model can't match. You need a reflex system that responds to touch without thinking.
Hilbert: The arm I counted in ninety-seven had a force sensor in the gripper. Cost more than the rest of the arm. And it still dropped things. The sensor told it when it was already too late.
The sensor is reactive, not predictive. A human hand predicts the slip before it happens.
Hilbert: The grape guy would tell you he could feel the grape thinking about slipping. That's not a sensor. That's a model of the world built from thirty years of grapes.
Which is the world model argument. The reason a world model helps is that it predicts the slip before the sensor detects it. You imagine the consequence of your grip, and you adjust before it happens.
Hilbert: That's the thing that's not in any of these stacks yet. The robot that can imagine the grape slipping and adjust before it slips. That's when the numbers move. Until then, it's just a better clipboard.
The unification debate is downstream of the real problem. The real problem is prediction under uncertainty in physical contact.
That's where the world model research is pointed. But it's early. The world models that exist are good at predicting video, not good at predicting the feel of a grape.
Hilbert: I'd come home from those warehouse shifts and my wife would ask how it went. I'd say, the arm dropped eleven bags today. She'd say, that doesn't sound too bad. I'd say, the human next to it dropped zero.
That's the benchmark that matters. Not the hundred meter dash. The human next to it dropped zero.
The demos are getting better, but the gap between the robot and the human next to it is not closing as fast as the demos suggest. The sprint robot beat Bolt's time, but Bolt doesn't have to pick up a sock after the race.
Hilbert: The sock is the whole thing. I've been saying that since ninety-seven.
Daniel asked whether we're heading toward one model. I think the answer is that the architecture question is a distraction from the sensing and prediction problem. You can unify everything into one model, and it will still drop the sock until it can feel the sock.
That's where the field is actually stuck. Not on model architecture, but on the physical grounding. The reason the modular systems persist is that they let you swap in a better manipulation policy when one comes along. A unified model would have to be retrained from scratch every time the manipulation improves.
The modular approach is the pragmatic choice while the physical layer is still unsolved. The unification people are betting that the physical layer will only be solved by a model that learns everything together.
Both bets are reasonable. That's why the field is split. It's not a religious war. It's two different theories about where the next breakthrough comes from.
Hilbert: The next breakthrough comes from a glove with sensors in it. Mark my words. Someone's going to put a hundred pressure sensors in a glove, have a robot wear it for a year, and the numbers will move. I've been waiting for that glove since ninety-seven.
The glove is the missing dataset. Touch data. We have enormous datasets of vision and language. We have almost no datasets of what things feel like.
That's the asymmetry. A robot can see a million socks. It's felt almost none of them. The feeling data doesn't exist at scale.
Hilbert: The grape guy's hands were the dataset. And he took it with him when he retired.
The trajectory isn't one model or many models. The trajectory is toward whatever architecture can absorb the touch data when it finally exists. And that's probably a hybrid, because touch runs at reflex speed and reasoning runs at conversation speed, and they're never going to be the same network.
The nervous system analogy holds. Different speeds, different systems, one coherent self. The coherence is the hard part, and it's not a software problem.
This has been My Weird Prompts. Thanks to our producer, Hilbert Flumingtop. If you want to send us your own weird prompt, email us at show at my weird prompts dot com, or find us at my weird prompts dot com. We'll be back soon.
