OpenAlpha Evolve
Evolve Python algorithms through LLM-generated code, testing, selection, and iterative refinement.
- Source repo
- shyamsaktawat/OpenAlpha_Evolve
- Stars
- ★ 1.1k
- Last updated
- 1y ago
- License
- MIT
- Primary language
- Python
- FA score
- 45/100 · Major gaps
At a glance
- How it runs
- Works with
- Universal · cross-platformOpenAI API · Claude API
- Cost
- Free software; you pay for model usage
- Setup effort
- Medium · a few setup steps
- You'll need
- Typical use
- An algorithms researcher exploring candidate implementations for a problem such as Dijkstra's algorithm under explicit input-output tests.
- Not a fit if
- Users unwilling to install and run Docker
- Production teams needing persistent storage or multi-user deployment
- Source review
- 45/100 · Major gaps 1 safety controls not found
What does this agent do, and when should you use it?
OpenAlpha Evolve is an open-source framework for automatically discovering and iteratively improving Python algorithms, inspired by DeepMind's AlphaEvolve research. Its architecture includes PromptDesignerAgent, CodeGeneratorAgent, EvaluatorAgent, DatabaseAgent, SelectionControllerAgent, and TaskManagerAgent. Users define a target function, permitted imports, and tests in YAML or with TaskDefinition, then the system evolves candidate programs across generations. Generated code is syntax-checked and executed against task examples in Docker containers for scoring. The repository offers both a command-line run path and a Gradio interface for defining tasks and starting evolution interactively.
A user supplies a YAML task containing task_id, task_description, function_name, allowed_imports, and tests. PromptDesignerAgent creates initial, mutation, and bug-fix prompts; CodeGeneratorAgent calls a model through LiteLLM to produce Python code and attempts to apply received diffs to parent code. EvaluatorAgent checks Python syntax, runs the program in a temporary isolated environment, and calculates fitness from test correctness, runtime, and potential additional metrics. DatabaseAgent records code, fitness, generation, and lineage; SelectionControllerAgent chooses parents and survivors; TaskManagerAgent repeats the evolutionary loop for the configured generations. Outputs include evolved Python candidates, evaluation results, and logs, with alpha_evolve.log as the documented default log file.
- An algorithms researcher exploring candidate implementations for a problem such as Dijkstra's algorithm under explicit input-output tests.
- A Python developer who wants to specify a function, allowed imports, and edge-case tests in YAML, then iterate on generated implementations.
- An experimenter studying how LLM-produced programs change in fitness through mutation, diff-based fixes, and selection.
- A prototype team that needs generated Python code syntax-checked and functionally tested in a Docker-isolated execution environment.
- A developer who wants to define a custom task through a Gradio UI and run the evolutionary process interactively.
How do you install or deploy this agent?
Prerequisites are Python 3.10+, pip, Git, and a running Docker installation. Run:
git clone https://github.com/shyamsaktawat/OpenAlpha_Evolve.git
cd OpenAlpha_Evolve
python -m venv venv
source venv/bin/activate
pip install -r requirements.txt
cp .env_example .envConfigure credentials for the selected model provider in .env. Google can use GOOGLE_APPLICATION_CREDENTIALS or GEMINI_API_KEY; the documentation also gives OPENAI_API_KEY, ANTHROPIC_API_KEY, and COHERE_API_KEY as examples. Provider access is handled through LiteLLM.
How do you use this agent?
Run the documented shortest-path example with:
python -m main examples/shortest_path.yamlThe system runs its evolutionary loop and writes logs to the terminal and, by default, alpha_evolve.log. For the web interface, run:
python app.pyOpen the local URL displayed by Gradio, define a task, and start an evolution run.
What are this agent's strengths and limitations?
- Separates prompt design, generation, evaluation, storage, selection, and orchestration into dedicated agents that can be extended or replaced.
- Supports initial generation, diff-based mutation, and diff-based bug fixing, enabling targeted changes to parent programs.
- Evaluates candidates with syntax checks, test execution, and fitness scoring instead of returning code text alone.
- Documents a multi-provider path through LiteLLM, including OpenAI, Anthropic, and Google, rather than a single-model interface.
- Executing generated code requires local Docker, with Docker Desktop or Docker Engine installed and running.
- Code generation requires credentials for a model provider; usage and costs depend on the provider chosen.
- The project is explicitly experimental: generated code may be suboptimal, incorrect, or insecure and requires review and testing before production use.
- DatabaseAgent is currently in-memory; the source does not document persistent storage, recovery, or multi-user deployment.
- The setup text names .env.example while the copy command uses .env_example, so adopters need to verify the repository's actual filename.
How does this agent compare with similar options?
The project explicitly presents itself as an open-source regeneration of core ideas inspired by DeepMind's AlphaEvolve, intended to make those concepts more accessible for experimentation and learning. The source does not document feature parity, performance comparisons, or deployment comparisons with AlphaEvolve.
Key facts side by side with the most closely related agents.
| Agent | Source review | Form / cost | Stars | Updated | Language | Full support on |
|---|---|---|---|---|---|---|
| OpenAlpha Evolve This agent | 45 · Major gaps | CLIFree + model costs | ★ 1.1k | 1y ago | Python | OpenAI API · Claude API |
| KADATH | 66 · Some gaps | CLIFree + model costs | ★ 228 | 15d ago | Python | OpenAI API |
| OpenEvolve | 51 · Major gaps | CLIFree + model costs | ★ 7.7k | 1d ago | Python | Claude Code · OpenAI API |
| CaveAgent | 63 · Some gaps | Library / SDKFree + model costs | ★ 219 | 1mo ago | Python | OpenAI API · Claude API |
How does FollowAgents rate this agent?
Why each dimension lost points
The generator sends prompts to the configured LiteLLM model; the README says environment variables may hold API keys, and the database writes programs and code to a JSON file. The evaluator runs candidate code through Docker and can disable networking, providing limited isolation and data-flow visibility. Deductions: the shown code does not establish pre-execution approval, detailed secret protection, or reliable rollback; dependencies are mostly unpinned and no dependency security evidence is provided.
The generator retries several API errors and logs failures, while database load/save paths also log exceptions, supporting ordinary troubleshooting. Deductions: the README says the database is currently in-memory while the code persists JSON; setup says to copy .env_example while the project structure names .env.example; most requirements are not version-pinned.
The README targets researchers, developers, and enthusiasts and describes YAML/Python tasks, multiple LLM providers, and replaceable components. Deductions: it says Gemini is currently configured while the code uses generic LiteLLM settings; the supplied evidence does not establish that task triggers and allowed-import boundaries are fully enforced.
The README has a contents list, structure overview, setup steps, YAML example, task-writing advice, and an experimental-project disclaimer; the MIT license text is complete. Deductions: the environment-file name is inconsistent, version history is absent, and maintainer responsibility/update path is only a general contribution invitation.
The framework connects LLM code generation, iterative mutation, evaluation, and selection for research and experimentation; the entry point can report best program code and scores. Deductions: use depends on an API, Docker, and user configuration, with no cost estimates or run-budget guidance; generated and evaluated results still need human review.
The README gives concrete workflow and configuration claims, with partial corresponding implementation in the entry point, generator, and database code; a test sample also asserts Docker invocation details. Deductions: some feature claims are not adequately supported by the supplied code, the test file is truncated, and static evidence cannot establish actual runtime behavior.
- Not found in source: dependency securityPin versions and run a dependency audit (npm audit, pip-audit) before installing; prefer running it in a container.
- Generated code is executed in Docker and prompts are sent to the configured LLM service; review task definitions, API configuration, container settings, and candidate code before use.
- Setup refers to .env_example while the structure section lists .env.example; check the repository’s actual filename before configuring credentials.
Maintain this project? Add the FARS badge to your README
[](https://followagents.com/en/agents/openalpha-evolve)<a href="https://followagents.com/en/agents/openalpha-evolve"><img src="https://followagents.com/badge/openalpha-evolve.svg" alt="FARS review"></a>FAQ
Can I use a provider other than Google?
Is generated code safe to ship directly to production?
Why is Docker required?
How do I define a problem for evolution?
Does it retain evolutionary history?
Thanks — we use this to improve the page.