AI Agents and Autonomous Systems

An Autonomous AI Agent is a computational system capable of perceiving its environment, maintaining internal state, formulating multi-step plans, and taking actions through external tools (APIs, code interpreters, or robotic actuators) to achieve a specified goal with minimal or no human intervention (Russell & Norvig, 2020). In the context of modern generative AI, agentic systems wrap Large Language Models (LLMs) in scaffolding that allows them to interact with the world, bridging the gap between stateless text generation and long-horizon environmental execution.

The transition from language models to autonomous agents marks a fundamental shift from AI as an "oracle" (a passive tool that answers questions) to AI as an "actor" (an entity that changes the state of the world).

An LLM is merely a stateless function predicting the next token. An agentic system leverages the LLM as a central reasoning engine, surrounding it with an architectural loop. The significance of this paradigm includes:

1. Action in the Loop: Agents can invoke external tools to execute code, query databases, or browse the web, escaping the confines of their static pretraining data.
2. Error Recovery: Through self-reflection and iterative execution, agents can identify when a tool call failed or an assumption was incorrect, and attempt alternative strategies.
3. Economic Automation: Capable agents can execute prolonged knowledge-work workflows—such as resolving a GitHub issue or conducting a systematic literature review—that require days of persistent, multi-step execution.

The concept of the rational agent has defined artificial intelligence since its inception. Early Symbolic AI relied on state-space search and automated planning (e.g., the General Problem Solver, late 1950s [VERIFICATION NEEDED: cite Newell, Shaw & Simon]), where actions were explicitly programmed as logical state transitions. Reinforcement Learning (RL) agents later achieved strong game-playing performance by learning policies through trial-and-error in simulated environments with fully known rules, for example AlphaGo (Silver et al., 2016) and AlphaGo Zero, which learned Go through self-play without human game data (Silver et al., 2017).

However, real-world internet and software environments are infinitely more complex and partially observable. The modern era of LLM-based agents was catalyzed by the ReAct (Reasoning and Acting) framework (Yao et al., 2023), which reported that prompting an LLM to interleave reasoning traces with actions improved success over imitation and reinforcement-learning baselines on the interactive benchmarks evaluated (ALFWorld and WebShop), and reduced hallucination relative to chain-of-thought alone on question-answering tasks. Open-source frameworks for building agent loops, such as AutoGPT and LangChain, appeared in 2023 [VERIFICATION NEEDED: no primary source cited; dates and adoption not confirmed], and early systems were reported to have reliability limitations (see Section 7).

#4.1 The Agent Loop

The core architecture of an LLM-based agent is an iterative control loop:

1. Observation: The agent receives the current state of the environment (e.g., user prompt, tool output, or error message).
2. Reasoning (Reflection / Planning): The LLM processes the observation, decomposes the high-level goal into sub-tasks, and decides what to do next.
3. Action (Tool Execution): The LLM outputs a structured command (often JSON) that the scaffolding executes via an external tool.
4. Evaluation: The result of the action becomes the new observation, and the loop repeats until the model outputs a termination sequence.

#4.2 Core Architecture Components

• Memory: Agents require state persistence. Short-term memory is maintained within the LLM's context window. Long-term memory (persistent memory) is typically implemented via vector databases, allowing the agent to perform similarity searches (Retrieval-Augmented Generation, RAG) to recall past interactions or factual knowledge.
• Planning: Breaking a complex task into a Directed Acyclic Graph (DAG) of sub-tasks. Techniques include Chain of Thought (Wei et al., 2022) and Tree of Thoughts (Yao et al., 2023b), which allow the agent to explore multiple reasoning paths.
• Tools: Executable functions bounded by precise schemas. These include calculators, Python interpreters, web browsers, and SQL executors.

#4.3 Scripted Workflows vs. General Autonomy

It is crucial to distinguish true agents from heavily scripted agentic workflows.

• A scripted workflow is a deterministic state machine where an LLM is used merely to route decisions or format text at specific nodes.
• A general autonomous agent is given a high-level goal and must dynamically discover the sequence of tool calls and states required to reach the goal. True autonomy is vastly harder to reliably engineer due to compounding errors.

