EvoAgentX
A Python framework that generates, executes, evaluates, and iteratively improves multi-agent workflows from natural-language goals.
- Source repo
- ANative-Lab/EvoAgentX
- Stars
- ★ 3.4k
- Last updated
- 8d ago
- License
- NOASSERTION
- Primary language
- Python
- FA score
- 44/100 · Major gaps
At a glance
- How it runs
- Works with
- Universal · cross-platformOpenAI APIClaude API (Partial support)
- Cost
- Free software; you pay for model usage
- Setup effort
- Medium · a few setup steps
- You'll need
- Typical use
- A developer who wants to turn a goal such as generating HTML for a Tetris game into a multi-agent workflow.
- Not a fit if
- Teams wanting a ready-made chat product or hosted service
- Users needing production-grade financial investment advice (demo is alpha)
- Source review
- 44/100 · Major gaps 1 safety controls not found
What does this agent do, and when should you use it?
EvoAgentX is an open-source framework for building, evaluating, and evolving LLM-based agents and agentic workflows. A natural-language goal is passed to WorkFlowGenerator to create a WorkFlowGraph; AgentManager instantiates its agents, and WorkFlow.execute() runs the result. The project includes short- and long-term memory, human-in-the-loop controls through HITLManager, and toolkits for search, code execution, files, databases, images, and browsers. It integrates TextGrad, MIPRO, AFlow, and EvoPrompt as workflow or prompt evolution algorithms, alongside benchmark and evaluation material. It is installed and used as a Python library rather than delivered as a hosted chat product; model calls and external capabilities depend on the configured providers, tools, and credentials.
A developer configures OpenAILLMConfig and OpenAILLM, then calls WorkFlowGenerator(llm=llm).generate_workflow(goal) to create a workflow graph from a goal. AgentManager.add_agents_from_workflow() creates agents from that graph, and WorkFlow(graph=..., agent_manager=..., llm=...).execute() runs the workflow and returns output. The generator can receive a tools list, such as ArxivToolkit, and may assign those tools to relevant agents; the repository also provides toolkits for search, HTTP requests, file operations, command execution, databases, images, and browser automation. HITLInterceptorAgent can pause execution before a named action by a target agent and request a human approval or rejection; workflow graphs can also be display()ed and saved or loaded with save_module() / from_file().
- A developer who wants to turn a goal such as generating HTML for a Tetris game into a multi-agent workflow.
- A researcher optimizing prompts or workflow structure for HotPotQA, MBPP, or MATH with TextGrad, AFlow, MIPRO, or EvoPrompt.
- A research team that needs a workflow to retrieve and summarize arXiv papers for selected keywords and time ranges, using ArxivToolkit or MCP tools.
- An application developer who needs a human approval checkpoint before a sensitive action such as sending email, using HITLInterceptorAgent.
- A Python team building workflows that call search, HTTP, filesystem, PostgreSQL, MongoDB, FAISS, or browser tools.
How do you install or deploy this agent?
Install with pip:
pip install evoagentxOr install directly from the repository:
pip install git+https://github.com/EvoAgentX/EvoAgentX.gitThe local-development example uses Python 3.11: create and activate a conda environment, then run pip install -r requirements.txt or pip install -e ..
How do you use this agent?
First set OpenAI credentials, for example on Linux/macOS:
export OPENAI_API_KEY=<your-openai-api-key>Then create a model and run a first workflow:
import os
from evoagentx.models import OpenAILLMConfig, OpenAILLM
from evoagentx.workflow import WorkFlowGenerator, WorkFlow
from evoagentx.agents import AgentManageropenai_config = OpenAILLMConfig(model="gpt-4o-mini",
openai_key=os.getenv("OPENAI_API_KEY"),
stream=True,
output_response=True)
llm = OpenAILLM(config=openai_config)
goal = "Generate html code for the Tetris game"
workflow_graph = WorkFlowGenerator(llm=llm).generate_workflow(goal)
agent_manager = AgentManager()
agent_manager.add_agents_from_workflow(workflow_graph, llm_config=openai_config)
workflow = WorkFlow(graph=workflow_graph, agent_manager=agent_manager, llm=llm)
output = workflow.execute()
print(output)To make tools available, pass an instance such as ArxivToolkit() to the tools arguments of both WorkFlowGenerator and AgentManager. Beyond OpenAI, the README states that Qwen, Claude, DeepSeek, and Kimi can be integrated through native adapters or LiteLLM, SiliconFlow, and OpenRouter; complete configuration examples for those paths are not included in the supplied material.
What are this agent's strengths and limitations?
- It can generate a structured multi-agent workflow from one natural-language goal, with explicit Python APIs for generation, instantiation, and execution.
- It combines workflow construction, evaluation, and evolution in one framework, explicitly integrating TextGrad, MIPRO, AFlow, and EvoPrompt.
- Its tool layer spans search and HTTP, files and commands, MongoDB/PostgreSQL/FAISS, images, and two forms of browser automation, with MCP tool support.
- HITLManager and HITLInterceptorAgent support approval gates and user-input collection around selected actions.
- The README documents paths for OpenAI and Qwen plus several models through LiteLLM, SiliconFlow, or OpenRouter, and identifies LiteLLM as an option for locally deployed models.
- The first runnable example requires an OpenAI API key; external models, search services, and some toolkits may require separate provider configuration or credentials.
- CMDToolkit can execute shell/CLI commands, while StorageToolkit and FileToolkit operate on files, so adopters must define permissions and isolation for their runtime.
- DockerInterpreterToolkit is presented for isolated code execution, but the supplied material does not document Docker runtime, deployment, or security configuration.
- The README calls the financial-analysis workflow an alpha version and says more indicators and analytical tools would be needed for a practical investment assistant.
- The supplied repository metadata says NOASSERTION for the license while the README claims an MIT License; verify the actual license file and applicable terms before adoption.
How does this agent compare with similar options?
EvoAgentX lists TextGrad, MIPRO, AFlow, and EvoPrompt as integrated evolution algorithms rather than presenting only one of them. It also describes using EvoAgentX to optimize prompts for Open Deep Research and OWL in GAIA validation-set scenarios; the supplied material does not provide a uniform feature or performance comparison with those projects.
Key facts side by side with the most closely related agents.
| Agent | Source review | Form / cost | Stars | Updated | Language | Full support on |
|---|---|---|---|---|---|---|
| EvoAgentX This agent | 44 · Major gaps | Library / SDKFree + model costs | ★ 3.4k | 8d ago | Python | OpenAI API |
| Deuz SDK | 76 · Good | Library / SDKFree + model costs | ★ 508 | 22d ago | TypeScript | OpenAI API · Claude API |
| Enterprise AI Agent Platform | 57 · Major gaps | Self-hosted service | ★ 152 | today | Python | — |
| Email Agents From Scratch | 46 · Major gaps | Library / SDKFree + model costs | ★ 2.4k | 2mo ago | Jupyter Notebook | OpenAI API |
How does FollowAgents rate this agent?
Why each dimension lost points
The README lists shell, file, database, browser, and HTTP tools, which can reach local resources and external services; the shown Agent core does not establish fine-grained permission controls, so least privilege and external effects are only partly addressed. The HITL example offers pre-execution approval, but it must be explicitly enabled and is shown for a specific action; data flows and side effects are mainly described in tool lists and examples. The quickstart documents environment variables and .env key setup and warns against committing secrets, but the Traditional Chinese README key section omits that warning, and memory-data protections are not described. Dependency groups and some version ranges are visible, but no security audit evidence is supplied. No revocation or rollback mechanism is shown. The LICENSE identifies MIT and some third-party sources, supporting a score of 2 for attribution; the third-party license list does not provide complete provenance.
The quickstart describes WorkflowResult success and error fields, and the Agent code includes input assertions and action preparation, giving some support for understandable failures. Installation guides conflict on the minimum Python version (English says 3.11, Chinese says 3.10; pyproject.toml says >=3.10), and README installation guidance does not fully align with the optional dependency groups in pyproject.toml, so consistency and dependency availability are only partly supported. There is no execution evidence, and this review does not infer runtime reliability from it.
The materials address researchers, developers, and workflow engineers, with concrete research, QA, code-generation, and tool-driven scenarios. Capability boundaries are only mentioned in passing, such as the stock demo being alpha and needing more financial indicators; broad self-evolution and real-world interaction claims lack matching limits. Natural-language goal to workflow generation is a clear entry point, but guidance on when to use it versus designing a workflow manually is limited. Python, Conda, Windows, and Linux/macOS key setup are mentioned, but conflicting version guidance and sparse compatibility detail reduce environment fit.
The README, installation guide, quickstart, module guides, and tutorials form a clear information structure and provide pip, source, Conda, and optional-feature installation paths. Examples cover workflows, tools, and HITL and show an error-output field, but no FAQ is evident. Known limitations include an alpha demo and an unfinished roadmap, but there is no systematic limitations list. LICENSE specifies MIT and some third-party licenses, though the package metadata says MIT while the supplied license metadata is NOASSERTION, and the third-party list is limited; this does not warrant full marks. pyproject.toml gives version 0.1.4, but this packet contains no clear version changelog. The author field names a team and contact email, and the README provides contact details and a response-time promise; maintenance ownership and update process remain vague.
The quickstart shows how to generate a workflow graph, instantiate agents, and obtain structured results; examples also cover saving, loading, and displaying workflows, making outputs usable in code. Combining generation, evaluation, evolution, memory, and tools offers clear added value for developers who need those capabilities together. Cost-benefit is only partly established: the core and optional dependency sets are large, an LLM key is needed, and API, compute, and maintenance costs are not quantified.
Feature claims often link to concrete modules, examples, tutorials, and papers, and the README and quickstart agree on the basic workflow path, providing moderate traceability. Corroboration across sources is limited: the shown Agent code, tests, documentation, and dependency configuration do not verify every capability listed in the README; the supplied tests are only a sample and do not establish overall test adequacy. Benchmark figures and strong performance claims appear in documentation tables, but the packet does not include complete, checkable methods and artifacts, so the boundary between documented fact and inference is only partly clear.
- Not found in source: rollback or recovery pathBack up first, or work on a git branch or snapshot, so its changes can be undone.
- The listed tools include shell commands, file and database writes, browser automation, and external APIs; inspect each tool's permissions and data flows before granting them to an agent.
- The HITL example is disabled by default and intercepts only a named agent and action; do not assume every external side effect requires approval.
- The installation guides conflict on Python 3.10 versus 3.11; check the target revision's package configuration and required optional dependencies.
Maintain this project? Add the FARS badge to your README
[](https://followagents.com/en/agents/evoagentx)<a href="https://followagents.com/en/agents/evoagentx"><img src="https://followagents.com/badge/evoagentx.svg" alt="FARS review"></a>Recent releases
Latest entries from the project's GitHub Releases. Notes are quoted from upstream as written, not rewritten or tested by FollowAgents.
-
v0.1.4 v0.1.4 Release
Release notes excerpt
This release improves workflow orchestration, parameter validation, and overall compatibility. Highlights - Improved workflow execution and graph handling, with better compatibility across old and new workflow patterns. - Added stronger validation for tool and action parameters through stricter JSON schema checks. - Normalized LLM-generated parameter types to reduce runtime mismatches. - Improved workflow task progression and completion handling. - Added utility support for async and mixed sync/async execution paths. …View on GitHub ↗ -
v0.1.3 v0.1.3 Release
Release notes excerpt
Release Notes This release focuses on the agent/tool-calling upgrade and provider compatibility improvements. Highlights - Refactored CustomizeAgent and CustomizeAction to support structured inputs/outputs, JSON Schema-backed parameters, and more robust tool orchestration. - Added native function-calling support for providers that speak the OpenAI-style tool protocol, with a fallback prompt-based path for others. - Improved OpenRouter support with prompt caching, provider-aware request shaping, and cache-write cost warnings. …View on GitHub ↗ -
v0.1.2 v0.1.2 Release
Release notes excerpt
Release Highlights This release upgrades EvoAgentX core LLM provider support and improves structured output handling. LLM Provider Updates - Updated OpenAILLM and OpenRouterLLM to support sync/async generation, streaming usage tracking, and tool-call output formatting. - Refactored AliyunLLM and SiliconFlowLLM to use OpenAI-compatible clients. - Improved LiteLLM compatibility with OpenAI-style response and cost handling. - Added streaming cost tracking via usage chunks where providers support it. …View on GitHub ↗
FAQ
What credentials does the minimal example need?
Can it use local models or Claude?
How can a human retain control over critical decisions?
Will a workflow access the network, files, or command line?
Thanks — we use this to improve the page.