OpenAlpha Evolve
Evolve Python algorithms through LLM-generated code, testing, selection, and iterative refinement.
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.
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 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.
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.