agent0-symbiotic-evolution

name	agent0-symbiotic-evolution
title	Agent0: Unleashing Self-Evolving Agents from Zero Data via Symbiotic Competition
version	0.0.2
engine	skillxiv-v0.0.2-claude-opus-4.6
license	MIT
url	https://arxiv.org/abs/2511.16043
keywords	["Agent Training","Self-Evolution","Curriculum Learning","Symbiotic Competition","Zero-Data Learning"]
description	Train agents from scratch without human-annotated data via symbiotic competition—curriculum agent proposes progressively harder tasks while executor agent learns to solve them, creating autonomous self-reinforcing loops.

Train Agents from Zero Data via Symbiotic Curriculum Competition

Most agent training requires human-curated task datasets or expert demonstrations. Agent0 breaks this dependency via symbiotic competition: two agents create a self-reinforcing loop without external data. A Curriculum Agent proposes increasingly difficult tasks; an Executor Agent learns to solve them. As the executor improves, the curriculum agent escalates difficulty, creating an automatic curriculum.

This achieves significant performance gains (18% on math, 24% on reasoning benchmarks) from a base model with zero human-annotated training data—the only input is the problem domain specification.

Core Concept

Training agents typically requires:

1. Task datasets (curated by humans)
2. Reward models (trained on human preferences)
3. Expert demonstrations (for imitation learning)

Agent0 eliminates these by creating two complementary agents:

1. Curriculum Agent: Proposes novel tasks from the problem space; initially simple, escalates difficulty as executor improves
2. Executor Agent: Solves proposed tasks; learns from successes and failures

The feedback loop: Executor improves → Curriculum escalates → harder tasks → Executor gets better signal → loops. This creates high-quality curriculum learning without human intervention.

Architecture Overview

• Curriculum Agent: LLM that generates tasks conditioned on executor capability level; uses tool-aware task generation
• Executor Agent: Solves curriculum tasks via RL; builds tool integration capability progressively
• Capability Assessment: Track executor performance level (easy/medium/hard); feed to curriculum for difficulty adjustment
• Tool Integration: Curriculum proposes tasks requiring specific tools; executor learns which tools to use when
• Self-Reinforcement: Executor improvement directly increases curriculum difficulty, creating positive feedback

Implementation Steps

Step 1: Define Problem Space and Tool Interface.

class ProblemDomain:
    """
    Specification of task domain (math, coding, QA, etc.)
    and available tools for solving.
    """
    def __init__(self, domain_name='math', tools=):
        .domain_name = domain_name
        .tools = tools  {}
        .capability_level =   

     ():
        
        .tools[tool_name] = {
            : fn,
            : description,
            : 
        }

     ():
        
        descriptions = []
         name, tool_info  .tools.items():
            descriptions.append()
         .join(descriptions)

     ():
        
        
         .domain_name == :
             ._evaluate_math(task, solution)
         .domain_name == :
             ._evaluate_code(task, solution)
        :
             ._evaluate_generic(task, solution)

     ():
        
        :
            answer = extract_answer(solution)
            correct = (answer - task[]) < 
             correct,   correct  
        :
             ,