DOCSEARCHbyAlgolia
Submit Docs

awesome-self-evolving-agents

repository·main·Indexed 25 days ago

https://github.com/evoagentx/awesome-self-evolving-agents

A curated survey and resource repository for self-evolving AI agents. It covers optimization techniques for single-agent (behavior, prompt, memory, and tool optimization), multi-agent systems (including frameworks like MetaAgent, AutoGen, and MetaGPT), and domain-specific applications in biomedicine, programming, finance, law, and science. The collection includes references to automated frameworks such as EvoAgentX and MASLab.

Tokens
3.5K
Snippets
1
Records
16
Agent score
32%

What's inside awesome-self-evolving-agents

  1. Overview of Self-Evolving AI Agents

    main

    This repository, awesome-self-evolving-agents, serves as a comprehensive survey and resource collection for self-evolving AI agents. It bridges the gap between static foundation models and lifelong agentic systems. The project categorizes evolution and optimization techniques into three major directions:

    1. Single-Agent Optimisation: Focusing on individual agent capabilities.
    2. Multi-Agent Optimisation: Focusing on how multiple agents interact and evolve together.
    3. Domain-Specific Optimisation: Tailoring evolution to specific industries or tasks.

    Key resources included in the survey:

    • EvoAgentX: An automated framework for evolving agentic workflows (EMNLP'25 Demo).
    • MASLab: A unified codebase for LLM-based multi-agent systems (Arxiv'25).

  2. Multi-Agent System (MAS) Optimisation Frameworks

    main

    The repository categorizes several research frameworks and tools for optimizing Multi-Agent Systems (MAS). These are divided into construction and optimization techniques:

    Automatic Multi-Agent Construction

    • MetaAgent: Uses Finite State Machines to automatically construct MAS.

    MAS Optimisation

    • CORAL: Focuses on autonomous multi-agent evolution for open-ended discovery.
    • R&D-Agent: Automates data-driven AI solution building through LLM-powered research and development.
    • MaAS: Performs Multi-Agent Architecture Search via an Agentic Supernet.
    • AFlow: Automates agentic workflow generation.
    • ADAS: Focuses on the automated design of agentic systems.
    • ScoreFlow: Masters LLM agent workflows using score-based preference optimization.
    • GPTSwarm: Treats language agents as optimizable graphs.
    • DSPy: Compiles declarative language model calls into optimized pipelines.
    • AgentVerse: Facilitates multi-agent collaboration and explores emergent behaviors.
    • MetaGPT: Provides a meta-programming framework for multi-agent collaboration.
    • AutoGen: Enables multi-agent conversations for LLM applications.
    • AutoFlow: Automates workflow generation for LLM agents.
    • Symbolic Learning: Enables self-evolving agents through symbolic learning.
    • rSDE-Bench: Focuses on self-evolving multi-agent collaboration networks for software development.
    • Agent Foundation Models (Chain-of-Agents): Uses multi-agent distillation and agentic RL for end-to-end agent foundation models.
    • Agent KB: Leverages cross-domain experience for agentic problem solving.

  3. Explore Memory Optimisation techniques

    main

    Memory Optimisation focuses on how agents store, retrieve, and manage information to handle long-term tasks and context. Key research areas include:

    • Long-Term Memory: Using specialized banks or structures like MemoryBank or Mem0 to provide scalable long-term storage.
    • Context Management: Using techniques like Gist Memory or Compressive Memory to handle very long contexts.
    • Graph-Based Memory: Building graph-based agents (e.g., GraphReader) to enhance long-context reasoning.
    • Agentic Memory Management: Using Reinforcement Learning to teach agents how to manage and utilize their own memories (e.g., Memory-R1).

  4. Explore Tool Optimisation techniques

    main

    Tool Optimisation improves how agents interact with external APIs and functions. It is categorized by when the optimisation occurs:

    1. Training-Based Tool Optimisation

    • Supervised Fine-Tuning: Teaching models to use tools via self-instruction (GPT4Tools) or mastering large API sets (ToolLLM).
    • Reinforcement Learning: Using RL to optimize strategic tool use (ReTool, ToolRL) or multi-step reasoning (Tool-Star).

    2. Inference-Time Tool Optimisation

    • Prompt-Based: Optimizing tool instructions at runtime (EASYTOOL, play2prompt).
    • Reasoning-Based: Using search or planning to navigate action spaces (ToolChain*, Tool-Planner) or discovering tools autonomously (MCP-Zero).

    3. Tool Functionality Optimisation

    • Focuses on the creation and evolution of the tools themselves (e.g., CREATOR for tool creation, Alita for maximal self-evolution).

  5. Explore Unified Optimization frameworks

    main

    Unified Optimization approaches attempt to combine multiple optimisation dimensions into a single framework for lifelong learning and continuous evolution. Examples include:

    • ELL-StuLife: Building self-evolving agents via experience-driven lifelong learning.
    • EvoAgent: Using a continual world model for long-horizon tasks.

  6. Explore Prompt Optimisation techniques

    main

    Prompt Optimisation aims to find the most effective instructions for an agent. The repository categorizes these into four approaches:

    • Edit-Based: Searching for prompts by making incremental changes (e.g., GPS, GrIPS, TEMPERA).
    • Evolutionary: Using evolutionary algorithms to evolve prompts over generations (e.g., EvoPrompt, Promptbreeder).
    • Generative: Using LLMs themselves as prompt engineers to generate and optimize instructions (e.g., Automatic Prompt Engineer, DSPy, PromptAgent).
    • Text Gradient-Based: Treating text as a differentiable medium to perform 'gradient descent' on prompts (e.g., TextGrad, Automatic Prompt Optimization).

  7. LLM-Based and Agent-Based Evaluation Methods

    main

    Evaluation of agent performance can be conducted using the following paradigms:

    LLM-as-a-Judge

    Using Large Language Models to assess the quality, utility, or correctness of agent outputs. Techniques include:

    • Automated Peer Debate/Committee Voting: Using multiple agents to debate and vote on evaluations (e.g., Auto-Arena).
    • Test-Time Scaling: Using methods like MCTS (Monte Carlo Tree Search) for code correctness evaluation (e.g., MCTS-Judge).
    • Divergent Thinking Evaluation: Assessing scientific idea generation (e.g., LiveIdeaBench).

    Agent-as-a-Judge

    Using autonomous agents to evaluate the behavior and performance of other agents (e.g., agent-as-a-judge).

  8. Single-Agent Optimisation Techniques

    main

    Single-agent optimization focuses on improving the performance and efficiency of an individual agent through several key dimensions:

    • LLM Behaviour Optimisation: Refining how the underlying Large Language Model acts and responds.
    • Prompt Optimisation: Improving the instructions and context provided to the agent.
    • Memory Optimization: Enhancing how the agent stores, retrieves, and utilizes long-term and short-term information.
    • Tool Optimization: Improving the agent's ability to select and use external tools and APIs effectively.

  9. Automatic Multi-Agent Construction via MetaAgent

    main
    MetaAgent (ICML'25) is a framework for automatically constructing Multi-Agent Systems (MAS) based on Finite State Machines (FSM). This approach allows for the structured generation of agentic workflows by leveraging state machine logic to define agent interactions and transitions.

  10. Explore LLM Behaviour Optimisation techniques

    main

    LLM Behaviour Optimisation is divided into two main categories for improving agent performance:

    1. Training-Based Optimisation

    Focuses on improving the model's core capabilities through:

    • Supervised Fine-Tuning (SFT): Using datasets like ToRA (mathematical reasoning), STaR (bootstrapping reasoning), or MAS-GPT (multi-agent system building).
    • Reinforcement Learning (RL): Using methods like Self-Rewarding LMs, Agent Q, or R-Zero (self-evolving reasoning from zero data) to refine agent trajectories.

    2. Test-Time Optimisation

    Focuses on improving performance during inference (at runtime) via:

    • Feedback-Based Approaches: Using execution feedback (CodeT, LEVER) or process reward modeling (Math-Shepherd, Skywork-Reward) to verify and repair outputs.
    • Search-Based Approaches: Using structured reasoning paths like Tree of Thoughts, Graph of Thoughts, or Deductive Beam Search to explore solution spaces.
    • Reasoning-Based Approaches: Integrating tools and thinking processes directly into the reasoning loop (e.g., START, CoRT).

  11. Explore Self-Evolving Agents for Finance, Law, and Science

    main

    The repository provides resources for agents in specialized research and professional domains:

    Scientific Research

    • PiFlow: Principle-aware scientific discovery via multi-agent collaboration.

    Financial Decision-Making

    • R&D-Agent-Quant: Multi-agent framework for data-centric factors and model joint optimization.
    • FinRobot: Open-source AI agent platform for financial applications.
    • agentUniverse: Expertizing domain-specific tasks with multi-agent frameworks and tuning.
    • FinCon: Synthesized LLM multi-agent system with conceptual verbal reinforcement.

    Legal Reasoning

    • LawLuo: Multi-agent collaborative framework for Chinese legal consultation.
    • Legalgpt: Legal chain of thought for multi-agent frameworks.
    • LawGPT: Chinese legal knowledge-enhanced LLM.
    • AgentCourt: Simulating court with adversarial evolvable lawyer agents.

    Other Domains

    • Agents of Change: Self-evolving agents for strategic planning.
    • EarthLink: Self-evolving AI agent for climate science.
    • SEAgent: Self-evolving computer use agent with autonomous learning from experience.

  12. Explore Self-Evolving Agents for Programming

    main

    The repository lists several frameworks for autonomous programming tasks, divided into Code Refinement and Code Debugging:

    Code Refinement

    • AgentCoder: Multi-agent code generation with iterative testing and optimization.
    • Self-Refine: Iterative refinement using self-feedback.
    • CodeAgent: Autonomous agents for code review.
    • OpenHands: An open platform for AI software developers as generalist agents.
    • CodeCoR: Self-reflective multi-agent framework for code generation.
    • AlphaEvolve: Coding agent for scientific and algorithmic discovery.
    • Darwin Gödel Machine: Open-ended evolution of self-improving agents.
    • OpenEvolve: Open-source evolutionary coding agent.
    • rSDE-Bench: Self-evolving multi-agent collaboration networks for software development.
    • Live-SWE-agent: Software engineering agents that self-evolve on the fly.

    Code Debugging

    • Self-Edit: Fault-aware code editor for code generation.
    • Teaching LLMs to Self-Debug: Framework for teaching models to debug themselves.
    • RGD: Multi-LLM based agent debugger via refinement and generation guidance.
    • LLM Guided Self-Debugging: Code generation guided by LLMs for self-debugging.