• Single-Agent Systems: A monolithic LLM orchestrating the entire loop. Prone to losing context or becoming trapped in repetition loops during complex tasks.
• Multi-Agent Systems: Architectures where specialized agents (e.g., a "Coder", a "Reviewer", a "Project Manager") communicate via message passing to achieve a goal. Frameworks such as AutoGen (Wu et al., 2023) let multiple LLM agents converse to solve tasks.
• Hierarchical Agents: A supervisor agent delegates sub-tasks to subordinate worker agents, mirroring human organizational structures.

• Software Engineering: Agents such as SWE-agent (Yang et al., 2024) use an agent-computer interface to navigate code repositories, edit files and run commands in order to resolve GitHub issues. Such systems are evaluated on SWE-bench (Jimenez et al., 2024); current resolve rates change quickly and are not given here (see CAP-BENCH-001).
• Scientific Research: "ChemCrow" and similar agents integrate LLMs with computational chemistry tools; the ChemCrow authors report that their agent planned and, in some demonstrations, executed syntheses of a small number of compounds (Bran et al., 2024).
• Web Navigation: Agents operate websites through browser interfaces. On the WebArena benchmark, the best GPT-4-based agent reported at publication achieved an end-to-end task success rate of 14.41% against 78.24% for humans (Zhou et al., 2023; a 2023 result, since superseded by later systems [VERIFICATION NEEDED: no later figure retrieved]).

#Operational Advantages

• Automates "glue work"—tasks that require human reasoning but are too bespoke to be automated by traditional rigid code.
• Operates continuously without human fatigue, scaling asynchronously.

#Critical Limitations and Failure Modes

• Compounding Errors: In long-horizon tasks, a single hallucinated assumption or failed tool call early in the plan can derail the entire execution; agents often fail to detect or recover from such errors (the mechanism is not settled).
• Infinite Loops: Agents can get "stuck" executing the same failed tool call with the exact same parameters, unable to explore out of the local minimum.
• Context Degradation: As the agent loop fills the context window with long, verbose tool outputs, models can use information in long contexts unevenly, for example performing worse on material placed in the middle of a long input (Liu et al., 2024), which may contribute to agents losing track of original instructions.
• Cost and Latency: Executing an iterative ReAct loop with 20 steps using a frontier LLM is typically more expensive and slower than executing deterministic code [VERIFICATION NEEDED: no cost figures or date supplied].

#Security and Safety Risks

• Indirect Prompt Injection: An agent browsing the web might ingest a hidden malicious prompt on a webpage, which can override its original instructions and induce unauthorized actions, as Greshake et al. (2023) demonstrated against specific LLM-integrated applications. Defenses are an active research area, and the problem is not resolved in general [VERIFICATION NEEDED: cite defense literature].
• Excessive Permissions: Granting an agent write-access to databases or cloud infrastructure risks catastrophic data deletion if the agent hallucinates a destructive command.

Agent reliability is a fast-moving, contested question, and this article cites no survey of practitioner opinion. Benchmark evidence from 2023 showed large gaps between agents and humans on realistic tasks (for example 14.41% versus 78.24% on WebArena; Zhou et al., 2023), but later systems have improved and current results should be taken from dated leaderboards [VERIFICATION NEEDED: add dated SWE-bench / WebArena figures with source and as-of date]. Commonly recommended deployment practices include human approval gates for consequential actions, sandboxed execution and least-privilege tool access, and many production systems constrain agents with predefined workflows (see Section 4.3); no source is cited here for how widely these practices are adopted.

• Near-Term (0–3 Years) [speculative forecast, no forecast record assigned]: Agentic reliability may improve through specialized "Action Models" fine-tuned explicitly for tool use and JSON generation, moving away from relying on general-purpose chat models.
• Medium-Term (3–10 Years) [speculative]: Possible development of shared runtime layers for agents (sometimes called "agent operating systems", a term used by some proposals rather than an established standard), providing unified interfaces for memory, tool execution, and permission management.
• Long-Term (10+ Years) [speculative]: Possible convergence of digital agents with embodied robotics, requiring the integration of continuous real-world physics into agent planning loops.

