Add prompt meta-evolution feature

Implements meta-evolution of prompt templates inspired by the Darwin
Gödel Machine paper. The system maintains an archive of prompt templates,
tracks their success rates, and evolves them over time to improve
mutation quality.

Key features:
- PromptTemplate dataclass with success/improvement tracking
- PromptArchive for managing template population with sampling
- Configurable scoring weights for template quality assessment
- Automatic template evolution at configurable intervals
- Checkpoint persistence for prompt archives
- Validation to ensure scoring weights sum to 1.0

New config options under `prompt_meta_evolution`:
- enabled: Master switch (default: false)
- archive_size: Max templates to keep
- evolution_interval: Iterations between evolutions
- exploration_rate: Random sampling probability
- score_weight_*: Configurable scoring formula weights

Closes #170
Related to #53

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Author: fangchenli

examples/function_minimization/config_meta_evolution.yaml

@@ -0,0 +1,45 @@
+# Configuration for testing prompt meta-evolution feature
+max_iterations: 25
+checkpoint_interval: 5
+log_level: INFO
+
+# LLM configuration
+llm:
+  primary_model: "gpt-4o-mini"
+  primary_model_weight: 1.0
+  api_base: "https://api.openai.com/v1"
+  temperature: 0.7
+  max_tokens: 16000
+  timeout: 120
+
+# Prompt configuration
+prompt:
+  system_message: "You are an expert programmer specializing in optimization algorithms. Your task is to improve a function minimization algorithm to find the global minimum of a complex function with many local minima. The function is f(x, y) = sin(x) * cos(y) + sin(x*y) + (x^2 + y^2)/20. Focus on improving the search_algorithm function to reliably find the global minimum, escaping local minima that might trap simple algorithms."
+
+# Prompt meta-evolution - ENABLED for testing
+prompt_meta_evolution:
+  enabled: true
+  archive_size: 20
+  min_uses_for_evolution: 5  # Lower for testing
+  evolution_interval: 20  # Trigger at iteration 20
+  exploration_rate: 0.2
+  elite_fraction: 0.3
+
+# Database configuration
+database:
+  population_size: 50
+  archive_size: 20
+  num_islands: 3
+  elite_selection_ratio: 0.2
+  exploitation_ratio: 0.7
+  similarity_threshold: 0.99
+
+# Evaluator configuration
+evaluator:
+  timeout: 60
+  cascade_thresholds: [1.3]
+  parallel_evaluations: 3
+
+# Evolution settings
+diff_based_evolution: true
+max_code_length: 20000

openevolve/config.py

@@ -397,6 +397,56 @@ class EvolutionTraceConfig:
     compress: bool = False
 
 
+@dataclass
+class PromptMetaEvolutionConfig:
+    """Configuration for meta-evolution of prompt templates.
+
+    When enabled, OpenEvolve maintains an archive of prompt templates,
+    tracks their success rates, and evolves them over time to improve
+    mutation quality.
+    """
+
+    # Master switch
+    enabled: bool = False
+
+    # Archive settings
+    archive_size: int = 20  # Max templates to keep in archive
+
+    # Evolution triggers
+    min_uses_for_evolution: int = 10  # Min uses before template can be evolved
+    evolution_interval: int = 20  # Trigger evolution every N iterations
+
+    # Sampling behavior
+    exploration_rate: float = 0.2  # Probability of sampling random template
+    elite_fraction: float = 0.3  # Fraction of top templates protected from pruning
+
+    # Scoring weights (must sum to 1.0)
+    # score = w_success * success_rate + w_improvement * improvement_rate + w_fitness * normalized_fitness_delta
+    score_weight_success: float = 0.3  # Weight for success rate (mutations accepted)
+    score_weight_improvement: float = 0.4  # Weight for improvement rate (fitness increased)
+    score_weight_fitness_delta: float = 0.3  # Weight for avg fitness delta magnitude
+
+    # Scoring parameters
+    score_min_uses: int = 5  # Min uses before score is calculated (else neutral prior)
+    score_neutral_prior: float = 0.5  # Score returned when uses < min_uses
+
+    def __post_init__(self):
+        """Validate configuration after initialization."""
+        weight_sum = (
+            self.score_weight_success
+            + self.score_weight_improvement
+            + self.score_weight_fitness_delta
+        )
+        tolerance = 1e-6
+        if abs(weight_sum - 1.0) > tolerance:
+            raise ValueError(
+                f"Scoring weights must sum to 1.0, got {weight_sum:.6f} "
+                f"(success={self.score_weight_success}, "
+                f"improvement={self.score_weight_improvement}, "
+                f"fitness_delta={self.score_weight_fitness_delta})"
+            )
+
+
 @dataclass
 class Config:
     """Master configuration for OpenEvolve"""
@@ -416,6 +466,9 @@ class Config:
     database: DatabaseConfig = field(default_factory=DatabaseConfig)
     evaluator: EvaluatorConfig = field(default_factory=EvaluatorConfig)
     evolution_trace: EvolutionTraceConfig = field(default_factory=EvolutionTraceConfig)
