Skip to main content Accueil Créateurs adu2021 skillxiv agent0-symbiotic-evolution
agent0-symbiotic-evolution 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.
Aller à l'installation Skills Marketplace Découvrez et explorez les compétences IA créées par la communauté.
Installer avec Codex ou Claude Copiez ce prompt, collez-le dans Codex, Claude ou un autre assistant, puis laissez-le vérifier la page du skill et l'installer pour vous.
Afficher les détails du prompt Une commande directe contourne le prompt de vérification. Examinez la source avant de l'exécuter.
npx skills add https://github.com/ADu2021/skillXiv --skill agent0-symbiotic-evolutionLa commande reste sur une seule ligne. Faites défiler horizontalement pour la vérifier avant de la copier.
Vous préférez une copie locale ? Téléchargez les fichiers actuellement disponibles dans SkillsMP.
Télécharger Zip Téléchargement... Plus depuis ce dépôt meaningful-kebab-case-name Convert arXiv papers into ready-to-use agent skills using category-aware extraction. First classifies the paper into one or more of 11 research categories, then applies a specialized extraction pipeline for each category — because different types of papers produce different types of usable knowledge. A single paper can yield multiple skills if it spans categories. Use this skill whenever the user wants to turn a paper into a skill, extract practical techniques from research, build a skill library from papers, convert arXiv papers into reusable agent instructions, or batch-process multiple papers into skills. Also trigger when someone asks about extracting actionable knowledge from papers, making research practical for LLM agents, or systematically converting academic contributions into structured agent capabilities.
action-quantization-behavior-cloning Establish regret bounds for behavior cloning with discretized actions combining statistical error and quantization error terms. Prove smoothness requirements for safe quantizer design, show that learning-based quantizers fail these requirements, and propose model-based augmentation to reduce error dependence from H² to H.
adaptive-lora-personalized-ranks Dynamically allocate LoRA ranks per-layer during fine-tuning instead of using fixed uniform ranks. Learn optimal rank for each layer and subject via variational framework with discretized exponential distribution, reducing memory footprint while maintaining fidelity and text-alignment.
Métiers associés SOC
Basé sur la classification professionnelle SOC
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:
Task datasets (curated by humans)
Reward models (trained on human preferences)
Expert demonstrations (for imitation learning)
Agent0 eliminates these by creating two complementary agents:
Curriculum Agent : Proposes novel tasks from the problem space; initially simple, escalates difficulty as executor improvesExecutor 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 generationExecutor Agent : Solves curriculum tasks via RL; builds tool integration capability progressivelyCapability Assessment : Track executor performance level (easy/medium/hard); feed to curriculum for difficulty adjustmentTool Integration : Curriculum proposes tasks requiring specific tools; executor learns which tools to use whenSelf-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= ):
None
self
self
or
self
'easy'
def
register_tool
self, tool_name, fn, description
"""Register a tool the executor can learn to use."""
self
'fn'
'description'
'usage_count'
0
def
get_tool_descriptions
self
"""Return descriptions for curriculum agent's task generation."""
for
in
self
f"{name} : {tool_info['description' ]} "
return
"\n"
def
evaluate_solution
self, task, solution
"""
Check if solution solves the task.
Returns: (is_correct, score)
"""
if
self
'math'
return
self
elif
self
'coding'
return
self
else
return
self
def
_evaluate_math
self, task, solution
"""Math domain: check numerical correctness."""
try
abs
'answer'
1e-6
return
1.0
if
else
0.0
except
return
False
0.0
Step 2: Curriculum Agent—Generate Tasks at Appropriate Difficulty.
class CurriculumAgent :
"""
Generates tasks calibrated to executor's current capability level.
"""
def __init__ (self, base_llm, problem_domain ):
self .base_llm = base_llm
self .problem_domain = problem_domain
self .generated_tasks = []
self .difficulty_progression = []
def propose_task (self, executor_level ):
"""
Generate a new task at difficulty matching executor's level.
executor_level: str in [easy, medium, hard]
"""
prompt = f"""
Problem domain: {self.problem_domain.domain_name}
Current executor capability level: {executor_level}
Available tools:
{self.problem_domain.get_tool_descriptions()}
Generate a novel task that:
- Requires {executor_level} reasoning/problem-solving
- Ideally involves {self._select_tool_for_level(executor_level)} tool
- Is different from previously generated tasks:
{self._format_task_history()}
Format: JSON with keys: task, tool_hint, expected_approach
"""
task_json = self .base_llm(prompt)
task = json.loads(task_json)
self .generated_tasks.append(task)
return task
def escalate_difficulty (self, executor_success_rate ):
"""
Adjust difficulty based on executor's success rate.
Higher success rate → harder tasks; lower rate → easier tasks.
"""
if executor_success_rate > 0.8 :
if self .problem_domain.capability_level == 'easy' :
self .problem_domain.capability_level = 'medium'
elif self .problem_domain.capability_level == 'medium' :
self .problem_domain.capability_level = 'hard'
elif executor_success_rate < 0.5 :
if self .problem_domain.capability_level == 'hard' :
self .problem_domain.capability_level = 'medium'
elif self .problem_domain.capability_level == 'medium' :
self .problem_domain.capability_level = 'easy'
def _select_tool_for_level (self, level ):
"""Select tool appropriate for difficulty level."""
if level == 'easy' :
return 'basic_calculator'
elif level == 'medium' :
return 'python_interpreter'
else :
return 'complex_reasoning_tools'
def _format_task_history (self ):
"""Return recent tasks to encourage diversity."""
recent = self .generated_tasks[-5 :]
return "\n" .join([f"- {t['task' ]} " for t in recent])
Step 3: Executor Agent—Learn to Solve Curriculum Tasks.
class ExecutorAgent :
"""
Solves curriculum-generated tasks via RL.
Learns to integrate tools and build solving strategies.
"""
def __init__ (self, base_llm, problem_domain, learning_rate=1e-5 ):
self .base_llm = base_llm
self .problem_domain = problem_domain
self .success_history = []
self .tool_usage_patterns = {}
self .optimizer = torch.optim.AdamW(base_llm.parameters(), lr=learning_rate)
def solve_task (self, task, max_steps=10 ):
"""
Attempt to solve task; collect trajectory for RL.
Returns: (solution, trajectory, reward)
"""
trajectory = []
solution_steps = []
context = f"Task: {task['task' ]} \nAvailable tools: {self.problem_domain.get_tool_descriptions()} "
for step in range (max_steps):
action_prompt = context + f"\nCurrent progress: {solution_steps} \n\nNext action:"
action = self .base_llm.generate(action_prompt, max_tokens=100 )
solution_steps.append(action)
if self ._is_tool_invocation(action):
tool_name, tool_args = self ._parse_tool_call(action)
tool_fn = self .problem_domain.tools[tool_name]['fn' ]
tool_result = tool_fn(tool_args)
self .tool_usage_patterns[tool_name] = self .tool_usage_patterns.get(tool_name, 0 ) + 1
context += f"\n[Tool: {tool_name} ]\nResult: {tool_result} "
trajectory.append({
'action' : action,
'tool' : tool_name,
'result' : tool_result,
'step' : step
})
elif self ._is_final_answer(action):
solution = self ._extract_answer(action)
is_correct, score = self .problem_domain.evaluate_solution(task, solution)
trajectory.append({
'action' : action,
'is_final' : True ,
'solution' : solution,
'reward' : 1.0 if is_correct else 0.0
})
return solution, trajectory, 1.0 if is_correct else 0.0
return None , trajectory, 0.0
def learn_from_trajectory (self, trajectory, reward ):
"""
Update executor via RL (policy gradient).
"""
returns = []
g = 0
for step in reversed (trajectory):
g = step.get('reward' , 0 ) + 0.99 * g
returns.insert(0 , g)
returns = torch.tensor(returns)
policy_loss = 0
for i, step in enumerate (trajectory):
action_log_prob = self ._compute_log_prob(step['action' ])
policy_loss -= action_log_prob * returns[i]
self .optimizer.zero_grad()
policy_loss.backward()
self .optimizer.step()
def get_success_rate (self, num_eval_tasks=20 ):
"""Evaluate current capability on curriculum-proposed tasks."""
successes = 0
for _ in range (num_eval_tasks):
task = self .problem_domain.get_evaluation_task()
_, _, reward = self .solve_task(task)
successes += reward
return successes / num_eval_tasks
Step 4: Symbiotic Loop—Agent Co-Evolution.
def symbiotic_evolution_loop (
problem_domain, base_llm,
num_iterations=1000 ,
tasks_per_iteration=10
):
"""
Main training loop: curriculum and executor co-evolve.
"""
curriculum = CurriculumAgent(base_llm, problem_domain)
executor = ExecutorAgent(base_llm, problem_domain)
for iteration in range (num_iterations):
print (f"\n=== Iteration {iteration} ===" )
print (f"Difficulty level: {problem_domain.capability_level} " )
successes = 0
trajectories = []
for task_idx in range (tasks_per_iteration):
task = curriculum.propose_task(problem_domain.capability_level)
solution, trajectory, reward = executor.solve_task(task)
successes += reward
executor.learn_from_trajectory(trajectory, reward)
trajectories.append({
'task' : task,
'solution' : solution,
'reward' : reward
})
success_rate = successes / tasks_per_iteration
curriculum.escalate_difficulty(success_rate)
eval_success = executor.get_success_rate(num_eval_tasks=5 )
print (f"Success rate (curriculum): {success_rate:.2 %} " )
print (f"Eval success rate: {eval_success:.2 %} " )
print (f"Tool usage: {executor.tool_usage_patterns} " )
if iteration > 100 and eval_success < 0.1 :
print ("Converged or diverged; stopping" )
break
return executor, curriculum
Practical Guidance When to Use: Training agents from scratch when task datasets are unavailable; domains where tasks can be procedurally generated or when self-play/curriculum is feasible (math, coding, games).
Start with simple tasks (one-step solutions); escalate gradually
Introduce tools progressively; hard level introduces complex tool combinations
Success thresholds: 80%+ for escalation, <50% for de-escalation
Task degeneration : Curriculum may propose trivial or identical tasks; add diversity metrics and deduplicationExecutor plateauing : If executor gets stuck, curriculum tasks may be too hard; implement gradual escalationTool usage imbalance : Some tools may be ignored; use tool-hint in curriculum to encourage explorationEvaluation overfitting : Executor may overfit to curriculum's task distribution; use held-out evaluation set When NOT to Use: Domains with scarce tool sets; problems requiring external knowledge (not learnable from environment); safety-critical applications.
Integration : Compatible with any LLM; works best with function-calling APIs for tool use.
