PTENES
← Track 1 MODULE 1.1

🌐 The Big Picture: From LLMs to Robots That Act

LLMs can talk about the world, but they don’t touch it. This module maps the cognitive stack perception→language→action, explains why manipulation is AI’s oldest bottleneck, and shows how foundation models for robotics became the bet for 2026.

6
Topics
~35
Minutes
Basic
Level
Theory
Type

Detailed content

1

🧠 The cognition stack: perception → language → action

Every embodied agent runs the same loop: perceive the world through sensors, reason about the objective and context, and act issuing motor commands. A pure LLM lives entirely in the middle layer—it operates on tokens, not the world. It has no sensory grounding (it doesn’t know where the cup is in metric coordinates) and no action channel (it can’t output torque). The VLA leap closes this loop: attach visual perception at the input and an action head at the output of the same backbone that already reasons.

👁 PERCEPTION cameras, force, proprioception → tokens 💬 LANGUAGE / REASONING LLMs' native domain 🦾 ACTION Δpose · gripper · torque world feedback

The loop closes: action changes the world, which returns as new perception. LLMs cover only the middle stretch.

📊 Why action is the missing link

  • 0% — fraction of physical actions an LLM-text model can execute without a motor channel.
  • ~50Hz — typical control rate for fine manipulation; autoregressive text comes nowhere close without chunking.
  • Metric 3D — the real action space, not the token space.

Grounding

Ground symbols in the physical world.

Sensorimotor loop

An action changes the next observation.

Embodiment

A body with sensors and actuators.

Action channel

Motor output beyond text.

2

🤖 Embodied AI and the Moravec paradox

O Moravec’s paradox (1980s) observes a counterintuitive reversal: tasks humans consider “easy”—picking up an object, maintaining balance, perceiving depth—require enormous sensorimotor computation, while “difficult” reasoning such as chess or integrals is relatively cheap for machines. The reason is evolutionary: billions of years refined our motor skills, making them unconscious; formal mathematics is only millennia old. That’s why a model can beat humans on math tests but still fail at folding a towel.

✓ What makes VLA viable today

  • ✓Reuse visual and semantic priors from web-scale models.
  • ✓Cross-embodiment datasets provide sensorimotor coverage.
  • ✓Action chunking amortizes fine-control latency.

✗ Why manipulation still breaks down

  • ✗Contact dynamics are discontinuous and difficult to model.
  • ✗Deformable objects and variable friction fall outside the training distribution.
  • ✗A millimeter-level error makes the task fail; text tolerates ambiguity.

⚡ Practical tip

When evaluating a VLA, don't confuse language fluency with motor competence. A model that perfectly describes "how" to pick up the cup may still fail to execute. Measure physical success rate, not the quality of the narration.

Moravec’s paradox

Sensorimotor > reasoning in cost.

Contact dynamics

Nonsmooth forces during contact.

Dexterity gap

Distance to the human hand.

Embodied AI

Intelligence situated in a body.

3

🌍 Foundation models for robotics

Classical robotics trained one policy per task per robot — N×M fragile models. The foundation model thesis inverts this: train one large model across many tasks and many bodies and harvest generalization. The bet is that diverse data induces shared representations — just as an LLM learns the syntax of one language and transfers it to another, a VLA learns to "grasp" with one arm and transfers that skill to another.

# Paradigma antigo            # Paradigma foundation
politica_pegar_braçoA()       modelo_vla(obs, instrução)
politica_empurrar_braçoA()      → ação  # qualquer tarefa
politica_pegar_braçoB()         # qualquer corpo
...  # N×M políticas frágeis   # 1 modelo, generaliza

💡 The generalization thesis in three dimensions

A good VLA generalizes across objects (picking up something never seen before), positions/scenes (new table, new lighting) and instructions (rephrased command). RT-2 showed that the third axis—language—directly inherits from web pretraining.

Generalist policy

One policy for many tasks.

Cross-embodiment

Transfer between different bodies.

Positive transfer

More data helps; it doesn't hurt.

Axes of generalization

Object · scene · instruction.