+    prompt_meta_evolution: PromptMetaEvolutionConfig = field(
+        default_factory=PromptMetaEvolutionConfig
+    )
 
     # Evolution settings
     diff_based_evolution: bool = True

openevolve/controller.py

@@ -18,6 +18,7 @@
 from openevolve.evolution_trace import EvolutionTracer
 from openevolve.llm.ensemble import LLMEnsemble
 from openevolve.process_parallel import ProcessParallelController
+from openevolve.prompt.meta_evolution import PromptArchive, evolve_prompt
 from openevolve.prompt.sampler import PromptSampler
 from openevolve.utils.code_utils import extract_code_language
 from openevolve.utils.format_utils import format_improvement_safe, format_metrics_safe
@@ -188,6 +189,25 @@ def __init__(
         # Initialize improved parallel processing components
         self.parallel_controller = None
 
+        # Initialize prompt meta-evolution if enabled
+        self.prompt_archive = None
+        if self.config.prompt_meta_evolution.enabled:
+            self.prompt_archive = PromptArchive(
+                max_size=self.config.prompt_meta_evolution.archive_size,
+                min_uses_for_evolution=self.config.prompt_meta_evolution.min_uses_for_evolution,
+                elite_fraction=self.config.prompt_meta_evolution.elite_fraction,
+                exploration_rate=self.config.prompt_meta_evolution.exploration_rate,
+                # Scoring configuration
+                score_weight_success=self.config.prompt_meta_evolution.score_weight_success,
+                score_weight_improvement=self.config.prompt_meta_evolution.score_weight_improvement,
+                score_weight_fitness_delta=self.config.prompt_meta_evolution.score_weight_fitness_delta,
+                score_min_uses=self.config.prompt_meta_evolution.score_min_uses,
+                score_neutral_prior=self.config.prompt_meta_evolution.score_neutral_prior,
+            )
+            self._initialize_default_prompt_templates()
+            self.prompt_sampler.set_prompt_archive(self.prompt_archive)
+            logger.info("Prompt meta-evolution enabled")
+
     def _setup_logging(self) -> None:
         """Set up logging"""
         log_dir = self.config.log_dir or os.path.join(self.output_dir, "logs")
@@ -225,7 +245,7 @@ def _setup_manual_mode_queue(self) -> None:
         if not bool(getattr(self.config.llm, "manual_mode", False)):
             return
 
-        qdir = (Path(self.output_dir).expanduser().resolve() / "manual_tasks_queue")
+        qdir = Path(self.output_dir).expanduser().resolve() / "manual_tasks_queue"
 
         # Clear stale tasks from previous runs
         if qdir.exists():
@@ -246,6 +266,34 @@ def _load_initial_program(self) -> str:
         with open(self.initial_program_path, "r") as f:
             return f.read()
 
+    def _initialize_default_prompt_templates(self) -> None:
+        """Initialize the prompt archive with default templates from TemplateManager."""
+        if self.prompt_archive is None:
+            return
+
+        # Get default templates from the sampler's template manager
+        tm = self.prompt_sampler.template_manager
+
+        # Get system template
+        system_template = self.config.prompt.system_message
+        if system_template in tm.templates:
+            system_template = tm.get_template(system_template)
+
+        # Get user template (diff-based or full rewrite)
+        if self.config.diff_based_evolution:
+            user_template = tm.get_template("diff_user")
+        else:
+            user_template = tm.get_template("full_rewrite_user")
+
+        # Add as the default template
+        self.prompt_archive.add_template(
+            system_template=system_template,
+            user_template=user_template,
+            is_default=True,
+            metadata={"source": "default"},
+        )
+        logger.info("Added default prompt template to archive")
+
     async def run(
         self,
         iterations: Optional[int] = None,
@@ -333,6 +381,7 @@ async def run(
                 self.database,
                 self.evolution_tracer,
                 file_suffix=self.config.file_suffix,
+                prompt_archive=self.prompt_archive,
             )
 
             # Set up signal handlers for graceful shutdown
@@ -493,6 +542,20 @@ def _save_checkpoint(self, iteration: int) -> None:
                 f"{format_metrics_safe(best_program.metrics)}"
             )
 
+        # Save prompt archive if meta-evolution is enabled
+        if self.prompt_archive is not None:
+            import json
+
+            prompt_archive_path = os.path.join(checkpoint_path, "prompt_archive.json")
+            with open(prompt_archive_path, "w") as f:
+                json.dump(self.prompt_archive.to_dict(), f, indent=2)
+            stats = self.prompt_archive.get_statistics()
+            logger.info(
+                f"Saved prompt archive (size={stats['size']}, "
+                f"total_uses={stats['total_uses']}, "
+                f"success_rate={stats['overall_success_rate']:.1%})"
+            )
+
         logger.info(f"Saved checkpoint at iteration {iteration} to {checkpoint_path}")
 
     def _load_checkpoint(self, checkpoint_path: str) -> None:
@@ -504,16 +567,131 @@ def _load_checkpoint(self, checkpoint_path: str) -> None:
         self.database.load(checkpoint_path)
         logger.info(f"Checkpoint loaded successfully (iteration {self.database.last_iteration})")
 
+        # Load prompt archive if meta-evolution is enabled
+        if self.prompt_archive is not None:
+            import json
+
+            prompt_archive_path = os.path.join(checkpoint_path, "prompt_archive.json")
+            if os.path.exists(prompt_archive_path):
+                with open(prompt_archive_path, "r") as f:
+                    self.prompt_archive = PromptArchive.from_dict(json.load(f))
+                # Re-inject into sampler and parallel controller
+                self.prompt_sampler.set_prompt_archive(self.prompt_archive)
+                stats = self.prompt_archive.get_statistics()
+                logger.info(
+                    f"Loaded prompt archive (size={stats['size']}, "
+                    f"total_uses={stats['total_uses']})"
+                )
+
+    def _maybe_evolve_prompts(self, iteration: int) -> None:
+        """
+        Periodically evolve prompt templates if meta-evolution is enabled.
+
+        Args:
+            iteration: Current iteration number
+        """
+        if self.prompt_archive is None:
+            return
+
+        # Only evolve at configured intervals
+        interval = self.config.prompt_meta_evolution.evolution_interval
+        if iteration == 0 or iteration % interval != 0:
+            return
+
+        # Get templates ready for evolution
+        templates_to_evolve = self.prompt_archive.get_templates_for_evolution()
+        if not templates_to_evolve:
+            logger.debug("No templates ready for evolution yet")
+            return
+
+        top_templates = self.prompt_archive.get_top_templates(5)
+
+        # Evolve the top template that's ready for evolution
+        # Sort by score descending
+        templates_to_evolve.sort(key=lambda t: t.score, reverse=True)
+        template = templates_to_evolve[0]
+
+        logger.info(
+            f"Evolving prompt template {template.id} "
+            f"(score={template.score:.3f}, uses={template.uses})"
+        )
+
+        # Create a sync wrapper for LLM generation that works in async context
+        # We use a thread pool to avoid event loop conflicts
+        import concurrent.futures
+
+        def llm_generate_sync(system: str, user: str) -> str:
+            import asyncio
+
+            # Create a new event loop in a thread to avoid conflicts
+            def run_in_new_loop():
+                loop = asyncio.new_event_loop()
+                asyncio.set_event_loop(loop)
+                try:
+                    return loop.run_until_complete(
+                        self.llm_ensemble.generate_with_context(
+                            system_message=system,
+                            messages=[{"role": "user", "content": user}],
+                        )
+                    )
+                finally:
+                    loop.close()
+
+            with concurrent.futures.ThreadPoolExecutor() as executor:
+                future = executor.submit(run_in_new_loop)
+                return future.result()
+
+        # Evolve the template
+        result = evolve_prompt(
+            template,
+            top_templates,
+            llm_generate_sync,
+            score_fn=self.prompt_archive.get_template_score,
+        )
+        if result:
+            new_system, new_user = result
+            new_template = self.prompt_archive.add_template(
+                system_template=new_system,
+                user_template=new_user,
+                parent_id=template.id,
+                metadata={"evolved_at_iteration": iteration},
+            )
+            logger.info(
+                f"Created evolved template {new_template.id} "
+                f"(generation {new_template.generation})"
+            )
+        else:
+            logger.warning(f"Failed to evolve template {template.id}")
+
     async def _run_evolution_with_checkpoints(
         self, start_iteration: int, max_iterations: int, target_score: Optional[float]
     ) -> None:
         """Run evolution with checkpoint saving support"""
         logger.info(f"Using island-based evolution with {self.config.database.num_islands} islands")
         self.database.log_island_status()
 
-        # Run the evolution process with checkpoint callback
+        # Track last prompt evolution for catching up between checkpoints
+        last_prompt_evolution = [start_iteration]  # Use list for closure mutability
+
+        # Create a combined callback that handles checkpoints and prompt evolution
+        def combined_callback(iteration: int) -> None:
+            self._save_checkpoint(iteration)
+
+            # Trigger prompt evolution - catch up on any missed intervals
+            if self.prompt_archive is not None:
+                evolution_interval = self.config.prompt_meta_evolution.evolution_interval
+                # Find all evolution points between last_prompt_evolution and current iteration
+                next_evolution = (
+                    last_prompt_evolution[0] // evolution_interval + 1
+                ) * evolution_interval
+                while next_evolution <= iteration:
+                    self._maybe_evolve_prompts(next_evolution)
+                    next_evolution += evolution_interval
+                last_prompt_evolution[0] = iteration
+
+        # Run the evolution process with combined callback
         await self.parallel_controller.run_evolution(
-            start_iteration, max_iterations, target_score, checkpoint_callback=self._save_checkpoint
+            start_iteration, max_iterations, target_score, checkpoint_callback=combined_callback
         )
 
         # Check if shutdown or early stopping was triggered