Findings demonstrate the potential of agentic AI to translate domain knowledge into generating executable components, providing a step toward automated configuration and design of evolutionary systems.
Abstract
We investigate whether agentic artificial intelligence can automate parts of the process of designing genetic programming systems by introducing an agentic framework that identifies and implements parent selection algorithms using large language model (LLM) reasoning and retrieval-augmented generation. Using symbolic regression as a test bed, we first conduct an ablation study across four LLM types to evaluate the effects of agentic reasoning and retrieval on generated algorithm categories, validity, implementation similarity, and downstream performance. Results show that these components substantially influence the types of algorithms generated, but their downstream performance largely depends on the underlying LLM. The strongest configuration, the full agentic setup with 5 mini (5 mini--AR), consistently generated established $\epsilon$-lexicase implementations while maintaining competitive downstream performance. We then benchmark this configuration against fixed implementations of tournament selection and semi-dynamic MAD $\epsilon$-lexicase. Across six symbolic regression problems, 5 mini--AR performed similarly to $\epsilon$-lexicase while generally outperforming tournament selection. These findings demonstrate the potential of agentic AI to translate domain knowledge into generating executable components, providing a step toward automated configuration and design of evolutionary systems.
We investigate the use of large language models (LLMs) as evolutionary operators for optimizing the architecture of multi-agent systems (MAS) - a representative instance of LLM-driven optimization over attributed-graph artifacts that arise in generative design. Given a task description, an initial MAS configuration is generated and then refined on a per-task basis through two optimization strategies: (1) a population-based evolutionary approach where LLMs serve as mutation, crossover, and selection operators, with an LLM-as-a-Judge ensemble providing the surrogate fitness signal; and (2) a simpler iterative regeneration scheme that uses textual feedback from LLM judges to guide single-solution improvement without maintaining a population. We evaluate both approaches on the GAIA benchmark. Our experiments reveal a critical sensitivity to the judge model's quality: a capable judge (Claude 4 Sonnet) yields +14.3 and +6.67 percentage-point accuracy improvements for evolutionary and iterative approaches, respectively, whereas a weaker judge (Gemini-2.5-Flash) provides no benefit or even degrades performance below the unoptimized baseline. Both approaches incur substantial computational costs, raising questions about practical cost-effectiveness. These results highlight fundamental challenges of surrogate fitness functions in LLM-driven evolutionary optimization and offer practical insights for applying evolutionary methods to MAS architecture design.
V. Akhmerov, Dmitry Gilemkhanov, Jerzy Kamiński et al.· Proceedings of the Genetic a...· 0 citations
The ongoing changes in software engineering requirements have created a substantial need for automated tools which can create secure source code from natural language input. The performance of traditional Large Language Models (LLMs) becomes limited by their"one-shot"capability which results in logical hallucinations together with reduced algorithmic performance during complicated operations. The research presents an autonomous AI Coding Agent which establishes a connection between LLM-generated content and production-ready software through its organized methodology for decision making. Our framework uses the Gemini 2.5 Flash API for essential reasoning capabilities while employing a tailored Monte Carlo Tree Search (MCTS) method to solve code generation challenges as a search operation. The agent uses a"Self-Critic"evaluator system to test different implementation methods which it ranks according to their accuracy and difficulty level before it improves its operational framework through backpropagation. The system operates through a Flask-based web interface which delivers instant feedback together with syntax highlighting features. Our experimental results show that the MCTS-based method achieves a 92% success rate on complex logical prompts while surpassing standard zero-shot generation models.
Genetic Programming (GP) can be used to evolve human-interpretable Behavior Tree controllers for realtimestrategy games. Current Behavior Trees-based GP approaches compute fitness only at the end ofeach episode, which does not allow learning from finer-grained tactical decisions during gameplay. In thiswork, we integrate tabular Q-learning within the BT controller to gate actions at terminal nodes based onlearned action-values, and collect additional rewards at each tick of the game that are used to augmentthe final fitness signal. Since the Q-table is reset at the start of each episode, our approach allows thelearned information to affect fitness, while keeping the learned values from one generation separate fromsubsequent generations (a form of Baldwinian learning). Applied to plain-terrain MicroRTS micromanagementchallenge (population of 100 BTs, 2000 generations, against a deterministic rush opponent), ourapproach achieves a maximum fitness of 26.44 compared to GP’s max fitness of 22.0, a relative improvementof 20.2%. Mean best-fitness was also increased by 17.8% compared to the GP-only baseline. Theseresults are reported from a single representative run per configuration; multi-seed replication is identifiedas a priority for future work. The additional per-episode RL reward signal is strongly correlated with elitefitness (r = 0.89), confirming that it provides informative guidance for the evaluation. Unit coordinationexhibited by the hybrid agents is also found to be more structured, with defined front-line and support roles.The agent maintains its interpretable Behavior Tree structure.
Mohamed Amine Chikh Touami, M. Salem, M. Khelfi· Informatica· 0 citations
Developments in artificial intelligence have made it possible for autonomous systems to compose, test, and refine code, but all current methods are based on single-agent designs or weak multi-agent systems with little cooperation and poor validation procedures. Single-agent designs lack internal diversity and poor reasoning, whereas small multi-agent designs are mostly competitive rather than cooperative and lack strong role specialization to facilitate complicated iterative improvement. The work presented here provides a five-agent collaborative architecture to provide continuous and verifiable code optimization by controlled specialization and iterative refinement. The architecture consists of five specialized agents, including the planner agent, the coder agent, the tester agent, the reviewer agent, and the explainer agent. Each agent plays a differentiated role in an integrated process of feedback where code is conceived, developed, tested, examined, and explained in an iterative process until optimality is reached. The improvement process continues until an internally optimal solution is obtained, and the reviewer agent then checks its validity individually and passes it on to the explainer agent for explainability and documentation, else the system goes through the improvement cycle again. This composition unifies independent thinking, responsibility, and transparency in an interdependent environment with lesser bias and more consistency of choice. The five-agent architecture realizes maximum heterogeneous viewpoints and distributed knowledge, producing better-quality, understandable, and verifiably optimal code than current single-agent or smaller multiagent approaches. Experiments show that continuous validation and specialization-based cooperation result in better results in automatically generated code and provides a scalable platform for intelligent, self-adjusting development environments with a 92
Jesalkumari Varolia· Journal of Intelligent Decis...· 0 citations
Recursive self-improvement (RSI) asks whether an AI system can improve the process that produces AI systems, so that the next system inherits the improvement. That process is the training algorithm: a better objective or update rule improves the compute\mbox{-}capability exchange rate for every subsequent run, including the one that produces the next agent. Whether RSI is feasible therefore turns on whether an agent can design training algorithms. No benchmark isolates that ability: existing suites are won by collecting data or by tuning hyperparameters, and none tells a change to how a run is executed apart from a change to how the model learns. We present AI4AI\mbox{-}Bench, 10 frozen research repositories spanning 10 training algorithm families. In each task, an agent has 4 hours on one B300 to rewrite the training algorithm; its code is then rerun from scratch for up to 12 hours and scored by a fixed evaluator hidden from the agent, against the repository's original algorithm under the same procedure. Because the 10 metrics are incommensurable, every task is mapped onto one scale on which $0$ is an uninformative model, $0.1$ is the algorithm the repository ships, and $1.0$ is the task optimum. Across 29 configurations of 6 systems on all 10 tasks the mean score is $0.166$, and the best system reaches $0.250$: even the strongest closes under a fifth of the distance between the algorithm that was already there and the optimum. The submissions show where that distance went: most never change how the model learns at all, and the minority that do average $0.226$ against $0.126$ for the rest. More reasoning effort mostly buys the willingness to go there, taking that minority from $8\%$ of submissions to $64\%$ and the mean score from $0.094$ to $0.196$. We release the task suite, the evaluators and every scored submission, so that the measurement can be repeated as these systems change.
The automated synthesis of sequential circuits remains a core challenge in electronic design automation. When synthesizing finite state machines (FSMs), traditional Cartesian genetic programming (CGP) typically relies on a monolithic representation that couples state and output logic into a single high-dimensional decision vector. This approach triggers a search space “curse of dimensionality” and induces significant evaluation noise due to intense variable interactions, severely limiting scalability in complex logic design. To address these issues, we propose a cooperative coevolutionary Cartesian genetic programming (CCGP) algorithm. Using the divide-and-conquer mechanism, CCGP functionally decomposes the FSM into two parallel-evolving subpopulations based on the Mealy machine model: next-state logic (NSL) and output logic (OL). To overcome the subcomponent fitness evaluation challenge in coevolution, we introduce a cross-population elite ensemble mechanism. By evaluating candidate individuals against an “elite committee” sampled from the partner population, this method significantly reduces random fitness variance and stabilizes selection pressure. Experimental evaluations across a diverse set of sequential circuit benchmarks demonstrate that CCGP significantly outperforms standard CGP and genetic programming (GP). Results show substantial improvements in both success rates and convergence stability. These findings prove that CCGP’s functional decoupling effectively prevents evolutionary stagnation caused by functional conflicts, drastically enhancing the discovery of globally optimal solutions and providing an efficient, robust new paradigm for automated sequential logic design.
Siyu Lin, Huikun Huang, Xinyuan Zhang et al.· International Conference on...· 0 citations