💻 computer science

Automating Parent Selection Configuration in Genetic Programming with Agentic AI

This paper demonstrates that an agentic AI framework leveraging large language models and retrieval-augmented generation can effectively automate the design and implementation of parent selection algorithms for genetic programming, achieving competitive performance in symbolic regression tasks comparable to established methods like $\epsilon$ -lexicase.

Original authors: Jose Guadalupe Hernandez, Jui-Hsuan Chang, Anil Kumar Saini, Xi Li, Jason H. Moore

Published 2026-08-19

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Jose Guadalupe Hernandez, Jui-Hsuan Chang, Anil Kumar Saini, Xi Li, Jason H. Moore

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

In the vast landscape of artificial intelligence, a specific branch known as evolutionary computing mimics the way nature evolves life. Imagine a computer program that does not follow a rigid set of instructions written by a human, but instead creates a population of digital candidates, tests how well they solve a problem, and then breeds the best ones to create the next generation. This process, called genetic programming, is powerful because it can discover complex solutions that humans might never conceive. However, for this digital evolution to work, the computer needs a way to decide which candidates get to reproduce. This decision is called parent selection. If the computer picks the wrong parents, the entire population might stagnate or fail to improve. Traditionally, humans have had to manually design these selection rules, a task that requires deep expertise and often involves a great deal of trial and error. The question researchers are now asking is whether a new kind of artificial intelligence, one that can reason and look up information like a human expert, can automate this difficult design process.

A team of researchers set out to test this idea by building a specialized digital agent designed to handle the job of parent selection. They did not ask the agent to invent a brand new way of selecting parents from scratch, but rather to identify the best existing method and then write the computer code to make it work. To do this, they gave the agent access to a library of scientific papers about parent selection, allowing it to retrieve relevant knowledge just as a human researcher would. The agent was tasked with a simple goal: look at the problem, decide which selection method would work best, and then generate a functional Python program that could be plugged into a genetic programming system. They tested this setup using a type of problem called symbolic regression, where the computer must find a mathematical formula that fits a set of data points. This is a common test bed for these systems because it requires the computer to discover relationships between numbers without being told what those relationships are.

The researchers ran a series of experiments to see how well different versions of their agent performed. They compared a standard large language model, which relies only on what it learned during its initial training, against an agent that could think through the problem step-by-step, and finally against an agent that could both think and look up information in their curated library of papers. The results were revealing. When the models were left to rely solely on their internal knowledge, they almost always chose a very basic, common method called tournament selection, where a few candidates are picked at random and the best one wins. This was the safe, familiar choice. However, when the agents were allowed to look up information in the library, their behavior changed dramatically. The agents began to identify and implement a more sophisticated method known as epsilon-lexicase selection. This method is more nuanced; instead of just looking at a single overall score, it evaluates candidates based on how well they perform on specific individual data points, allowing for a more diverse and often more effective evolution.

The study found that the ability to retrieve information was crucial for guiding the agent toward these better methods, but it did not guarantee success on its own. The specific type of artificial intelligence model used mattered just as much as the tools it had. One particular model, when combined with the ability to look up information, consistently generated the correct, sophisticated selection algorithms and performed as well as, or better than, the fixed, human-designed versions. This specific setup managed to write code that implemented the complex epsilon-lexicase method with high accuracy, using a statistical approach to determine how strict the selection should be. In direct head-to-head tests across six different real-world data problems, this automated agent produced results that were statistically indistinguishable from the best human-designed selection methods and significantly better than the basic tournament selection.

However, the researchers also discovered that this automation is not yet perfect. While the best setup worked reliably, other combinations of models and tools sometimes produced code that looked correct but failed to run, or generated algorithms that performed poorly because they got the details of the math wrong. The study showed that simply having access to a library of knowledge does not automatically make an artificial intelligence expert; the underlying model must be capable of correctly interpreting that information and translating it into working code. The researchers concluded that while agentic artificial intelligence shows great promise for automating the design of these evolutionary systems, it is currently a tool that works best when paired with the right model and careful oversight. The work demonstrates a significant step forward, proving that machines can begin to translate complex domain knowledge into executable components, potentially reducing the heavy burden of manual design that has long slowed the adoption of these powerful computational tools.

Technical Summary: Automating Parent Selection Configuration in Genetic Programming with Agentic AI

Problem Statement
Genetic Programming (GP) offers significant flexibility for symbolic regression (SR) by allowing the tailoring of representations, selection mechanisms, and variation operators. However, this flexibility creates a vast design space of interdependent algorithmic and parameter choices, requiring substantial expertise to configure effectively. This barrier hinders the broader adoption of GP. While Agentic Artificial Intelligence (AI) has been proposed as a mechanism to automate complex design tasks by extending Large Language Models (LLMs) with reasoning and tool-use capabilities, its feasibility in identifying and implementing specific, effective GP components remains largely unexplored. This study investigates whether an agentic AI framework can autonomously identify and implement parent selection algorithms for GP systems without requiring manual intervention.

