The evolutionary loop in AdaEvolve can incorporate a reduced-order model of the fitness landscape, analogous to structural optimization surrogates, to reduce expensive LLM query counts.

Integrating a surrogate model (e.g., Gaussian Process, neural network, or polynomial response surface) of the fitness landscape into the AdaEvolve evolutionary loop will reduce the number of expensive LLM API calls required to reach a target solution quality by ≥30%, while maintaining ≥95% of the solution quality (measured by task-specific fitness score) achievable by the baseline AdaEvolve system that queries the LLM for every candidate evaluation. This effect is expected to hold across at least 3 distinct benchmark tasks with differing fitness landscape topologies.

Minimum Viable Test (MVT): A controlled A/B comparison of standard AdaEvolve vs. surrogate-augmented AdaEvolve (SA-AdaEvolve) on 3 benchmark tasks, using 30 independent runs per condition per task, measuring LLM query count, solution quality, and total cost. The surrogate is a Gaussian Process (GP) trained on evaluated candidates and used to pre-screen 80% of each generation's candidates before LLM evaluation.

Design: 2×3 factorial (2 systems × 3 tasks), fully randomized, with fixed random seeds for reproducibility. Primary metric: LLM query reduction ratio (QRR = 1 - queries_SA / queries_baseline). Secondary metric: Relative solution quality (RSQ = fitness_SA / fitness_baseline). Both metrics computed per run, aggregated across runs.

Control variables: identical population size (N=50), identical mutation/crossover operators, identical termination criteria (100 generations or fitness plateau for 10 generations), identical LLM model (GPT-4o or equivalent), identical random seed sequences.

# SA-AdaEvolve: Surrogate-Assisted AdaEvolve
# Architecture Overview

import numpy as np
from sklearn.gaussian_process import GaussianProcessRegressor
from sklearn.gaussian_process.kernels import Matern
from sklearn.preprocessing import StandardScaler
from sklearn.model_selection import cross_val_score