4

🚀 The leap from RT-1 → RT-2

RT-1 (Google, 2022) proved that a transformer could map camera + instruction to tokenized actions, trained on ~130k demos. But its knowledge stopped at the demos. RT-2 (2023) made the leap: it took a VLM already pretrained on the web (PaLI-X / PaLM-E) and co-fine-tuned it with robot data, representing actions as text tokens. The result was emergent semantic generalization — the robot could "pick up the extinct animal" (the toy dinosaur) by inheriting concepts from the web, without ever having seen that instruction in demos.

1

RT-1 — action tokenization

Transformer + FiLM, actions in discrete bins. Solid, but with no knowledge beyond the dataset.

2

RT-2 — VLM as the foundation

Actions become text tokens in a web-scale VLM; co-fine-tuning preserves internet knowledge.

3

Semantic emergence

Multi-step reasoning and references to concepts never demonstrated appear "for free."

Web→action transfer

Web knowledge becomes action.

Co-fine-tuning

Mixes web + robot data during training.

Action-as-text

Actions as vocabulary tokens.

Emergent skills

Undemonstrated capabilities.

5

🏢 The 2023-2026 ecosystem

The field has organized around a few hubs. Google DeepMind kick-started academic research (RT-1/RT-2/RT-X). Physical Intelligence delivered the π0/π0.5 generalists with flow matching. NVIDIA pushes the humanoid stack forward with GR00T and simulation. Figure (Helix) and Tesla (Optimus) industrialize humanoid robots.

Google DeepMind

RT-1, RT-2, RT-X, Gemini Robotics. Pioneers of the VLA paradigm.

Physical Intelligence

π0/π0.5, FAST. Generalist manipulation models with flow matching.

NVIDIA

GR00T N1/N1.5, Isaac Sim/Lab, Cosmos. Foundation + simulation.

Figure / Tesla

Helix (System 1/2) and Optimus. Humanoids at industrial scale.

⚡ Practical tip

Track who it is open (OpenVLA, Octo, LeRobot, partial GR00T) versus done (RT-2, Optimus). For learning and prototyping, the open ecosystem is where you can actually run code.

GR00T

NVIDIA's humanoid foundation model.

π0

Generalist from Physical Intelligence.

Helix

Figure’s dual-system VLA.

Optimus

Tesla humanoid, FSD stack.

6

⏰ Why now: data, compute, architecture

VLAs didn’t emerge from a single invention, but from the convergence of three curves. Data: Open X-Embodiment brought together 60+ datasets, 22 embodiments, and 1M+ trajectories. Compute: GPUs made it feasible to train models with 7B+ parameters on robotic video. Architecture: Transformers and diffusion/flow models provided the right form for ingesting multimodality and generating expressive actions.

📊 The three converging curves

  • 1M+ trajectories — Open X-Embodiment aggregated demonstrations that were previously scattered.
  • 22 embodiments — body diversity that enables transfer.
  • 7B parameters — OpenVLA scale, trainable on accessible clusters.

💡 The Pareto moment

None of the three curves would be enough on its own. It's their intersection—unified data + accessible compute + a suitable architecture—that puts general-purpose robotics at the frontier in 2026. It's the same pattern that unlocked LLMs in 2020, delayed by years because of the cost of physical data.

Open X-Embodiment

Unified robotics corpus.

Scaling

Compute makes 7B+ on video feasible.

Transformers/diffusion

Architectures for multimodal input + action.

Pareto moment

Intersection of the three curves.

✅ Module summary

✓
The cognitive stack — LLMs operate at the language layer; VLAs close the loop with perception and action.
✓
Moravec’s paradox — manipulation is the bottleneck, not reasoning.
✓
Foundation models — one model, N tasks and bodies, generalizing across objects/scenes/instructions.
✓
RT-1→RT-2 and the ecosystem — Co-fine-tuned VLM brought about semantic emergence; the players and the convergence of data/compute/architecture explain the “why now.”

Next module

1.2 — VLA anatomy: let’s open the model and see the vision encoder, backbone, and action head inside.