---
title: 'Agent0: Evolving LLM and Robotic Architectures'
url: https://www.emergentmind.com/topics/agent0
type: topic
---

# Agent0: Evolving LLM and Robotic Architectures

Searching arXiv for the cited Agent0-related papers to ground the entry in current literature.
In recent arXiv literature, **Agent0** is not a single canonical system but a reused designation for several distinct agent architectures. The most prominent usage denotes a **self-evolving LLM-agent framework** that improves from zero external training data through co-evolution between a curriculum agent and an executor agent, with tool-integrated multi-step reasoning [2511.16043]. The same label also names a **training-free Code-as-Policy robotic agent** derived in CaP-X [2603.22435], a **recommender-systems feature-discovery framework** [2507.18993], and, in a separate social-simulation lineage, **Agent\_Zero / AgentZero++** as an affective-cognitive agent-based model of collective violence [2510.05185]. Subsequent papers further extend or reinterpret the term in multimodal self-evolution, embodied play-time skill acquisition, and broader “Agent0-like” systems design [2511.19900].

## 1. Terminological scope and major lineages

The name is therefore best treated as a **polysemous technical label** whose meaning depends on domain. In current usage, the LLM-agent and embodied-robotics lineages are the most directly connected, while the recommender-systems and social-simulation uses are distinct systems that share the same surface name rather than a common implementation ancestry [2511.16043].

| Usage of “Agent0” | Domain | Defining characteristics |
|---|---|---|
| Agent0 | LLM self-evolution | Zero-external-data co-evolution of curriculum and executor agents with tool-integrated reasoning |
| CaP-Agent0 | Robot manipulation | Training-free Code-as-Policy agent with multi-turn code execution and repair |
| Agent0-VL | Vision-language reasoning | Solver/Verifier self-evolving LVLM with tool-grounded critique and self-repair |
| Agent0 | Recommender systems | Architect–Sentinel–Oracle loop for text feature discovery and prompt optimization |
| Agent\_Zero / AgentZero++ | Agent-based social simulation | Affective, cognitive, and social mechanisms for decentralized collective violence |

The main technical ambiguity arises because some papers use **Agent0** as the name of a concrete framework, while others use it as a **design reference**. “AOrchestra,” for example, is explicitly framed as a blueprint for an “Agent0” system understood as a general long-horizon autonomous orchestrator, not as the same implementation as the zero-data co-evolution framework [2602.03786]. Similarly, papers in robotics and networking often use Agent0 or Agent0-like systems as comparative or architectural reference points rather than as a single fixed codebase.

## 2. Agent0 as a zero-data self-evolving LLM-agent framework

In the self-evolving lineage, Agent0 is introduced as a way to train stronger LLM agents **without external human-curated training data**, while avoiding curriculum stagnation, single-round interaction, and weak tool integration [2511.16043]. The system contains two agents initialized from the same pretrained base model: a **Curriculum Agent** \(\pi_\theta\), which proposes tasks, and an **Executor Agent** \(\pi_\phi\), which attempts to solve them. Training alternates between curriculum evolution and executor evolution.

