No one is waiting for the next foundation model

We already have good enough base models for humanoid robots. That is the unstated consensus across every single paper published this month on robotic control.

GR00T, RT-2, and the other public vision-language-action models are not the bottleneck. They work fine. The bottleneck is every single layer above and below the base model. The parts that no one puts in press releases: balance policies, post-training data curation, uncertainty estimation, experience memory, simulation fidelity and control loop timing.

All of the meaningful progress this month happened in these boring, unglamorous components. None of it required scaling parameters. All of it is usable today.

The split control stack that actually works

There is one control architecture that is quietly winning for teleoperated humanoids. No one announced it. Every working system now uses it.

Split the robot vertically. Teleoperate the upper body directly via VR. Run a standalone reinforcement learning policy exclusively for lower body balance and locomotion. Do not feed arm motion into the walking policy. Do not try to learn full body coordination end to end.

This stack was demonstrated this month on the $4800 ROBOTIS OP3 miniature humanoid. It achieves stable 0.45 m/s walking completely independent of arm position. The operator can wave, reach, lift or throw objects and the walking policy will not break. Prior to this work, arm motion would reliably destabilize every open source walking policy for this platform.

This is not elegant. It violates every instinct of end-to-end learning. It works.

In the cube relocation trial, an untrained operator moved two 40g objects across 5 meters of floor in 10 minutes. That performance is within 2x of a human doing the same task with the same robot.

Lab to store is a systems problem, not an architecture problem

The DEED paper released this month is the most important practical result for deployed humanoids this year.

Researchers took the off-the-shelf GR00T N1.6 foundation model. Out of the box, it successfully restocked supermarket chip shelves 0% of the time. It would miss shelves, knock over items, lose tracking half way through motion. Everyone assumed this meant the model was not good enough.

They did not change the model architecture. They did not train a new model. They built a boring post-training pipeline:

1. Aligned VLA inference output to 120hz control loop timing
2. Curated 7 hours of real world demonstration data
3. Added a simple visual highlight mask for task relevant objects
4. Ran 12 hours of fine tuning on one consumer GPU

After this process the same base model completed 87% of restock attempts over 120 real world trials. It handled misaligned shelves, displaced items and lighting variation.

There is no secret here. Closing the lab to real world gap is almost never about model capacity. It is almost always about fixing impedance mismatches between layers that were never designed to talk to each other.

Active inference finally gets a proper RL formulation

For ten years active inference has existed as a separate parallel universe. It had good theoretical justifications, interesting philosophical arguments, and almost zero working implementations that could compete with standard reinforcement learning on real tasks.

This month that changed. Researchers showed that expected free energy minimization, the core objective of active inference, can be formulated exactly as a convex Markov Decision Process.

The epistemic drive that makes active inference different is just a policy dependent performative reward term. All existing actor critic algorithms, dynamic programming and convergence proofs apply unchanged. You do not need custom solvers. You do not need separate inference code.

You can drop an active inference objective into any modern RL training loop today. This is not an incremental improvement. This merges two fields that have been ignoring each other for a decade.

Uncertainty estimation in TD learning was missing this whole time

Every temporal difference learning implementation ever written returns a single number for the value function. None of them tell you how certain that estimate is.

This has been an enormous unaddressed flaw. When a policy encounters an unseen state, it will output a very confident completely wrong value estimate. Every robot failure that gets blamed for distribution shift is actually this failure mode.

The generalized Kalman TD framework published this month fixes this. It treats value estimation as a stochastic inference problem, and recursively tracks both the expected value and its second moment. You get calibrated uncertainty estimates for every state, with less than 15% overhead over standard TD learning.

This works for non linear systems and non Gaussian distributions. It required no new theory, just someone finally noticing that we had been throwing away half the information from every update for 30 years.

Multi-agent coordination stops forgetting everything

Dynamic manufacturing floors break every existing multi-agent reinforcement learning system. When a machine fails, or an urgent job arrives, every existing approach throws out all prior experience and relearns coordination from scratch.

The Graph Structured Experiential Memory framework changes this. It encodes every historical coordination episode as a heterogeneous relational graph. When a new disturbance occurs, a graph neural network retrieves structurally similar past events, and adapts the existing policy instead of resetting.

On standard flexible job shop benchmarks this reduces adaptation time by 38% at high disturbance rates. That is the line between a system that works in demo and a system that can run an actual factory shift.

The simulation stack has reorganized completely

Simulation stopped being a thing you pick. It is now a layered stack that you assemble for your workload.

12 months ago every team picked one monolithic simulator and used it for everything. Today the stack has split cleanly into three separate layers:

1. Physics engine: runs dynamics, contacts, actuation
2. Training interface: handles RL loop, batching, policy evaluation
3. Rendering / sensor: only loaded when you are training vision policies or testing sim2real transfer

This is the single largest shift in the robotics infrastructure this year. No one builds monolithic simulators any more.

Simulation engine capability matrix

Engine	GPU Batched	Differentiable	RTX Rendering	Contact Accuracy	Best For	Max Parallel Envs / GPU
MuJoCo (CPU)	❌	✅ Partial	❌	✅ Excellent	Prototyping	32
MuJoCo Warp	✅	✅ Full	❌	✅ Excellent	RL Training	2048
Isaac Sim PhysX	✅	❌	✅	✅ Good	Sensor / Sim2Real	256
Isaac Lab Newton	✅	✅ Full	✅ Optional	✅ Very Good	Large Scale RL	4096
PyBullet	❌	❌	❌	⚠️ Average	Baseline Testing	16
Drake	❌	✅ Full	❌	✅ Excellent	Trajectory Optimisation	8

Newton is the new common layer. It is an open source GPU physics engine governed through the Linux Foundation, with contributions from NVIDIA, DeepMind and Disney Research. Every major training framework is adding Newton backend support as of this quarter.

What this means for deployment right now

You can build a working general purpose humanoid control stack today. You do not need to wait for any announcements. You do not need access to closed models.

Use this stack:

1. Split VR / RL locomotion control
2. GR00T N1.6 base model
3. DEED post training pipeline
4. Generalized Kalman TD for value estimation
5. Isaac Lab + Newton for training
6. GSEM memory for multi agent deployments

Every component here is published, open source, and runs on consumer hardware. This stack will outperform almost every demo you have seen from large humanoid vendors.

The unspoken bottleneck

Almost none of this work is being done on full size humanoids. All of the generalizable, reproducible control progress is happening on $3k-$8k miniature and education platforms.

The full size humanoid vendors are still running end to end policies, doing 10000 reset demos, and not publishing any of their control stack. The actual progress is happening on hardware that researchers can actually buy and run experiments on.

That is the pattern that will define this field over the next 18 months. The first useful deployed humanoids will not be the $100k platforms getting press releases. They will be small, cheap, boring robots running the stack described here.