EvoAgentX

A Python framework that generates, executes, evaluates, and iteratively improves multi-agent workflows from natural-language goals.

Stars
★ 3.4k
Last updated
27d ago
License
NOASSERTION
Primary language
Python

At a glance

Works with
Universal · cross-platformOpenAI APIClaude API (Partial support)
You'll need
Shell / CLINetwork accessLocal filesystemMCP Server
Typical use
A developer who wants to turn a goal such as generating HTML for a Tetris game into a multi-agent workflow.
Main limitation
The first runnable example requires an OpenAI API key; external models, search services, and some toolkits may require separate provider configuration or credentials.

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().

  1. A developer who wants to turn a goal such as generating HTML for a Tetris game into a multi-agent workflow.
  2. A researcher optimizing prompts or workflow structure for HotPotQA, MBPP, or MATH with TextGrad, AFlow, MIPRO, or EvoPrompt.
  3. A research team that needs a workflow to retrieve and summarize arXiv papers for selected keywords and time ranges, using ArxivToolkit or MCP tools.
  4. An application developer who needs a human approval checkpoint before a sensitive action such as sending email, using HITLInterceptorAgent.
  5. 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 evoagentx

Or install directly from the repository:

pip install git+https://github.com/EvoAgentX/EvoAgentX.git

The 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 AgentManager
openai_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?

Pros
  • 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.
Limitations
  • 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 Stars Updated Language Full support on
EvoAgentX This agent 47 · Major gaps ★ 3.4k 27d ago Python OpenAI API
Deuz SDK 69 · Some gaps ★ 697 3d ago TypeScript OpenAI API · Claude API
Email Agents From Scratch 49 · Major gaps ★ 2.3k 1mo ago Jupyter Notebook OpenAI API
AgentScope 2.0 70 · Some gaps ★ 32k today Python OpenAI API · Claude API

How does FollowAgents rate this agent?

FollowAgents source review · FARS-2.1
Major gaps
47/ 100 5-point scale 2.4 / 5
Trust 11/29
Reliability 6/14
Adaptability 9/18
Convention 10/18
Effectiveness 7/13
Verifiability 4/8
Why each dimension lost points
Trust11 / 29 · 1.9/5

Evidence: Framework provides HITL mechanism for human approval of critical operations (user_confirmation=2); toolset includes file system, shell, database, but no explicit least-privilege design (least_privilege=1); data flow transparency limited, no detailed data handling (data_flow_transparency=1); sensitive data handling not explicit, API key management only suggested via env vars (sensitive_data_handling=1); dependency security not audited, many third-party deps (dependency_security=1); external effects like email sending require human confirmation but not comprehensive (external_effects=1); no rollback mechanism (rollback=0); source attribution clear with MIT and third-party licenses (source_attribution=2).

Reliability6 / 14 · 2.1/5

Evidence: Code structure consistent, tests exist (self_consistency=2); many dependencies with unpinned versions, availability risk (dependency_availability=1); error messages provided in examples but overall failure handling unclear (failure_messages=1).

Adaptability9 / 18 · 2.5/5

Evidence: Targets researchers and developers, diverse scenarios (audience_and_scenarios=2); capability boundaries not explicit, e.g., tool permissions (capability_boundaries=1); trigger precision relies on LLM generation, not controlled (trigger_precision=1); environment fit supports multiple models and tools but complex dependencies (environment_fit=2).

Convention10 / 18 · 2.8/5

Evidence: Documentation structure clear with quickstart and tutorials (information_architecture=2); install notes detailed (install_notes=2); naming stable but version updates unclear (naming_stability=1); examples abundant (examples_and_faq=2); known limitations not listed (known_limitations=1); MIT license explicit (license=2); version number exists but no changelog (versioning_changelog=1); maintenance responsibility clear with contribution guide and community (maintenance_responsibility=2).

Effectiveness7 / 13 · 2.7/5

Evidence: Output usable, e.g., HTML reports (output_usability=2); high marginal value with evolution algorithms (marginal_value=2); cost-benefit not assessed, relies on external APIs (cost_benefit=1).

Verifiability4 / 8 · 2.5/5

Evidence: Papers and benchmark results traceable (claim_traceability=2); cross-source verification limited, only internal tests (cross_source_corroboration=1); fact-inference separation unclear (fact_inference_separation=1).

Risks and how to mitigate them
  • Not found in source: rollback or recovery pathBack up first, or work on a git branch or snapshot, so its changes can be undone.
  • Many dependencies with unpinned versions pose supply chain risks.
  • Sensitive data handling and least privilege not explicit; use with caution.
  • No rollback mechanism; failures may be unrecoverable.
Evidence confidence: Low Reviewed Aug 09, 2026 Reviewed revision aad19b912f64 New commits since this review; the score may not cover them
See the full review method →

FAQ

What credentials does the minimal example need?
The README's minimal code uses OpenAI and requires OPENAI_API_KEY. Google Custom Search, SerpAPI, and SerperAPI toolkits are also explicitly marked as requiring their respective keys or search-engine ID.
Can it use local models or Claude?
The README says locally deployed LLMs can be tried through LiteLLM and lists Claude as a model that can be integrated through LiteLLM. The supplied material does not include a complete configuration example for either path.
How can a human retain control over critical decisions?
Activate HITLManager and add HITLInterceptorAgent to request approve or reject before a specified action on a target agent. The HITL module also includes HITLUserInputCollectorAgent for collecting user input.
Will a workflow access the network, files, or command line?
Optional toolkits explicitly include HTTP, search, RSS, browser access, file I/O, and shell/CLI command execution. Whether they are actually invoked depends on the tools supplied to and assigned within a workflow.
View on GitHub ↗ Install ↓

Compare agents like this one

The same FARS review applied across the shortlist this agent qualifies for.

Related agents