Agent0: Evolving LLM and Robotic Architectures

• Agent0 is a polysemous term defining multiple autonomous agent architectures with distinct implementations across various domains.
• The zero-data LLM-agent framework employs co-evolution of curriculum and executor agents, using tool-integrated multi-turn reasoning to enhance performance.
• Robotic and multimodal Agent0 variants demonstrate training-free code policy, play-time skill acquisition, and serve as design blueprints for next-generation autonomous systems.

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 (Xia et al., 20 Nov 2025). The same label also names a training-free Code-as-Policy robotic agent derived in CaP-X (Fu et al., 23 Mar 2026), a recommender-systems feature-discovery framework (Škrlj et al., 25 Jul 2025), and, in a separate social-simulation lineage, Agent_Zero / AgentZero++ as an affective-cognitive agent-based model of collective violence (Malhotra et al., 5 Oct 2025). Subsequent papers further extend or reinterpret the term in multimodal self-evolution, embodied play-time skill acquisition, and broader “Agent0-like” systems design (Liu et al., 25 Nov 2025).

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 (Xia et al., 20 Nov 2025).

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 (Ruan et al., 3 Feb 2026). 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 (Xia et al., 20 Nov 2025). 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 (Xia et al., 20 Nov 2025).

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 (Ye et al., 12 May 2026).

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 (Fu et al., 23 Mar 2026). 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 (Fu et al., 23 Mar 2026).

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 (Zhang et al., 17 Jun 2026).

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 (Grant et al., 29 Jun 2026). 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 (Liu et al., 25 Nov 2025). 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 $\pi_\phi$0 and confidence in $\pi_\phi$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

$\pi_\phi$2

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%) (Liu et al., 25 Nov 2025).

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 (Škrlj et al., 25 Jul 2025). 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

$\pi_\phi$3

and

$\pi_\phi$4

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 (Malhotra et al., 5 Oct 2025). It preserves the affective, deliberative, and contagion-based architecture of Agent_Zero while embedding it in a $\pi_\phi$5 toroidal Civil-Violence-style grid. Its central disposition equation is

$\pi_\phi$6

where affect $\pi_\phi$7, perceived risk $\pi_\phi$8, and contagion $\pi_\phi$9 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 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

$x$0

and restricts the orchestrator action space to

$x$1

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 (Ruan et al., 3 Feb 2026).

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 $x$2, with objective

$x$3

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 (Hua et al., 7 Apr 2026). 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 (Wang et al., 2 Jul 2026). 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 (Chang et al., 18 Jul 2025). “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 (Barbosa et al., 29 May 2026). 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.