gigaevo-llm-evolution

name	gigaevo-llm-evolution
title	GigaEvo: Open Source Optimization Framework Powered By LLMs And Evolution
version	0.0.2
engine	skillxiv-v0.0.2-claude-opus-4.6
license	MIT
url	https://arxiv.org/abs/2511.17592
keywords	["Evolutionary Algorithms","LLM Mutation","Algorithm Optimization","Program Synthesis","Quality-Diversity"]
description	Evolve Python algorithms and programs using LLMs as mutation operators combined with MAP-Elites quality-diversity search, achieving competitive results on geometric optimization and algorithmic problems by iteratively mutating code informed by historical performance and lineage context.

GigaEvo: LLM-Driven Evolutionary Optimization

Rather than optimizing neural network weights, this skill demonstrates how to evolve entire programs and algorithms using large language models as intelligent mutation operators. GigaEvo combines evolutionary computation (MAP-Elites quality-diversity algorithm) with LLM-based code generation, enabling discovery of novel algorithms for geometric optimization, combinatorial problems, and other domains where explicit algorithms may outperform learned models.

The core innovation is using LLMs not for inference, but as mutation operators that generate improved algorithm variants by analyzing parent code, performance metrics, and historical context about what changes succeeded.

Core Concept

GigaEvo implements an evolutionary framework where:

1. Population Management: Python programs stored with their metrics and lineage information in a database
2. Evolutionary Engine: MAP-Elites algorithm maps solutions to a behavior space based on fitness and behavioral features
3. Mutation via LLM: LLMs generate offspring code by analyzing parent implementations, metrics, and historical mutations
4. Fitness Evaluation: Programs are executed and evaluated on benchmark tasks (geometric optimization, bin packing, etc.)

The system tracks bidirectional lineage (parent→offspring and offspring→parent) to enable context-aware code generation.

Architecture Overview

• Redis Database: Stores evolutionary units with code, metrics, fitness scores, and lineage pointers
• DAG Execution Engine: Asynchronously processes programs through validation, complexity analysis, and evaluation stages
• MAP-Elites Quality-Diversity: Maintains diverse, high-performing solutions across behavior space dimensions
• LangGraph Mutation Agent: Constructs rich context from parent code and generates improved variants
• Metrics Tracking: Historical performance data to guide evolution direction

Implementation Steps

The evolutionary process cycles through population initialization, evaluation, and mutation stages.

1. Initialize Population and Behavior Space

Create initial population of random programs and define the behavior space dimensions.

def initialize_giga_evo(task_domain, population_size=100):
    """
    Initialize the evolutionary population with random programs.
    Sets up the behavior space for quality-diversity optimization.
    """
    population = []

    
     idx  (population_size):
         task_domain == :
            program = generate_random_geometric_algorithm()
         task_domain == :
            program = generate_random_packing_algorithm()

        individual = {
            : ,
            : program,
            : ,
            : ,
            : {: [], : []},
            : {}
        }

        population.append(individual)

    
    behavior_space = {
        : (, ),      
        : (, ),     
        : (, )     
    }

     population, behavior_space