I was in Shanghai a few weeks ago when one of the people I was traveling with — a smart, non-robotics savvy friend who reads the news and notices things — turned to me over dinner and asked the question I’d been waiting for the entire trip.
“All these robot dogs we’ve seen running around. The humanoids doing kung fu on the demo stage at the Unitree office. The robotic arms we have seen folding laundry. How are they doing this? Are they powered by large language models? How does that even work? Is there an language model somehow controlling their movements?”
It’s a great question, and the honest answer is: kind of, but the real story is more interesting than that. The robots you’re watching on social media aren’t ChatGPT in a metal suit. They’re running a stack — several layers of AI working in concert — that has changed more in the last three years than in the previous thirty. Language models are part of it. So are vision models, action models, behavior trees, classical control loops, and an emerging family of systems called world models that may be the most important development of all.
This is a long post because it’s the explanation I wish I’d had time for at that dinner. I’ll start at the beginning — when robots were almost entirely hand-programmed — and walk forward through every major shift, ending at where we are now: on the cusp of robots that don’t just react to the world, but imagine it.
A video of the martial arts demo with G1 humanoids at Unitree’s new office.
Part 1: The Pre-LLM Era — When Robots Were Mostly Just Software
For decades, building a robot meant writing a lot of code. Like, a lot. And almost none of it was learned.
A classical industrial robot — the orange arms welding a Toyota chassis in the 1990s, the Boston Dynamics BigDog of the early 2000s — was a tower of carefully engineered modules stacked on top of each other:
Perception: filter the camera feed, run edge detection, identify the position of the workpiece using geometric matching.
State estimation: combine wheel encoders, gyros, and accelerometers (sensor fusion) to figure out where the robot is and how fast it’s moving.
Planning: given a goal pose, compute a collision-free path through a known map using algorithms like A* or RRT.
Control: at the lowest level, hundreds-to-thousands of times per second, a PID controller1 adjusts motor torques to follow that path.
Each of these layers was written by humans, often by different humans in different labs, and stitched together with enormous care. Behavior — “pick up the cup if it’s red, otherwise wait” — was encoded as state machines or behavior trees: literal flowcharts that the robot executed step by step.
The strengths of this approach were real. It was predictable. You could prove certain things about it mathematically. It met safety standards. It’s why your car has working ABS brakes.
The weakness was equally real. A robot like this is only as smart as the situations its engineers anticipated. Move it to a new factory, a new lighting condition, a new color of cup, and it falls apart. Generalization, in any meaningful sense, was nearly zero.
Part 2: Machine Learning Sneaks In
In the 2010s, deep learning started chipping away at the perception layer first. The same convolutional neural networks that were beating humans at ImageNet image classification could be retrained to detect grasp points on objects, segment furniture in a room, or recognize a person’s pose. Suddenly, the “perception” box at the top of the stack didn’t need to be hand-engineered — you could train it.
Then learning crept into control. Researchers at Berkeley, DeepMind, and OpenAI showed that reinforcement learning — letting a robot (agent) try things in simulation millions of times and reinforcing whatever worked — could produce surprisingly competent walking gaits, in-hand object manipulation (OpenAI’s solving a Rubik’s cube one-handed in 2019 was a landmark moment), and locomotion policies that adapted to terrain.
A parallel thread was imitation learning, often called behavior cloning: record a human teleoperating the robot for a few hundred attempts at a task, then train a neural network to predict what the human would do given what the robot is seeing. Simple, but it actually worked for a meaningful class of tasks.
The key catch in all of this: each learned policy was narrow. Train a network to pick up a red block, and it has no idea what to do with a yellow mug. Train it to walk on grass and it falls down on tile. Generalization remained the white whale.
A wider scaffolding emerged around this period that’s worth naming because it still underpins almost everything: ROS, the Robot Operating System (first released in November 2007). ROS isn’t an operating system in the Windows or Linux sense — it’s a middleware framework, a kind of universal plumbing system for robots. It lets the “camera node,” the “navigation node,” the “arm controller node,” and dozens of others publish and subscribe to messages over a shared bus. ROS2, the current version, is what runs underneath an enormous fraction of the world’s research and commercial robots, from Stanford’s labs to Chinese humanoid startups. When people talk about a robot’s “operating system,” they almost always mean ROS2 plus whatever stack of perception, planning, and control packages sits on top of it.
Part 3: The LLM Lands in Robotics
Then ChatGPT happened.
Suddenly there was this thing — a large language model — that could read instructions in plain English, reason in multiple steps, write code, and call functions. Roboticists noticed almost immediately that this was a missing piece they’d been working around for years. The hardest part of getting a robot to do something useful in a home or office wasn’t usually the motor control. It was the interface: how does a person tell the robot what to do, and how does the robot break that goal down into the atomic actions it already knows how to perform?
The first wave of LLM-in-robotics work treated the language model as a kind of natural-language compiler sitting on top of ROS. The pattern looked like this:
The user says something in English: “Bring me the coffee mug from the kitchen counter and put it on my desk.”
The LLM, given a list of the robot’s available atomic skills (
navigate_to(location),find_object(name),pick(object),place(location)), generates a plan — either as a sequence of function calls, a state machine, or a behavior tree written in XML.A ROS2 node executes that plan one step at a time. If a step fails, the failure is reported back to the LLM, which can re-plan.
Google’s SayCan project from 2022 was a particularly clean version of this idea: the LLM proposed skills, a separate “affordance” model scored how likely each skill was to succeed right now, and the robot picked the combination with the highest joint score. Open frameworks like ROS-LLM led by Huawei’s research labs, ROSGPT, and ROSA generalized the pattern.
This was a real and useful leap. Suddenly you could tell a robot to “clear the table and put the recyclables in the blue bin” and it would attempt something reasonable. But notice what’s still happening here: the LLM is in the planning layer. The actual motor commands are still being produced by the same hand-engineered or narrowly-trained controllers underneath. The language model is a smart dispatcher. It’s not driving.
Part 4: VLAs — When the Brain Started Driving
The next leap was harder won and far more important. Researchers asked a more ambitious question: what if the model didn’t just plan, but actually produced motor commands directly? What if you fed the camera image and the language instruction straight into a single neural network and got, out the other side, the next millisecond of joint movement?
This is a Vision-Language-Action model, or VLA. It is now the dominant paradigm in modern humanoid and quadruped robotics.
The first widely noticed VLA was RT-2 from Google DeepMind in 2023. The clever trick: take a big vision-language model (one already trained to caption images and answer questions about them) and continue training it on robot demonstrations, but treat robot actions as just another kind of token to predict. The same neural net that could write “the cat is sitting on the mat” could now output a sequence of tokens encoding “move the right gripper 3 cm forward, close fingers, lift 5 cm.” Reasoning and acting in the same model.
Then, in mid-2024, a Stanford-led team released OpenVLA, a 7-billion-parameter open-source VLA trained on the Open X-Embodiment dataset — a million-plus episodes pooled from twenty-one different research labs across twenty-two different robot bodies. This was the first time anyone outside Google could just download a generalist robot model and start tinkering. It changed the field overnight.
Today, the leading VLAs are a small but rapidly evolving cast:
π0 and π0.5 from Physical Intelligence — known for impressive task adaptability.
NVIDIA Isaac GR00T N1.7 — open-weights, commercially licensed, designed specifically for humanoids, and the model most Chinese hardware companies are now post-training on their own data.
Figure AI’s Helix and the newer Helix-02 — proprietary, but architecturally important.
AgiBot’s Genie Envisioner — a Chinese world-model-driven platform we’ll come back to.
SmolVLA, NORA, ACoT-VLA, CogACT — a growing zoo of academic VLAs exploring different design points.
How a VLA actually works (no math, promise)
Think of a VLA as having three streams of input fused into one stream of output.
The first stream is vision. RGB cameras, sometimes depth or LiDAR, sometimes tactile sensors on the fingertips, are processed by a vision encoder — usually a transformer model like DINOv2 or SigLIP — which compresses each image into a few hundred “vision tokens” that summarize what the robot is seeing.
The second stream is language. Your instruction (”hand me the screwdriver”) is tokenized just like in ChatGPT.
These two streams are concatenated and fed into a transformer “trunk” (often a small open language model like Qwen3 or Llama). The trunk does the reasoning — combining what it sees with what it’s been asked.
The third stream — the action — comes out the other end. This is where designs diverge:
Discrete action tokens: The model literally generates tokens that decode into joint angles or end-effector positions, the same way ChatGPT generates words. Simple, but jerky at high frequency.
Diffusion or flow-matching action heads: A separate small network takes the trunk’s output and denoises a smooth trajectory of joint positions, like an image diffusion model but generating motion. This is what π0 does. Smoother, more natural-looking movement.
Action chunking: Predict not the next single command but the next half-second of commands at once, smoothing out jitter.
This is the architectural shift that matters: reasoning and acting are no longer separate. The same gradient that taught the network to recognize a cup also taught it how to grasp one. That coupling is why VLAs generalize where their predecessors didn’t.
Part 5: The Two-Brain Trick — How LLMs and VLAs Work Together
Here’s a wrinkle the marketing rarely explains clearly. The best-performing humanoid robots today don’t run a single VLA. They run two models, at two different speeds, talking to each other. This is sometimes called a dual-system or System 1 / System 2 architecture, borrowed from Daniel Kahneman’s psychology framework where humans have a fast intuitive brain and a slow deliberative one.
Figure AI’s Helix made this design canonical, and it’s now copied (with variations) almost everywhere — including, importantly, NVIDIA’s GR00T N1.7, which means most Chinese humanoids inherit it too. Here’s the structure:
System 2 (S2): the slow brain. A 7-billion-parameter vision-language model running at roughly 7–9 Hz — that’s seven to nine times per second. Its job is to look at the scene, parse the instruction, do multi-step reasoning (”the bowl is behind the cereal box; I need to move the box first”), and emit high-level intent — usually as a compact set of internal vectors, not literal words.
System 1 (S1): the fast brain. A much smaller (~80-million-parameter) visuomotor policy running at 200 Hz. It takes S2’s intent vector plus the latest sensor data and outputs continuous joint commands. It doesn’t “think” in any meaningful sense — it reacts.
More recently, Figure’s Helix-02 (January 2026) added a System 0 — a reflex layer beneath the dual brain rather than a third cognitive tier. It’s a 10-million-parameter network running at 1 kHz that handles raw balance and full-body coordination, replacing more than a hundred thousand lines of hand-written locomotion C++ code with a neural controller. Think of S0 as a learned spinal cord: it doesn’t reason or plan, it just keeps the body upright and coordinated while the dual brain above does the thinking.
The reason for this split is a constraint of physics, not philosophy. A motor command issued every 200 milliseconds — the speed of a big VLA — would feel like a robot moving underwater. A motor command needs to update faster than the natural oscillations of the joint it’s controlling, which means hundreds to thousands of times per second. No 7-billion-parameter transformer can run that fast on a battery-powered robot.
So the cognitive labor gets divided: the big slow model thinks; the small fast model acts. They communicate not in English but through learned latent vectors — the slow model whispers an abstract goal, and the fast model knows how to interpret it.
Part 6: The Cloud, the Edge, and the Question of Where to Put the Brain
This brings us to a question my friend in Shanghai didn’t ask but should have: where is all this compute actually happening?
There’s a strong, almost ideological consensus among serious robotics teams now that the safety-critical loop has to run locally, on the robot itself. There are two reasons:
Latency. A WiFi or cellular round-trip is, optimistically, 30–80 milliseconds. A motor command needs to update every 1–5 milliseconds. You cannot put a network in that loop and survive. If a robot is about to step on a cat, the decision to lift its foot must happen on-device.
Reliability. Robots operate in factories, warehouses, kitchens, hospitals. Networks drop. A robot that stops working when WiFi flickers is a liability.
So the modern split looks like this:
Onboard (local), running on something like an NVIDIA Jetson Thor or AGX Thor module (~2,000 TFLOPS, 128 GB memory, 40–130 W power):
All of S0 / S1 — balance, locomotion, fine motor control.
The VLA itself (System 2), increasingly quantized to FP8 or FP4 to fit. Models in the 2–7 billion parameter range now run on-device.
Perception, sensor fusion, and the safety monitor that can override anything else.
Cloud or remote server, when present:
Conversational interfaces (”Hey robot, what should I make for dinner?”) — these can tolerate latency.
Fleet-wide learning: thousands of robots sending teleoperation data home to be aggregated into the next model release.
Heavy long-horizon planning that might use a frontier-scale model.
Operator dashboards and monitoring.
There’s also a growing middle layer: on-premise edge servers in a factory or warehouse, talking to a fleet of robots over a local network with single-digit-millisecond latency. This is where a bigger LLM might live, doing the high-level dispatch that no individual robot needs to host.
The Chinese humanoid wave — Unitree, AgiBot, XPeng IRON, Fourier, EngineAI — is being built on this assumption. Their robots come with onboard compute (often Jetson, sometimes domestic Chinese alternatives like Huawei’s Ascend chips), and the cloud is used for fleet learning and conversational shells, not for the control loop.
Part 7: Why Open Models Are Quietly the Most Important Story
If you watch only the demos, you’d think the field is being driven by a handful of well-funded American companies. The reality is more subtle. The pace of progress in physical AI is being set, to a remarkable degree, by open-weights models that anyone can download and fine-tune.
The list is short but consequential:
OpenVLA (Stanford): the first open 7B generalist robot model.
NVIDIA Isaac GR00T (N1, N1.5, N1.7): open weights with commercial licensing coming soon, trained on tens of thousands of hours of human egocentric video. The GR00T N1.7 release in March 2026 made the dual-system architecture freely available to anyone with a humanoid.
Physical Intelligence’s π0: weights released for research.
NVIDIA Cosmos: open world foundation models (we’ll get there).
AgiBot World: a massive open-source dataset of teleoperated humanoid demonstrations from the Shanghai-based startup.
Hugging Face’s LeRobot: an open library that has become the meeting ground for all of the above.
Mimic robotics’ mimic-video: open video-action model that achieved 10× better sample efficiency than traditional VLAs.
This matters for two reasons. First, robotics startups don’t have to spend tens of millions of dollars pretraining a foundation model — they can take GR00T or π0 and post-train it on their own robot’s data. Unitree, EngineAI, Booster, Galbot, and dozens of smaller Chinese firms are doing exactly this. That’s how a company with a few hundred employees ships a humanoid that walks, talks, and folds laundry: they stand on the open stack.
Second, open models are the only realistic safety story. A closed model running in a robot’s chest, on someone’s factory floor, with no external visibility into its reasoning, is a regulatory nightmare. Open weights let auditors, researchers, and operators actually inspect what the robot has been trained to do.
Part 8: What’s Still Broken
If you’ve watched enough robot demo videos, you’ve also watched enough robot fail videos. (The “robot face-plants into wall” subgenre is its own art form on YouTube.) The current generation of LLM+VLA robots is genuinely impressive, and it is also genuinely limited. The honest list of problems:
Mid-task recovery. A VLA handles unexpected variation better than anything before it. But when something actually goes wrong — a grasp that slips, an object that rolls, a person who steps into the workspace — getting back on track is still a weak point. The robot often re-attempts the same failed action.
Sample efficiency. Training a VLA from scratch takes tens of thousands of teleoperation hours. A human can learn to operate a new tool in minutes. The gap is enormous.
Cross-embodiment generalization. A model trained on a Franka robot arm in a Stanford lab does not transfer cleanly to a Unitree humanoid in a Shenzhen warehouse. The physical bodies are different, and the model has overfit to one of them.
Long-horizon tasks. Anything requiring more than 30–60 seconds of coherent behavior, with multiple subgoals, tends to drift. “Make me breakfast” remains comfortably out of reach.
Physical common sense. A VLA has been trained to imitate, not to understand. It does not know that a glass of water tips over when you knock it, in the deep sense of “knowing.” It has only seen examples and predicts what would happen next based on pattern matching.
Spatial reasoning. Despite being multimodal, VLAs are surprisingly weak at things like “go around the obstacle, not through it” or “stack these so they don’t fall.”
This last cluster of weaknesses — physical common sense, spatial reasoning, long-horizon planning — is where the field is starting to bet on a fundamentally different kind of model.
Part 9: Enter the World Model
The bet is this: what if, instead of training the robot to predict actions, we train it to predict the consequences of actions?
A world model is a neural network that, given the current state of the world (typically as a video or sequence of frames) and a proposed action, predicts what the world will look like next. In its simplest form, you can think of it as a learned video predictor with a steering wheel. You show it the last second of camera footage and tell it “the robot moves its arm forward 10 cm,” and it generates a realistic-looking video of what the next second would look like.
Why does this matter?
Because once you have a world model, the robot can think before it acts. It can mentally roll out three or four different candidate actions, predict the outcome of each, score them, and pick the best — all before any motor moves. This is exactly how a chess engine plays: it doesn’t memorize moves, it simulates futures. We’ve never had this capability in physical robotics before, because we’ve never had a model accurate enough to simulate the messy real world.
What world models actually look like in 2026
The state of the art is a small but rapidly growing menagerie. A few you should know:
NVIDIA Cosmos — a family of open world foundation models, including Cosmos Predict 2.5 (generation), Cosmos Transfer 2.5 (controllable simulation), Cosmos Reason 2 (a vision-language reasoner for robots), and the very recent Cosmos Policy, which goes the extra step of directly outputting actions by post-training a world model for control. Cosmos was trained on tens of thousands of GPU-hours of video data (Cosmos Predict 2.5 is the world model in the family.)
DeepMind Genie 3 — an interactive world model that generates fully navigable environments from a text prompt, at 24 frames per second, with consistency for minutes at a time. Originally for game-like environments but a clear stepping stone toward physical AI.
Meta V-JEPA 2 — pretrained on more than a million hours of internet video, then action-conditioned with just 62 hours of robot footage. Hit 80% zero-shot pick-and-place success on real robot arms across different labs with no task-specific training. The “JEPA” approach is architecturally distinct from the others — more on this in a moment.
DeepMind Dreamer 4 — learned to collect diamonds in Minecraft (a 20,000-step task) from purely offline data, with zero environment interaction. A proof that you can do real reinforcement learning inside an imagined world.
AgiBot’s Genie Envisioner — a unified world-model platform from China, trained on 3,000+ hours of real-world humanoid manipulation video. It can both generate predicted rollouts and produce executable action trajectories. AgiBot uses NVIDIA Cosmos Predict 2 as a backbone and post-trains it on their own data — exactly the open-stack-plus-domestic-data pattern I described earlier.
Toyota Research Institute’s Cosmos-based world model — used for teleoperation data augmentation and navigation.
Part 10: Alternative Architectures, Because the Field Isn’t Settled
There is no single agreed-upon way to build a world model. The architectural debate is one of the most interesting fights in AI right now, and it directly shapes what robots will be able to do. Three camps worth knowing:
Pixel-level video diffusion (the Cosmos / Sora school). Predict future frames as actual pixels using a diffusion model. Pro: works as a synthetic data generator — you can render whole new robot demonstrations that never happened. Con: expensive, sometimes hallucinates physics, and predicting pixels you’ll never look at is wasteful.
Joint Embedding Predictive Architectures, or JEPA (the LeCun school). Don’t predict pixels — predict the abstract representation of the next frame. Throw away texture detail and just keep the semantic essence of what’s there. Pro: efficient, focuses on what matters for action. Con: harder to use as a visual synthetic-data generator. This is what V-JEPA, V-JEPA 2, and the new JEPA-VLA hybrids are exploring.
Latent action world models (the Genie / Dreamer school). Learn to compress entire episodes of video into a latent “action language” that captures the structure of behavior, then train the world model to predict the next latent state given the next latent action. Pro: lets you train on action-free internet video, then bolt on a small amount of real robot data. Con: the latent actions are not human-interpretable, which complicates safety analysis.
There are also fascinating hybrids: GigaBrain-0, a 2025 paper, is a VLA that uses world-model-generated synthetic data to massively expand the diversity of its training distribution — variations in materials, lighting, viewpoints that you’d never get from real footage. Mimic-video uses a pretrained internet video model and bolts a flow-matching action decoder onto it. Cosmos Policy post-trains a world model directly into a controller. ACoT-VLA (CVPR 2026) introduces a “chain-of-thought in action space” — the robot reasons in the language of motions, not in English.
Part 11: What a World-Model-Powered Robot Actually Looks Like in Practice
If you fast-forward a couple of years, the architecture of a frontier humanoid robot probably looks like this:
A world model lives onboard alongside the VLA. When the robot encounters a new situation, it does something like:
The VLA proposes a few candidate next actions (it remains the policy).
The world model takes each candidate and simulates 1–3 seconds of imagined video forward in time.
A value head scores the imagined outcomes — did the cup get picked up? Did anything fall? Did the human get bumped?
The robot picks the action whose imagined future scores best, and executes only its first chunk.
Real sensor data flows back in; the cycle repeats.
This is model-predictive control, the technique that has stabilized rockets and quadcopters for years, but with a learned world model replacing the hand-derived physics equations. It scales because the world model was pretrained on millions of hours of video, not because someone wrote the Navier-Stokes equations for a kitchen.
The benefits cascade:
Recovery improves. If a grasp slips, the world model can imagine multiple corrective trajectories and pick the most promising one.
Generalization improves. A world model trained on internet video has seen orders of magnitude more “physics” than any robot teleoperation dataset.
Long horizons become tractable. Plan in imagination, not in reality.
Sim-to-real shrinks. Instead of training in a hand-built simulator (Isaac Sim, Newton physics engine) and hoping it transfers, you train in a learned simulator that was fit to real video — so the gap is smaller.
Synthetic data explodes. A world model can generate millions of varied robot trajectories, with different lighting, materials, and object configurations, for almost free. This solves one of the field’s biggest bottlenecks.
There’s a separable, important benefit for safety. A robot that can simulate the outcome of an action before performing it is one that can refuse to do dangerous things — not because a hard-coded rule blocked it, but because its imagined future included someone getting hurt.
Part 12: Things My Friend Should Also Know
A few threads I want to pull on briefly before closing, because they came up in his follow-up questions and they round out the picture:
The data problem is the actual problem. All the architectures in the world don’t help if you can’t feed them. Teleoperation — humans wearing VR rigs and remotely puppeteering robots — is currently the bottleneck. A robot company’s competitive moat is increasingly its data collection pipeline, not its model. AgiBot has built warehouses full of teleoperators. NVIDIA’s GR00T N1.7 dexterity scaling law showed that more human egocentric video directly and predictably improves robot dexterity. This is part of why China has a structural advantage: lower labor costs for data collection, more permissive deployment environments, and a state actively coordinating the supply chain.
Simulation is a parallel universe. NVIDIA’s Isaac Sim, the new open-source Newton physics engine (1.0 GA in April 2026), and Omniverse let companies train robots in millions of parallel simulated environments before they ever touch reality. Most of what looks like “robot intelligence” was actually grown in simulation and grafted onto hardware later.
The economics are starting to bite. Unitree shipped roughly 5,500 humanoids in 2025 and is targeting 10,000–20,000 in 2026. The average price has fallen from $85,000 to $25,000 in two years. Unitree’s R1 costs $5,900. Noetix Bumi launched at $1,400. We are watching humanoid hardware hit consumer-electronics price curves while the AI inside still trails the demos. That gap will close, and when it does, the volume effects on the field will be significant.
Failure modes look weird. When LLM-based robots fail, they often fail in ways no classical robot could — confidently doing the wrong thing, “hallucinating” affordances, getting stuck in conversational loops with their own planners. The classical robotics community has a fair amount of well-earned skepticism here, and they’re not wrong to insist that learned systems must be wrapped in safety monitors and bounded behaviors. The most reliable deployed robots today are hybrid: a VLA brain inside a hand-engineered safety cage (similar to an “agentic harness”).
The “ChatGPT moment” framing is a useful but misleading metaphor. Jensen Huang has been telling everyone that the ChatGPT moment for robotics has arrived. He has a strong incentive to say this because NVIDIA sells the picks and shovels. The honest version is: we’re in roughly the GPT-2 era of physical AI. Capable enough to surprise you. Not capable enough to deploy unsupervised. Improving fast but no viral adoption moment, instead a slow and steady trajectory.
Closing: Why the Bet Is Worth Taking
The demo we saw at Unitree’s office with a group of five G1 humanoids performing martial arts was carefully choreographed motion sequences, an onboard VLA-style controller was doing fine adjustments, and the remote operator ensured nothing went awry. It wasn’t autonomous in any deep sense. But every piece of that pipeline — the perception, the planning, the motor control — is being eaten by neural networks. In two years, the same robot will do the same routine without choreography, because it will have imagined the routine and chosen the best version.
The whole arc I’ve described — from hand-coded controllers, through ML perception, to LLM planners, to VLAs, to dual-system architectures, to world models — is really one slow shift in where the intelligence of a robot lives. It started in the engineer’s head. It moved into hand-written code. It moved into the perception layer. It moved into the planner. It moved into the policy. And now it’s moving, finally, into a learned model of the world itself.
Each shift made robots more general, more adaptable, and more useful. The world-model shift, if it works, will be the one that makes them genuinely capable — capable enough that the question stops being what can robots do? and starts being what should we let them do?
That’s the question I owe my friend an answer to. Maybe next trip.
If you found this useful, I write about AI, Robotics, the people I meet, and the long, strange road to physical AI. Subscribe and tell a friend who’s tired of vague “AI is everywhere” and second-hand takes — I’ll keep them concrete and direct from the source.
A PID (Proportional - Integral - Derivative) Controller is a control loop feedback mechanism that automatically corrects the behavior of a system to accurately maintain a desired target (like temperature or speed) by calculating and adjusting for errors in real-time