• Foundational Concepts:
  • TECH-LLM-001 Large Language Models: The cognitive engine of modern agents.
• Related Methods & Technologies:
  • TECH-RL-001 Reinforcement Learning: The mathematical basis for sequential decision making.
  • CAP-BENCH-001 AI Evaluation, Benchmarking & Contamination: The difficulty of measuring agent reliability (e.g., SWE-bench).
• Advanced Implications & Future Trajectories:
  • AGI-PATH-001 Scientific Pathways to AGI: Test-time compute and agentic reasoning as pathways to AGI.
  • SAFE-ALIGN-001 The AI Alignment Problem: Aligning models to safely execute tools.

A multi-agent system is a set of two or more autonomous decision-making entities that act in a shared environment and whose outcomes depend on one another's behaviour. In machine learning the term covers multi-agent reinforcement learning (MARL), where several learning agents optimise their own or a shared objective, and, more recently, LLM-based multi-agent systems, where several instances of language models with assigned roles exchange messages to complete tasks.

The single-agent framework in TECH-RL-001 Reinforcement Learning treats the environment as fixed. With several learners the environment from each agent's viewpoint changes as the others learn, which breaks the assumptions behind many convergence guarantees (Zhang et al., 2021). Multi-agent settings cover cooperation (teams of robots, coordinated software agents), competition (games) and mixed motives (negotiation), and they are relevant to safety because behaviours can emerge from interaction that no individual agent was trained to produce (Baker et al., 2020).

This article distinguishes two bodies of work with different maturity: the MARL literature, with formal models and benchmarked algorithms, and LLM-based multi-agent frameworks, which are recent and evaluated mainly on task benchmarks and case studies. Single-agent architecture is in TECH-AGENT-001 Autonomous AI Agents, which mentions multi-agent frameworks briefly; this article covers the interaction problem itself.

Multi-agent systems originated in distributed AI and game theory before deep learning. Zhang, Yang and Başar (2021) review MARL theory built on Markov (stochastic) games and extensive-form games, grouped into fully cooperative, fully competitive and mixed settings.

Deep MARL grew from 2016–2018. Lowe et al. (2017) proposed MADDPG for mixed cooperative-competitive environments. Foerster et al. (2018) introduced COMA, using a centralised critic and a counterfactual baseline to assign credit to individual agents. Rashid et al. (2018) introduced QMIX, which factorises a joint value function monotonically into per-agent values. Yu et al. (2022) reported that a carefully implemented multi-agent PPO performs strongly across four cooperative benchmarks, challenging the assumption that off-policy methods are necessarily better.

Large-scale game systems demonstrated multi-agent learning at scale: Jaderberg et al. (2019) reported human-level play in a 3-D first-person team game with population-based reinforcement learning; Vinyals et al. (2019) reported Grandmaster-level play in StarCraft II; Baker et al. (2020) showed hide-and-seek agents developing a sequence of strategies through an automatically generated curriculum; and Meta Fundamental AI Research Diplomacy Team (FAIR) et al. (2022) reported Cicero, which combined a language model with planning and reinforcement learning in the negotiation game Diplomacy.

From 2023, language models were composed into multi-agent systems: Park et al. (2023) simulated generative agents; Li et al. (2023) proposed CAMEL role-playing; Du et al. (2023) proposed multiagent debate; Hong et al. (2023) MetaGPT; and Wu et al. (2023) the AutoGen framework. Cemri et al. (2025) published a large annotated-trace study and taxonomy of failures in such systems.

#4.1 Formal models