class SurrogateAssistedAdaEvolve:
    def __init__(self,
                 llm_evaluator,          # LLM-based fitness function
                 embedder,               # Text -> vector embedding
                 population_size=50,
                 warmup_generations=2,
                 prescreening_ratio=0.80, # Fraction filtered by surrogate
                 candidate_multiplier=5,  # Candidates generated per slot
                 surrogate_r2_threshold=0.70,
                 max_generations=100):
        
        self.llm_evaluator = llm_evaluator
        self.embedder = embedder
        self.pop_size = population_size
        self.warmup_gens = warmup_generations
        self.prescreening_ratio = prescreening_ratio
        self.candidate_mult = candidate_multiplier
        self.r2_threshold = surrogate_r2_threshold
        self.max_gens = max_generations
        
        # Surrogate model: GP with Matérn kernel
        self.surrogate = GaussianProcessRegressor(
            kernel=Matern(nu=2.5),
            n_restarts_optimizer=5,
            normalize_y=True
        )
        self.scaler = StandardScaler()
        
        # Data stores
        self.evaluated_embeddings = []  # X for surrogate
        self.evaluated_fitnesses = []   # y for surrogate
        self.llm_query_count = 0
        self.surrogate_r2_history = []
        
    def embed(self, candidates):
        """Convert candidate solutions to fixed-dim vectors."""
        return np.array([self.embedder(c) for c in candidates])
    
    def llm_evaluate(self, candidates):
        """Query LLM for fitness; track query count."""
        fitnesses = []
        for c in candidates:
            f = self.llm_evaluator(c)
            fitnesses.append(f)
            self.llm_query_count += 1
        return np.array(fitnesses)
    
    def train_surrogate(self):
        """Train GP surrogate on all LLM-evaluated data."""
        X = np.array(self.evaluated_embeddings)
        y = np.array(self.evaluated_fitnesses)
        X_scaled = self.scaler.fit_transform(X)
        
        # Cross-validate to estimate R²
        if len(X) >= 10:
            cv_scores = cross_val_score(
                self.surrogate, X_scaled, y,
                cv=min(5, len(X)//2), scoring='r2'
            )
            r2 = np.mean(cv_scores)
        else:
            r2 = 0.0
        
        self.surrogate.fit(X_scaled, y)
        self.surrogate_r2_history.append(r2)
        return r2
    
    def surrogate_prescreen(self, candidates):
        """
        Use surrogate to filter candidates.
        Returns top (1-prescreening_ratio) fraction for LLM eval.
        """
        embeddings = self.embed(candidates)
        X_scaled = self.scaler.transform(embeddings)
        
        # GP predicts mean and uncertainty
        mu, sigma = self.surrogate.predict(X_scaled, return_std=True)
        
        # Acquisition: Upper Confidence Bound (UCB)
        # Balance exploitation (mu) and exploration (sigma)
        kappa = 2.0  # exploration weight
        acquisition = mu + kappa * sigma
        
        # Select top (1-prescreening_ratio) fraction
        n_select = max(1, int(len(candidates) * (1 - self.prescreening_ratio)))
        top_indices = np.argsort(acquisition)[-n_select:]
        
        return [candidates[i] for i in top_indices]
    
    def generate_candidates(self, population):
        """Generate candidate_multiplier × pop_size candidates via mutation/crossover."""
        candidates = []
        n_candidates = self.pop_size * self.candidate_mult
        for _ in range(n_candidates):
            # Standard evolutionary operators (task-specific)
            parent = population[np.random.randint(len(population))]
            candidate = self.mutate(parent)  # LLM-based or rule-based mutation
            candidates.append(candidate)
        return candidates
    
    def mutate(self, individual):
        """Placeholder: implement task-specific mutation operator."""
        raise NotImplementedError
    
    def run(self, initial_population):
        population = initial_population
        fitness = self.llm_evaluate(population)  # Always evaluate initial pop
        
        # Store initial evaluations
        embeddings = self.embed(population)
        self.evaluated_embeddings.extend(embeddings)
        self.evaluated_fitnesses.extend(fitness)
        
        best_fitness_history = [np.max(fitness)]
        
        for gen in range(self.max_gens):
            candidates = self.generate_candidates(population)
            
            if gen < self.warmup_gens:
                # WARMUP: evaluate all candidates with LLM
                selected_candidates = candidates[:self.pop_size]
                candidate_fitness = self.llm_evaluate(selected_candidates)
            else:
                # SURROGATE-ASSISTED: prescreen, then LLM-evaluate survivors
                r2 = self.train_surrogate()
                
                if r2 >= self.r2_threshold:
                    # Surrogate reliable: prescreen candidates
                    prescreened = self.surrogate_prescreen(candidates)
                    candidate_fitness = self.llm_evaluate(prescreened)
                    selected_candidates = prescreened
                else:
                    # FALLBACK: surrogate unreliable, use full LLM evaluation
                    selected_candidates = candidates[:self.pop_size]
                    candidate_fitness = self.llm_evaluate(selected_candidates)
                
                # Update surrogate training data
                new_embeddings = self.embed(selected_candidates)
                self.evaluated_embeddings.extend(new_embeddings)
                self.evaluated_fitnesses.extend(candidate_fitness)
            
            # Selection: keep top pop_size individuals
            all_individuals = list(population) + list(selected_candidates)
            all_fitness = np.concatenate([fitness, candidate_fitness])
            top_indices = np.argsort(all_fitness)[-self.pop_size:]
            population = [all_individuals[i] for i in top_indices]
            fitness = all_fitness[top_indices]
            
            best_fitness_history.append(np.max(fitness))
            
            # Early stopping: plateau detection
            if len(best_fitness_history) > 10:
                if np.std(best_fitness_history[-10:]) < 1e-4:
                    print(f"Converged at generation {gen}")
                    break
        
        return {
            'best_individual': population[np.argmax(fitness)],
            'best_fitness': np.max(fitness),
            'llm_query_count': self.llm_query_count,
            'surrogate_r2_history': self.surrogate_r2_history,
            'fitness_history': best_fitness_history
        }

# EXPERIMENT RUNNER
def run_experiment(task, n_runs=30, condition='baseline'):
    results = []
    for seed in range(n_runs):
        np.random.seed(seed)
        if condition == 'baseline':
            # Standard AdaEvolve: no surrogate
            agent = BaselineAdaEvolve(task.llm_evaluator, pop_size=50)
        else:
            # SA-AdaEvolve
            agent = SurrogateAssistedAdaEvolve(
                llm_evaluator=task.llm_evaluator,
                embedder=task.embedder,
                population_size=50,
                warmup_generations=2,
                prescreening_ratio=0.80
            )
        
        init_pop = task.generate_initial_population(seed=seed)
        result = agent.run(init_pop)
        results.append(result)
    
    return results

# METRICS COMPUTATION
def compute_metrics(baseline_results, sa_results):
    baseline_queries = [r['llm_query_count'] for r in baseline_results]
    sa_queries = [r['llm_query_count'] for r in sa_results]
    baseline_fitness = [r['best_fitness'] for r in baseline_results]
    sa_fitness = [r['best_fitness'] for r in sa_results]
    
    qrr = 1 - np.mean(sa_queries) / np.mean(baseline_queries)
    rsq = np.mean(sa_fitness) / np.mean(baseline_fitness)
    
    from scipy import stats
    t_stat, p_value = stats.ttest_rel(baseline_queries, sa_queries)
    
    return {
        'QRR': qrr,          # Query Reduction Ratio
        'RSQ': rsq,          # Relative Solution Quality
        'p_value': p_value,
        'baseline_queries_mean': np.mean(baseline_queries),
        'sa_queries_mean': np.mean(sa_queries),
        'baseline_fitness_mean': np.mean(baseline_fitness),
        'sa_fitness_mean': np.mean(sa_fitness)
    }