OpenEvolve
The most advanced open-source evolutionary coding agent turns your LLMs into autonomous code optimizers that discover breakthrough algorithms.
Evidence shows: the repository provides no permission model, user confirmation mechanism, data flow transparency, sensitive data handling, dependency security audit, external effects control, rollback mechanism, or source attribution. All trust-related criteria are unmet, hence all scores are 0.
Evidence shows: README and configuration examples are largely consistent in functionality, but there are inconsistencies, such as README claiming 'fully deterministic' while config allows random templates and temperature settings, and no detailed explanation of determinism guarantees. Dependency availability: pyproject.toml lists dependencies but lacks version pinning or integrity checks, and the integration test workflow installs math-verify additionally, indicating incomplete dependency management. Failure messages: test scripts provide basic error output, but no user-facing troubleshooting guide.
Evidence shows: README identifies target audiences (performance optimization, algorithm discovery, etc.) and multiple use cases, with several examples. Capability boundaries: README describes configurable constraints (e.g., 'MUST NOT CHANGE' in system messages), but lacks comprehensive capability boundary documentation. Trigger precision: provides configuration examples and system message guidance, but no detailed trigger conditions. Environment fit: supports multiple LLM providers and local models, but lacks detailed configuration guides for all environments.
Evidence shows: README provides clear information architecture including quick start, examples, configuration. Installation instructions are detailed, covering PyPI, development install, and Docker. Naming stability: project name and main APIs are consistent in docs. Examples and FAQ: multiple examples provided, but no FAQ section. Known limitations: not explicitly listed. License: Apache-2.0, but no copyright holder information. Versioning: pyproject.toml uses dynamic version, but no CHANGELOG. Maintenance responsibility: author info only lists 'codelion', no maintainer contact or contribution guide.
Evidence shows: Output usability: provides library API and CLI, with output examples. Marginal value: claims 2-3x speedups and SOTA results, but no independent verification. Cost-benefit: provides cost estimates, but no actual benchmark data.
Evidence shows: Performance claims in README (e.g., 2-3x speedups, SOTA) lack traceable benchmarks or paper citations. Cross-source corroboration: relies solely on internal repository evidence, no external validation. Fact-inference separation: README mixes inferences (e.g., 'breakthrough optimizations') with facts (e.g., examples) without clear distinction.
- Performance claims (e.g., 2-3x speedups, SOTA) lack verifiable benchmarks or paper citations; treat with caution.
- Dependency management is incomplete, without version pinning, and integration tests install math-verify additionally, potentially affecting reproducibility.
- No explicit permission model or security audit is provided; assess risks yourself when using as an Agent framework.
What does this agent do, and when should you use it?
OpenEvolve is an open-source library for automatically improving code through evolutionary algorithms. It implements MAP-Elites quality-diversity optimization and island-based evolution, leveraging multiple LLMs to generate new programs. Core components include an evolutionary engine, an evaluator interface, a database for population management, and visualization tools. Users can run evolution via CLI or Python API, with seed settings for reproducibility and extensive configuration options. It supports multiple programming languages (Python, Rust, Metal shaders) and demonstrates results across domains like GPU kernel optimization and algorithmic discovery.
OpenEvolve evolves code iteratively. It starts with an initial program, uses an LLM ensemble to generate mutated versions, evaluates them with user-supplied evaluator functions, and manages the population in a database. It uses MAP-Elites to organize programs by feature dimensions and island migration to maintain diversity. Artifact feedback (e.g., errors, warnings) informs future generations. The entry points include run_evolution and evolve_function Python APIs, and the openevolve-run.py CLI. Configuration is YAML-based, allowing multiple LLM providers (OpenAI-compatible endpoints, Claude Code CLI). The output is improved program code and performance metrics.
- GPU kernel developers seeking automated optimization for specific hardware, e.g., achieving 2.8x speedup on Apple Silicon.
- Researchers discovering new algorithms or mathematical structures, like achieving state-of-the-art circle packing results.
- Scientists automating tedious tuning of complex algorithms like adaptive sort or signal processing filters.
- Competitive programmers exploring multiple solution strategies for multi-objective problems.
- Engineers optimizing prompts for LLMs, using OpenEvolve to evolve prompts for improved accuracy.
- Developers needing to evolve code across multiple languages, including Python, Rust, and Metal shaders.
What are this agent's strengths and limitations?
- Uses MAP-Elites and island models to prevent premature convergence and maintain diversity.
- Supports multiple LLM providers (OpenAI, Gemini, Claude Code, local models) for flexible integration.
- Provides full reproducibility with seed settings (default seed=42), ideal for research.
- Includes a visualizer and checkpoint system for real-time monitoring and analysis.
- Demonstrated success: GPU kernel optimization (2.8x speedup), state-of-the-art circle packing.
- Costs vary by LLM provider; advanced models can be expensive per iteration (e.g., o3 at $0.15-0.60).
- Requires LLM API keys, which adds dependency (though Claude Code CLI offers an alternative with OAuth).
- Crafting effective system messages is crucial and may require iterative tuning, which is not trivial.
- Performance may depend on problem complexity and evaluator quality; configuration needs adjustment.
- Benchmarks and achievements are from examples and may not generalize to all domains.
How do you install or deploy this agent?
Requires Python 3.10+ and an LLM API key (e.g., Google Gemini or OpenAI). Install via pip: pip install openevolve. Set the environment variable OPENAI_API_KEY (for Gemini, use the same variable). Optionally, install Docker for containerized runs (see docker pull ghcr.io/algorithmicsuperintelligence/openevolve:latest) or Claude Code CLI (npm install -g @anthropic-ai/claude-code).
How do you use this agent?
Quick start: Install, set OPENAI_API_KEY, and run an example: python openevolve-run.py examples/function_minimization/initial_program.py examples/function_minimization/evaluator.py --config examples/function_minimization/config.yaml --iterations 50. Or use the Python API: from openevolve import run_evolution; result = run_evolution(initial_program='...', evaluator=lambda path: {'score': ...}, iterations=100). Configure LLM providers by editing config.yaml (e.g., llm.api_base and llm.model).
FAQ
How much does it cost to run OpenEvolve?
Must I use a specific LLM?
What if evolution gets stuck?
num_diverse_programs or migration intervals.How can I measure success?
combined_score or metric average, or track convergence, diversity coverage, and efficiency via the visualizer.