Methodology
The authors propose an agentic framework that combines an LLM with Retrieval-Augmented Generation (RAG) to automate the selection and implementation of parent selection algorithms. The framework utilizes a curated corpus of parent selection literature to ground the agent's reasoning.

Framework Architecture: The system employs a specialized agent that receives a prompt defining its role as a GP specialist. The agent performs two tasks: (1) identifying an appropriate parent selection algorithm and (2) implementing it as a Python function with a specific signature (selection(fitnesses)). The agent operates in an iterative reasoning loop, deciding autonomously whether to rely on internal knowledge or invoke a RAG tool to retrieve relevant literature from a vector database.
Experimental Setup: The study uses six real-world symbolic regression problems from the UCI Machine Learning Repository. A standard GP system (implemented in DEAP) is used where only the parent selection procedure varies.
Ablation Study (Experiment 1): The authors evaluated four LLM types (gpt-4o, gpt-4.1 mini, gpt-5 mini, and gpt-oss 20b) across three configurations:
1. LLM: Standalone model with zero-shot prompting.
2. ANR (Agentic No Retrieval): Agentic workflow without the RAG tool.
3. AR (Agentic Retrieval): Full agentic framework with RAG.
  Metrics included execution success, classification success (agreement between reported and manually verified algorithm family), code similarity, and downstream performance (test set Mean Squared Error).
Benchmark Evaluation (Experiment 2): The best-performing configuration from Experiment 1 was benchmarked against fixed, handcrafted implementations of Tournament Selection (size 3) and Semi-Dynamic $\epsilon$ -lexicase selection (using Median Absolute Deviation for $\epsilon$ ).

Key Results

Impact of RAG and Reasoning: The inclusion of the RAG module and agentic reasoning substantially influenced the types of algorithms generated. For models like gpt-4o and gpt-4.1 mini, the standalone LLM and ANR configurations exclusively generated Tournament Selection. In contrast, the AR configuration shifted the output toward $\epsilon$ -lexicase. However, this shift did not uniformly improve downstream performance; for some models (e.g., gpt-4o), the AR configuration resulted in significantly worse performance due to poor parameterization (e.g., using fixed $\epsilon$ values instead of MAD-based thresholds).
Model Dependence: The effectiveness of the framework was highly dependent on the underlying LLM. The gpt-5 mini model exhibited a unique capability: it frequently generated $\epsilon$ -lexicase algorithms even without retrieval, accounting for 85.7% of the generated algorithms in the LLM configuration. When equipped with RAG (5 mini–AR), it consistently generated established $\epsilon$ -lexicase implementations, predominantly using MAD-based $\epsilon$ thresholds and dynamic or semi-dynamic variants.
Performance: The 5 mini–AR configuration achieved downstream performance comparable to the fixed semi-dynamic MAD $\epsilon$ -lexicase implementation across all six SR problems. It generally outperformed Tournament Selection. Notably, while 5 mini–AR generated independent implementations for each replicate, its performance remained competitive with the fixed reference, though it exhibited higher variance in specific cases (e.g., Housing and Yacht datasets).
Validity and Similarity: Execution success was high across most configurations. However, classification success (correctly identifying the specific variant, such as static vs. dynamic $\epsilon$ -lexicase) varied. The AR configuration sometimes reduced classification success for models that defaulted to Tournament Selection, as the retrieved information led to more complex but occasionally misclassified implementations.

Significance and Claims
The paper claims that agentic AI demonstrates the potential to translate domain knowledge into generating executable components for evolutionary systems. Specifically, the study provides evidence that:

Agentic frameworks can successfully automate the configuration of parent selection, moving beyond simple assistance to autonomous generation of algorithmic components.
The integration of RAG is critical for guiding LLMs toward established, effective algorithm families (like $\epsilon$ -lexicase) that they might not prioritize in a zero-shot setting, although the quality of the resulting implementation depends heavily on the LLM's internal knowledge and ability to interpret retrieved context.
The 5 mini–AR configuration serves as a proof-of-concept that an agentic system can generate parent selection algorithms that are competitive with expert-defined, fixed implementations.

The authors maintain a modest stance, noting that while the framework is a step toward automated GP design, it currently isolates parent selection and does not yet validate or revise generated algorithms based on their downstream performance in a closed loop. They emphasize that future work must address the reliability of generated implementations and extend the framework to other GP components.

More like this