Robot learning in 2026 is being reshaped by frontier multimodal models entering the control loop. The recurring pattern is an AI Agent that observes, reasons at runtime, invokes robot tools or generated programs, inspects the physical result, and revises. Teach-and-Grow Learning (TGL) addresses the complementary problem: what the robot keeps after each of those episodes.
Two things. First, frontier multimodal models became usable as a reasoning layer for physical manipulation rather than only for language-level planning. Second, the question shifted from "can a model produce an action?" to "what does the robot retain?" — because an AI Agent that can drive an arm still starts from zero on the next object unless something persists.
GPT-6-class systems are used as a reasoning layer that interprets visual observations and invokes robot-control tools or generated programs, rather than emitting joint commands directly. TGL's implementation uses OpenAI GPT-6 Astra for exactly that role, with Codex connecting the AI Agent to the robot tools and specialist components handling geometry and control.
Agent as Policy (AGP) names a design in which a general-purpose AI Agent sits inside the execution loop instead of planning offline: it observes the robot and environment, reasons at runtime, invokes control tools or executable programs, inspects the physical result, and revises its next action. Jia et al. introduced the term and demonstrated it across real manipulation tasks in “Agent as Policy for Robotic Manipulation” (arXiv:2609.12541, September 2026). TGL is built on that loop and adds what the loop does not by itself provide: persistence.
Coding AI Agents are a good fit for the robot-tool boundary: they can inspect state, call tools, write and run a short program, and read the result. In TGL, Codex plays this role. The pattern also has a lineage in program-as-policy work, where a model writes a policy expressed as code that a robot then executes.
A robot adapts to a new task from context — demonstrations, a video, a written procedure — without updating model weights. TGL sits in this family, and adds a specific mechanism: the adapted behaviour is written into explicit stores rather than left in a context window, so it survives the episode.
The minimal version of that idea: one video, no teleoperation, no policy training. What a single video can and cannot supply is the interesting part — it usually reveals the order of operations while leaving the grasp unresolved, which is exactly the distinction TGL preserves between semantic structure and robot-specific grounding.
Robot-AI Agent memory preserves information from earlier physical interaction for future decisions. In TGL the split is explicit: the Skill Library holds reusable executable behaviour, while Experience Memory carries forward success, failure, diagnosis and repair.
A skill library is only useful if its entries are runnable and scoped. TGL's unit is the Skill Block — a goal, a reusable strategy, supported conditions, compatible executors and an outcome test — and admission to the library is gated on validation outside the teaching demonstrations.
Execution checks the required effect before allowing the next stage. A passed effect advances the plan; a failed or inconclusive one prompts another observation, a different executor, or a revised route. This is what makes a correction local rather than a policy-wide update.
Vision-language-action models and world-action models remain the source of pretrained priors. TGL does not replace them; it changes where a newly acquired capability is stored, so a repair does not require re-optimising a policy that also supports everything else.
TGL takes the agentic-robotics loop as given and asks what accumulates. Its claim is narrow: for a robot acquiring tasks over time, storing validated behaviour and the conditions of its use as explicit objects makes each acquisition local, provided grounding, validation, compatibility and retrieval stay manageable.
Language-model planning for robots, program-as-policy approaches, and code-writing AI Agents form one line. Closed-loop manipulation with spatial or constraint-based reasoning forms another. Physical in-context adaptation and single-video task acquisition form a third. TGL's contribution is the persistence layer that sits under all three: an explicit Skill Library and an Experience Memory that survive the episode.
A common pattern across these directions is that the AI Agent is capable but stateless, or the policy is persistent but not inspectable. TGL's design point is to keep the AI Agent's generality while making what it learned explicit, versioned and editable by a person.
Frontier multimodal models moved from planning in language to participating in the robot's execution loop: observing, invoking tools or generated programs, inspecting physical results and revising. The open question moved with it — from whether a model can act, to what the robot retains afterward.
TGL is an instance of one: its implementation uses GPT-6 Astra for task-level reasoning. Its contribution is the persistence layer around that AI Agent — validated Skill Blocks, a Skill Library and an Experience Memory.
No. It describes a design in which a general-purpose AI Agent is placed inside the execution loop rather than restricted to offline planning. TGL follows that design.