A Markov game for $N$ agents is a tuple $(\mathcal{S}, \{\mathcal{A}_i\}_{i=1}^N, P, \{r_i\}_{i=1}^N, \gamma)$ with joint transition $P(s' \mid s, a_1,\dots,a_N)$ and per-agent rewards $r_i(s,a_1,\dots,a_N)$. When agents observe only local information, the cooperative case is a decentralised partially observable MDP (Dec-POMDP), with a shared reward and each agent conditioning on its own observation history. Agent $i$ seeks a policy $\pi_i$ maximising $\mathbb{E}\big[\sum_t \gamma^t r_i\big]$, but the value of $\pi_i$ depends on the other agents' policies $\pi_{-i}$. For general-sum games the solution concept is typically a Nash equilibrium, a profile in which no agent gains by unilaterally changing its policy; for two-player zero-sum games, equilibrium play is also minimax-optimal (Zhang et al., 2021).

#4.2 Core difficulties

• Non-stationarity: from agent $i$'s perspective the transition kernel changes as $\pi_{-i}$ changes during learning.
• Credit assignment: with a shared team reward, determining each agent's contribution is hard. COMA computes a counterfactual baseline that marginalises one agent's action while holding the others' fixed (Foerster et al., 2018).
• Scalability: the joint action space grows exponentially with the number of agents.
• Partial observability and communication: what agents may observe or say to each other is a design choice.
• Equilibrium selection and generalisation: agents may fail against partners or opponents not seen in training.

#4.3 Centralised training, decentralised execution

A common design is to give a critic access to global state or joint actions during training, while each actor uses only local observations at deployment. COMA uses a centralised critic with decentralised actors (Foerster et al., 2018); MADDPG likewise (Lowe et al., 2017). QMIX learns a mixing network constrained to be monotonic so that maximising the joint value is consistent with each agent maximising its own utility (Rashid et al., 2018). Yu et al. (2022) report that PPO with a centralised value function, little tuning and no domain-specific modifications is competitive on particle-world, StarCraft Multi-Agent Challenge, Google Research Football and Hanabi benchmarks.

#4.4 Competition, self-play and populations

In competitive settings agents train against copies or populations of themselves. Jaderberg et al. (2019) used population-based training with learned internal rewards. Vinyals et al. (2019) combined supervised learning from human games with multi-agent reinforcement learning against a league of agents to reach Grandmaster level on the public Battle.net ladder. Baker et al. (2020) report six distinct emergent strategy phases in hide-and-seek, each creating pressure for the other team to adapt, and conclude that competition scaled better than intrinsic-motivation baselines on their transfer tests.

#4.5 Language-model multi-agent systems

Here an agent is typically a language model instance with a role prompt, memory and tools; coordination happens via text messages. Patterns reported in the literature include: debate, in which several instances propose and critique answers over rounds, which Du et al. (2023) report improves mathematical and strategic reasoning and factual accuracy; role-playing pairs (Li et al., 2023); assembly-line pipelines that encode standard operating procedures so that agents check each other's intermediate outputs (Hong et al., 2023); a general conversation-programming framework (Wu et al., 2023); and agent societies with memory, reflection and planning that produce believable social behaviour (Park et al., 2023, with 25 agents in a simulated town). Cicero shows a hybrid: a language model for dialogue plus planning and reinforcement learning for strategy (FAIR et al., 2022).

• By objective structure: fully cooperative (shared reward), fully competitive (zero-sum), mixed-motive (general-sum).
• By information: fully observable, partially observable, with or without communication channels.
• By training paradigm: independent learners, centralised training with decentralised execution, fully centralised, population-based self-play.
• By agent type: reinforcement-learning agents versus LLM-based agents with natural-language communication.
• By topology (LLM systems): debate/peer groups, hierarchical (manager and workers), sequential pipelines, and free-form conversation.
• By human involvement: fully automated versus human-in-the-loop (supported in AutoGen according to Wu et al., 2023).

Games (research milestones). Team first-person play (Jaderberg et al., 2019), StarCraft II (Vinyals et al., 2019), and Diplomacy, where across 40 games of an anonymous online league Cicero achieved more than double the average score of human players and ranked in the top 10% of participants who played more than one game (FAIR et al., 2022). These are results in games with defined rules; they are not evidence of general negotiation competence outside them.

Simulation and social modelling. Generative-agent sandboxes (Park et al., 2023) are used to study believable behaviour; their evaluation is by human judgement of believability and by ablation, not by validated prediction of real populations.

Software and task automation. MetaGPT and AutoGen target software-engineering and other task benchmarks (Hong et al., 2023; Wu et al., 2023); see TECH-CODE-001 AI Code Generation. These results are developer-reported on their chosen benchmarks.

Robotics. Coordinated teams of physical robots are an application area for cooperative MARL; this article cites no specific deployment and treats the area as research (see TECH-ROBOT-001 Robotics and Embodied AI).

Advantages. Division of labour and specialisation; parallelism; decentralised execution; in LLM systems, the possibility that cross-checking by multiple instances reduces some errors (Du et al., 2023; Hong et al., 2023).

Limitations. (1) Non-stationarity and weak theory: Zhang et al. (2021) describe the theory of MARL as relatively lacking compared with empirical results. (2) Training cost: the game-playing systems above required very large compute and engineered training leagues. (3) In LLM systems, the benefit of multiple agents over a single well-prompted model is not established in general. Cemri et al. (2025) analysed more than 1,600 annotated traces from seven multi-agent frameworks and proposed a taxonomy of 14 failure modes in three categories (system design issues, inter-agent misalignment, task verification), indicating that failures are frequent and structured. (4) Compounding errors, cost multiplication from many model calls, and difficult attribution of responsibility. (5) Safety: emergent behaviours (Baker et al., 2020) and interactions among deployed agents are hard to evaluate; systematic evidence on large-scale agent ecosystems is sparse.

Unresolved. Whether LLM multi-agent organisation yields gains that scale beyond what better single-agent prompting, tools or training provide; how to evaluate agent teams (see CAP-AGENTEVAL-001 Evaluating Autonomous Agents); how to ensure cooperation is robust to partners not seen in training.

As of 2026-10-15: centralised-training methods (COMA, MADDPG, QMIX) and the effectiveness of tuned PPO baselines are documented on standard cooperative benchmarks (Yu et al., 2022; Foerster et al., 2018; Rashid et al., 2018) and are Well Supported for the tested benchmarks. Game-playing milestones are peer-reviewed. LLM multi-agent evidence is mostly Preliminary: framework papers (preprints, developer-reported benchmarks) and one failure-taxonomy study (Cemri et al., 2025). Systems and benchmark rankings change quickly and are not tabulated; see MODEL-001.

Observed trends. Interest has shifted from game-playing leagues to LLM-based teams for coding and research tasks, alongside growing attention to failure analysis.

Medium and long term. Whether multi-agent organisation becomes the dominant way to build capable systems, or is absorbed into stronger single models with tool use, is an open question; this article asserts no forecast and attaches no FCST- record. Risks of interacting agents are discussed in SAFE-ALIGN-001 AI Alignment in general terms only.

• Foundational Concepts:
  • TECH-AGENT-001 Autonomous AI Agents: The single-agent loop that multi-agent systems compose.
  • TECH-RL-001 Reinforcement Learning: MDP and policy-gradient foundations.
• Related Methods & Technologies:
  • TECH-LLM-001 Large Language Models: Language backbone of LLM agent teams.
  • TECH-CODE-001 AI Code Generation: A leading application of agent teams.
  • TECH-ROBOT-001 Robotics and Embodied AI: Physical multi-robot settings.
• Evaluation and Safety:
  • CAP-AGENTEVAL-001 Evaluating Autonomous Agents: Agent evaluation methodology.
  • SAFE-ALIGN-001 AI Alignment: Alignment in multi-agent contexts.

Embodied AI is the study and engineering of artificial agents that perceive and act through a physical (or physically simulated) body, so that their learning and behaviour are shaped by sensing, actuation and real-world dynamics. Robot learning is the subset that uses machine learning, as opposed to hand-engineered models and controllers, to produce robot behaviour.

Language and image models operate on digital data in which errors are cheap and data are plentiful. Robots must act in continuous, partially observed environments with contact dynamics, latency and safety constraints, and each real-world trial costs time and risks hardware damage. Embodied AI is therefore a distinct engineering regime, and it is a frequent test of claims about general intelligence, because physical competence requires integrating perception, planning and control (see AGI-WM-001 World Models and APP-PHYS-001 AI in Industry, Robotics and Autonomous Vehicles).

Current research tries to import the recipe of large-scale pretraining from language and vision into robotics, producing general-purpose "vision-language-action" models (Brohan et al., 2023b; Kim et al., 2024). Whether this recipe will yield reliable general-purpose manipulation is open, and this article separates demonstrated results from claims.

Classical robotics decomposed the problem into state estimation, planning and feedback control built on analytic models. Machine learning entered first through perception and then through control. Levine et al. (2016) trained policies mapping camera images directly to motor torques, arguing for joint (end-to-end) training of perception and control. Reinforcement learning in simulation followed, with the principal obstacle being the reality gap between simulated and real dynamics. Tobin et al. (2017) proposed domain randomization, training in simulation with randomised rendering so that real images appear as another variation. OpenAI et al. (2019) used automatic domain randomization to train, in simulation only, a controller for a robot hand that solved a Rubik's cube. Lee et al. (2020) reported a locomotion policy trained in simulation and deployed on a legged robot over challenging terrain. Kaufmann et al. (2023) described Swift, a drone-racing system that combined simulation-trained reinforcement learning with real-world data and that, according to the authors, won several head-to-head races against three human champions and set the fastest recorded race time.

From 2022, large pretrained models were integrated. Ahn et al. (2022) (SayCan) used a language model to propose actions and learned value functions to ground them in what the robot could actually do. Driess et al. (2023) trained PaLM-E, an embodied multimodal language model. Brohan et al. (2023a) trained RT-1 on large-scale real robot data, and Brohan et al. (2023b) RT-2 by co-fine-tuning vision-language models on robot trajectories and web data. Open X-Embodiment pooled data across institutions (Open X-Embodiment Collaboration, 2024), and later open and commercial models followed (Kim et al., 2024; Black et al., 2024).

#4.1 The control problem

A robot interacts with an environment as a partially observable Markov decision process (see TECH-RL-001 Reinforcement Learning): at each step it receives observations $o_t$ (camera images, joint states, force readings) and issues an action $a_t$ (joint targets, end-effector velocities, torques). A policy $\pi_\theta(a_t \mid o_{\le t}, \ell)$ may be conditioned on a language instruction $\ell$. Typical control rates are tens of hertz for manipulation and higher for dynamic locomotion or flight; large models must meet these latency budgets, often by predicting short chunks of future actions.

#4.2 Learning paradigms

Imitation learning (behaviour cloning) fits $\pi_\theta$ to demonstration trajectories by supervised loss $\mathbb{E}\big[\|\,a_t - \pi_\theta(o_t)\,\|^2\big]$ or a likelihood loss. Errors compound because the policy drifts into states absent from the demonstrations. Zhao et al. (2023) addressed this for fine-grained bimanual tasks by predicting action sequences with a transformer (Action Chunking with Transformers) on low-cost hardware; the authors report learning six real-world tasks from about ten minutes of demonstrations and success rates of 80–90% on tasks such as slotting a battery. Chi et al. (2023) model the policy as a conditional denoising diffusion process, which can represent multimodal action distributions, and report an average 46.9% improvement over prior methods across 12 tasks from four benchmarks (see TECH-DIFF-001 Diffusion Models).

Reinforcement learning optimises expected return through trial and error, usually in simulation because real-world sample cost is prohibitive. Sim-to-real transfer relies on randomisation of physical and visual parameters (Tobin et al., 2017; OpenAI et al., 2019) or on adaptation methods surveyed by Zhao et al. (2020).

#4.3 Foundation models in the loop

Two integration patterns exist. In modular grounding a language model produces a high-level plan and a library of learned skills and value functions filters it for feasibility (Ahn et al., 2022). In end-to-end vision-language-action (VLA) models, a pretrained vision-language model is trained to output robot actions represented as tokens or via a dedicated action head; RT-2 co-fine-tunes on robot trajectories and web-scale vision-language tasks, with actions written as text tokens (Brohan et al., 2023b). OpenVLA is a 7-billion-parameter open VLA trained on 970,000 real-world demonstrations; its authors report 16.5% higher absolute task success than the 55-billion-parameter RT-2-X across 29 tasks (Kim et al., 2024). The $\pi_0$ model combines a pretrained vision-language model with a flow-matching action head, trained on data from multiple robot types (Black et al., 2024).

#4.4 Data

The principal bottleneck is robot data. Open X-Embodiment assembled data from 22 robots across 21 institutions, covering 527 skills and 160,266 tasks, and reported "positive transfer": a high-capacity model trained on pooled data improved performance on multiple robots relative to training on single-robot data (Open X-Embodiment Collaboration, 2024). Teleoperation, simulation and human video are alternative data sources.

• By embodiment: fixed-base manipulators, mobile manipulators, bimanual systems, legged robots, humanoids, drones, autonomous vehicles.
• By policy class: regression-based, transformer-based, diffusion/flow-based, hybrid language-conditioned VLAs.
• By learning signal: imitation, RL, mixed pipelines combining pretraining, supervised fine-tuning and RL.
• By integration: modular (language planner plus skills) versus end-to-end.
• By training venue: real-world only, simulation only with transfer, or sim-plus-real.

Deployed (outside the scope of learned generalist policies). Industrial manipulators in structured cells and warehouse systems are widely used; most rely on conventional programming with learned perception components. This article does not catalogue such deployments.

Research demonstrations with published evidence. Legged locomotion over rough terrain (Lee et al., 2020); in-hand manipulation (OpenAI et al., 2019); drone racing against champions (Kaufmann et al., 2023); mobile-manipulator instruction following (Ahn et al., 2022); multi-task manipulation and instruction generalisation on real robots (Brohan et al., 2023a, 2023b); laundry folding, table cleaning and box assembly (Black et al., 2024, as reported by the authors).

Not established. Reliable, unsupervised household or open-ended general-purpose manipulation across arbitrary environments has not been demonstrated in the cited literature. Statements by developers about commercial humanoid or general-purpose robots are classified as claims pending independent evaluation.

Advantages. Learned policies can handle perception noise and contact dynamics that are hard to model analytically, and pretrained models supply semantic generalisation, such as following instructions that do not appear in robot data (Brohan et al., 2023b).

Limitations. (1) Data scarcity and cost. (2) Reality gap in simulation-trained systems (Zhao et al., 2020). (3) Evaluation: results are reported on different robots, tasks and success criteria, with few shared physical benchmarks, so cross-paper comparisons are weak; the RT-2 and OpenVLA numbers above are developer-reported on their own task suites. (4) Safety: learned policies lack formal guarantees, and failures are physical. (5) Latency and compute: large models strain onboard control loops. (6) Hardware reliability and cost.

Unresolved. Whether pooled cross-embodiment pretraining scales as language pretraining did; the role of explicit world models versus end-to-end policies; how to certify safe behaviour for learned controllers; the relative value of simulation, teleoperation and human video as data sources.

As of 2026-10-15, the following are documented in peer-reviewed or archival sources: simulation-trained policies can transfer to real robots in specific tasks (Section 6), pretrained vision-language models can be adapted into robot policies and can improve generalisation to novel instructions in the authors' evaluations, and pooled multi-robot data can improve per-robot performance in at least the tested settings (see section 12). Independent, standardised evaluation of generalist robot policies is limited, and developer-reported success rates should be treated as Preliminary. The identities, specifications and prices of current commercial robot platforms change quickly and are not listed here; use MODEL-001, FACT-001 and TIME-001.

Observed trends. Policies have moved from single-task controllers to multi-task language-conditioned models trained on pooled data; diffusion and flow-matching action heads have become common.

Forecast.

Medium and long term. Beyond this record the article asserts no forecast.

• Foundational Concepts:
  • TECH-RL-001 Reinforcement Learning: The control-learning framework.
  • TECH-DL-001 Deep Learning: Perception and policy networks.
• Related Methods & Technologies:
  • TECH-AGENT-001 Autonomous AI Agents: Software agents sharing the perceive-plan-act loop.
  • TECH-LLM-001 Large Language Models: Language backbones for planning and VLAs.
  • TECH-DIFF-001 Diffusion Models: Basis of diffusion policies.
  • TECH-MM-001 Multimodal Foundation Models: Vision-language pretraining.
• Applications and Implications:
  • APP-PHYS-001 AI in Industry, Robotics and Autonomous Vehicles: Deployment context.
  • AGI-WM-001 World Models: Internal models for planning.