A central construct is the **frontier task**, defined through executor self-consistency. For a generated task \(x\), Agent0 samples \(k\) responses and defines
\[
\hat{p}(x) = \frac{1}{k}\sum_{i=1}^{k}\mathbb{I}(o_i=\tilde y),
\qquad
\tilde y = \arg\max_y \sum_{i=1}^{k}\mathbb{I}(o_i=y).
\]
The retained training set is
\[
\mathcal{D}^{(t)}=\left\{x\in X_{\text{pool}} \mid \left|\hat p(x;\pi_\phi^{(t-1)})-0.5\right|\le\delta\right\}.
\]
In experiments, the implementation uses \(k=10\), \(\delta=0.25\), and explicitly retains tasks with self-consistency between **0.3 and 0.8**. The curriculum agent is trained with **GRPO** using a composite reward that combines an uncertainty reward, a capped tool-use reward based on ` ```output ` markers, and a BLEU-based repetition penalty. The executor agent uses **multi-turn, tool-integrated rollout** with a sandboxed Python interpreter, majority-vote pseudo-labeling, and **Ambiguity-Dynamic Policy Optimization (ADPO)** to downweight noisy pseudo-labels and loosen the upper trust-region clip on more ambiguous tasks [2511.16043].

Tool use is not incidental in this formulation. The executor emits Python code blocks, pauses generation when ` ```python ... ``` ` appears, executes code in a sandbox, appends the result in ` ```output ... ``` ` form, and continues generation until a final answer is emitted in `\boxed{\cdots}` form. The curriculum is explicitly rewarded for generating tasks that induce tool use, so executor improvement feeds back into task difficulty and tool-awareness. The paper describes this as a symbiotic competition between task generation and tool-augmented solving rather than ordinary self-play.

The phrase **“zero data”** is narrower than “zero prior knowledge.” The framework still depends on pretrained base LLMs, specifically **Qwen3-4B-Base** or **Qwen3-8B-Base**, together with prompting scaffolds, tool interfaces, RL infrastructure, and an appendix-level **GPT-4o judge prompt** for answer checking. Empirically, Agent0 improves **Qwen3-8B-Base** by **18% on mathematical reasoning** and **24% on general reasoning benchmarks**. In later comparative work, it appears as a baseline in synthetic-curriculum research: EvoTD reports AVG scores of **27.8** on **Qwen3-4B-Base** and **33.5** on **Qwen3-8B-Base** for Agent0, with structured evolutionary task discovery exceeding those values on the same backbones [2605.11666].

## 3. Embodied Agent0: CaP-Agent0 and robotic descendants

In robotics, **CaP-Agent0** is the training-free embodied coding-agent framework derived from CaP-X’s study of Code-as-Policy systems [2603.22435]. It is not merely a planner or a single prompt, but an inference-time stack built around **multi-turn interaction**, **structured execution feedback**, a **Visual Differencing Module (VDM)**, an **automatically synthesized persistent skill library**, and **parallel or ensembled reasoning**. Instead of predicting low-level actions directly, the agent synthesizes executable Python programs over a robot API, executes them in a sandbox connected to the environment, observes `stdout`, `stderr`, and updated perception, and either regenerates code or terminates. CaP-Gym, the surrounding execution substrate, integrates **187 tasks** from **robosuite**, **LIBERO-PRO**, and **BEHAVIOR**.

The benchmark evidence motivating CaP-Agent0 is that frontier models remain brittle when hand-designed abstractions are removed. CaP-Bench evaluates seven core tasks—**Cube Lift**, **Cube Stack**, **Spill Wipe**, **Peg Insertion**, **Cube Re-stack**, **Two-Arm Lift**, and **Two-Arm Handover**—with **100 trials per tier** and zero-shot Pass@1. The paper reports that, despite using only low-level primitives, CaP-Agent0 achieves success rates **comparable to or exceeding human-written programs on 4 out of 7 tasks**. On **LIBERO-PRO**, its reported averages across object/goal/spatial position and task perturbations are **0.22/0.18** for object, **0.26/0.17** for goal, and **0.12/0.14** for spatial suites, while on **BEHAVIOR** mobile-manipulation tasks it improves substantially over the S3 baseline and reaches human-level task success on the soda-can task [2603.22435].

Later embodied work reframes CaP-Agent0 as a strong but still task-reactive baseline. “Playful Agentic Robot Learning” introduces **RATs** as a play-time skill-acquisition extension over CaP-Agent0. During play, RATs proposes exploratory tasks, runs code policies, verifies progress at the plan and per-step level, diagnoses failures, and distills successful executions into a frozen code skill library. The paper reports gains of **20.6 percentage points** over CaP-Agent0 on **LIBERO-PRO** and **17.0 percentage points** on **MolmoSpaces**, and shows that the learned library can be plugged back into standard CaP-Agent0 to improve **RoboSuite** and **real-world transfer** by **8.9** and **8.8** points, respectively, without fine-tuning the underlying model [2606.19419].

The robotics literature is not uniform in its assessment of Agent0-style control. SPARK treats **CaP-Agent0** as the representative multi-turn code-generation baseline and argues that its main weakness under **LIBERO-PRO** position and spatial perturbations is misplaced test-time compute: repeated re-querying and script regeneration attack the plan layer, whereas perception and grounding fail most often. In that comparison, CaP-Agent0 reports **18.2%** mean success on the original LIBERO-Pro evaluation and **23.2%** under the RATs reevaluation protocol, while SPARK reaches **43.7%**. At the same time, SPARK explicitly notes that CaP-Agent0 can outperform it on **Wipe**, **TwoArmLift**, and **TwoArmHandover**, because turn-level observation and visual differencing can help on tasks requiring mid-execution reassessment [2606.30613]. A common misconception is therefore that CaP-Agent0 is either universally dominant or universally obsolete; the later evidence instead indicates a domain-dependent trade-off between iterative code regeneration and more modular typed-plan execution.

## 4. Agent0-VL and multimodal self-evolution

**Agent0-VL** is the vision-language continuation of the self-evolving Agent0 idea [2511.19900]. It is built on a single shared-parameter LVLM that alternates between two roles: a **Solver**, which performs multi-turn tool-integrated reasoning, and a **Verifier**, which critiques each step, assigns structured self-rewards, and can trigger local self-repair. The paper formalizes the setting as a POMDP
\[
\mathcal{M}=(\mathcal{S},\mathcal{A},\mathcal{O},T,R,\gamma),
\]
where states include text context, visual features, and tool traces; actions can be textual reasoning or tool calls; and observations are textualized tool outputs. Verification produces tuples
\[
V_t=(\text{score}_t,\text{conf}_t,\text{critique}_t),
\]
with step-level scores in \([-1,1]\) and confidence in \([0,1]\).

The system’s core loop is the **Self-Evolving Reasoning Cycle (SERC)**. It begins with supervised fine-tuning on about **200k samples**, then alternates solver rollouts, stepwise verification, confidence-gated self-repair, and **GRPO** updates using a process reward that combines tool-grounded agreement, semantic reliability, and KL regularization. The confidence gate is
\[
g_t=\sigma\bigl(\kappa(\tau_c-\text{conf}_t)\bigr),
\]
so low-confidence steps are more likely to trigger repair. Training uses **Qwen2.5-VL-7B-Instruct** and **Qwen3-VL-8B** backbones, about **40k RL tasks**, and about **240k** total curated trajectories. Reported results include a **12.5% improvement** over the base model for Agent0-VL-7B, averages rising from **57.3** to **65.5** across three SERC iterations, and final averages of **65.6** for Agent0-VL-7B and **74.6** for Agent0-VL-8B. The paper also reports that removing the RL self-evolving loop causes the largest degradation, about **8.7%**, larger than removing tool use (**6.5%**) or self-repair (**2.5%**) [2511.19900].

A recurring controversy here concerns the phrase **“zero external reward evolution.”** The main evolution loop indeed uses internally generated, tool-grounded rewards rather than a separate reward model, but the appendix discloses a **short external-reward RL warm-up phase** of two epochs to stabilize tool use. The framework is therefore best described as minimizing reliance on external reward during the main self-evolving phase, rather than literally excluding all external reward during the full training lifecycle.

## 5. Other domain-specific meanings of Agent0

A separate use of the name appears in recommender systems, where **Agent0** is an LLM-agent architecture for **automatic feature discovery from raw text** [2507.18993]. Its architecture is explicitly **Architect–Sentinel–Oracle**. The **Sentinel** applies a prompt at scale to raw documents and emits comma-separated multi-value categorical features; the **Architect** rewrites the extraction prompt using the top 5 best and top 5 worst prompt-score pairs from shared memory; and the **Oracle** evaluates the resulting feature by inserting it as a new field into a smaller production-style **DCNv2** CTR model and measuring lift in **Relative Information Gain (RIG)**. The paper defines cross-entropy as
\[
\mathrm{CE}(\mathbf{p},\mathbf{y}) = -\frac{1}{N}\sum_{i=1}^{N}\left[y_i\log p_i + (1-y_i)\log(1-p_i)\right]
\]
and
\[
\mathrm{RIG}=1-\frac{\mathrm{CE}(\hat{\mathbf{p}},\mathbf{y})}{\mathrm{CE}(\bar p,\mathbf{y})},
\qquad
\bar p=\frac{1}{N}\sum_{i=1}^{N}y_i.
\]
The best discovered prompt yields a **positive lift above baseline of approximately 0.005+ RIG**, and the authors estimate a **2–3× faster** research cycle than human-driven feature engineering.

In social simulation, **AgentZero++** is not an LLM agent at all but a direct extension of Epstein’s **Agent\_Zero** framework [2510.05185]. It preserves the affective, deliberative, and contagion-based architecture of Agent\_Zero while embedding it in a **\(50\times 50\)** toroidal Civil-Violence-style grid. Its central disposition equation is
\[
D_i = A_i + P_i + C_i - \theta_i(\gamma),
\]
where affect \(A_i\), perceived risk \(P_i\), and contagion \(C_i\) are offset by an impulse-control-modulated threshold. The extension adds eight mechanisms: **age-based impulse control**, **memory-based risk estimation**, **affect-cognition coupling**, **endogenous destructive radius**, **fight-or-flight dynamics**, **affective homophily**, **retaliatory damage**, and **multi-agent coordination**. This use of the Agent0 label belongs to a different intellectual lineage and should not be conflated with the LLM-agent or robotic systems discussed elsewhere.

## 6. Agent0 as a broader systems design reference

Several recent papers do not define a system named Agent0, but explicitly use **Agent0-like** requirements as a design target. “AOrchestra” is the clearest example. It frames long-horizon autonomous task solving as orchestration over the unified tuple
\[
\text{Agent}=(\text{Instruction},\text{Context},\text{Tools},\text{Model}) = \Phi=(I,C,T,M),
\]
and restricts the orchestrator action space to
\[
\mathcal{A}_{\text{AOrchestra}}=\{\mathrm{Delegate}(\Phi),\ \mathrm{Finish}(y)\}.
\]
The orchestrator never acts directly in the environment; it curates context, chooses tools and models, and spawns ephemeral sub-agents on demand. Across **GAIA**, **SWE-Bench**, and **Terminal-Bench**, AOrchestra reports a **16.28% relative improvement** against the strongest baseline when paired with **Gemini-3-Flash**, and its appendix is explicitly written as a design blueprint for an “Agent0” system [2602.03786].

The same tendency appears in optimization and governance work. “AgentOpt” formalizes role-wise model assignment in multi-step agent pipelines as client-side optimization over combinations \(c=(m_1,\dots,m_H)\), with objective
\[
c^\star=\arg\max_{c\in M^H}J(c),
\qquad
J(c)=\mathrm{PERF}(\tau(c))-\lambda_c\,\mathrm{COST}(\tau(c))-\lambda_\ell\,\mathrm{LATENCY}(\tau(c)).
\]
It shows that, at matched accuracy, the cost gap between the best and worst model combinations can reach **13–32×**, and that **Arm Elimination** reduces evaluation budget by **24–67%** relative to brute force on three of four tasks while maintaining near-optimal accuracy [2604.06296]. For any Agent0-like system with stable planner, solver, critic, or verifier roles, that result implies that role-to-model assignment is itself a first-order systems problem rather than a mere implementation detail.

Finally, infrastructure papers increasingly treat Agent0 as the kind of software stack that needs analysis, networking, and closed-loop operational control. “AgentFlow” introduces **Agent Dependency Graphs** for recovering agents, prompts, models, capabilities, memory states, and control policies from source-code agent programs; on **5,399** real-world programs it identifies **238** projects with prompt-to-tool risks and is described as directly relevant to Agent0-like systems [2607.01640]. The “Agent Network Protocol” proposes a three-layer stack of **identity and encrypted communication**, **meta-protocol negotiation**, and **application protocol** layers for internet-scale agent interoperability, with DID-based authentication and `.well-known/agent-descriptions` for discovery [2508.00007]. “AgentxGCore” shows the same planner/executor separation in a domain-specific setting, adding an **Intent Manager**, **Monitor Tools**, **Execution Tools**, an **MCP Server**, and a **bounded sliding-window memory** for network control [2606.00417]. Taken together, these works suggest that Agent0 now functions both as a specific family of systems and as a shorthand for a broader class of autonomous, tool-using, multi-role agent architectures.

Source: https://www.emergentmind.com/topics/agent0