Source-linked AI summary
Autonomous Evolution of EDA Tools: Multi-Agent Self-Evolved ABC
Cunxi Yu, Haoxing Ren
TL;DR
The paper addresses the difficulty of improving ABC, a large and tightly coupled synthesis system whose heuristic decisions are costly to redesign manually. It introduces multi-agent LLM evolution over ABC’s integrated codebase with correctness and QoR feedback, and reports progressively improved synthesis quality while revealing that agents work best when guided by domain knowledge and existing algorithmic structure.
Problem
Improving ABC is difficult because its large, interdependent codebase and complex heuristic decisions make autonomous evolution methods designed for smaller systems inadequate.
Method
Specialized LLM agents iteratively modify ABC’s flow, logic-minimization, and mapping subsystems under shared correctness checks, QoR evaluation, and domain-guided rules.
Results
The fully evolved system improves static timing and area–delay product across benchmark suites, with approximately 8 to 9% average worst-negative-slack improvement and roughly 8.3% area–delay-product reduction.
Takeaways & Limitations
The results demonstrate repository-scale, agentic, self-improving EDA tool development that can learn new synthesis strategies over the entire ABC codebase.
Takeaways & Limitations
Agents perform well only when guided by sufficient domain knowledge, and fully novel algorithmic constructs without existing structural anchors fail more often.
Abstract
from arXiv · showhide
This paper introduces the first \emph{self-evolving} logic synthesis framework, which leverages Large Language Model (LLM) agents to autonomously improve the source code of \textsc{ABC}, the widely adopted logic synthesis system. Our framework operates on the \emph{entire integrated ABC codebase}, and the output repository preserves its single-binary execution model and command interface. In the initial evolution cycle, we bootstrap the system using existing prior open-source synthesis components, covering flow tuning, logic minimization, and technology mapping, but without manually injecting new heuristics. On top of this foundation, a team of LLM-based agents iteratively rewrites and evolves specific sub-components of ABC following our ``programming guidance`` prompts under a unified correctness and QoR-driven evaluation loop. Each evolution cycle proposes code modifications, compiles the integrated binary, validates correctness, and evaluates quality-of-results (QoR) on \emph{multi-suite benchmarks including ISCAS~85/89/99, VTR, EPFL, and IWLS~2005}. Through continuous feedback, the system discovers optimizations beyond human-designed heuristics, effectively \emph{learning new synthesis strategies} that enhance QoR. We detail the architecture of this self-improving system, its integration with \textsc{ABC}, and results demonstrating that the framework can autonomously and progressively improve EDA tool at full million-line scale.
1 Introduction
EDA tools are difficult to evolve because their combinatorial search spaces, tightly coupled components, and expert-designed heuristics make substantial improvements human-intensive. This paper addresses the gap by using multi-agent LLMs to evolve the integrated ABC codebase while preserving correctness and evaluating QoR.
- Motivation: EDA development is constrained by combinatorial search spaces, subtle algorithmic interactions, and extensive re-engineering requirements.These factors make progress fundamentally dependent on human-intensive, heuristic-driven development.
- Motivation: ABC contains decades of synthesis advances, but many improvements remain external or difficult to integrate into its monolithic C codebase.Built-in decisions such as cut selection, refactoring conditions, choice-node expansion, and cost estimation are often statically designed by experts.
- Research Gap: Prior LLM evolution systems target isolated kernels or smaller repositories, whereas ABC exceeds 1.2 million lines across more than 4,000 files and four abstraction layers.This scale creates deep interdependencies and makes direct transfer of modular evolution techniques difficult.
- Approach: The paper introduces a scalable multi-agent framework that iteratively modifies ABC modules, checks logic correctness, and evaluates QoR on benchmark circuits.Beneficial changes are retained and accumulated across generations.
- Contributions: The framework decomposes ABC into functional subsystems and uses a unified QoR objective, formal correctness feedback, and benchmark evaluation to evolve the integrated tool.The stated contributions include full-scale code evolution, collaborative subsystem agents, formal equivalence feedback, and benchmark evidence beyond human-engineered baselines.
2 Background
Logic synthesis transforms Boolean networks into technology-specific implementations through optimization and mapping, but ABC’s large, coupled codebase and hand-engineered heuristics make further improvement difficult. Prior agentic methods do not directly address ABC’s scale or its multi-objective QoR requirements, motivating a domain-guided self-evolution approach.
- Logic Synthesis and ABC: Logic synthesis combines logic optimization and technology mapping to reduce network size or depth and bind logic to standard cells or LUTs.Both phases are NP-hard and rely on multi-stage heuristics balancing QoR and runtime.
- Logic Synthesis and ABC: ABC’s effectiveness depends on extensive hand-engineered heuristics for rewriting, resubstitution, refactoring, mapping, and flow control.These heuristics reflect years of expert experimentation.
- Challenges: Millions of lines, thousands of interdependent C files, shared structures, and circuit-dependent decisions make ABC changes slow, error-prone, and difficult to search exhaustively.Small heuristic changes can propagate unpredictably across subsystems.
- Related Work: Prior LLM evolution frameworks focus on compact kernels or smaller repositories and therefore do not directly fit ABC’s scale and tightly coupled architecture.ABC also requires simultaneous consideration of area, delay, depth, node count, mapping cost, and correctness.
- Self-Evolving Programming: The proposed programming process explicitly supplies human domain knowledge through repository guidance, evolution rules, and forbidden development rules.The paper identifies these inputs as human domain-knowledge contributions to the self-evolution process.
3 Approach
The framework bootstraps ABC with integrated prior components, assigns specialized agents to flow, mapping, and logic-minimization subsystems, and coordinates their autonomous code evolution. Each iteration compiles changes, verifies functional equivalence, evaluates QoR across diverse flows and metrics, and updates rules based on feedback.
- Initialization: A pre-evolution agent surveys flow tuning, technology mapping, and technology-independent optimization projects before selecting components suitable for ABC integration.Selection considers quality, extensibility, synergy with self-evolution, and full integration into ABC.
- Initialization: FlowTune is selected for flow-level exploration because it is implemented as an integrated ABC command with a modular internal structure.External black-box flow optimizers offer less opportunity for direct code evolution inside ABC.
- Initialization: External mapping methods provide structural guidance, while existing ABC mapping routines remain the direct substrate for evolution.Integration challenges arise from external learning-framework dependencies incompatible with the in-repository code structure.
- Agent Setups and Roles: Three specialized agents evolve flow scheduling, technology mapping, and technology-independent logic optimization within separate ABC subsystems.The mapper targets cut pruning, enumeration, and cost scoring, while the flow agent evolves pass orchestration and the logic agent evolves optimization algorithms.
- Agent Setups and Roles: After cycle 0, planning and coding proceed autonomously under a shared QoR objective and functional-semantics constraint, with human intervention limited to repeated safety failures.Planning agents propose subsystem strategies and coding agents implement repository diffs.
- Evolutionary Iteration Workflow: Each iteration compiles the repository, self-debugging compilation failures before formal combinational equivalence checking rejects mismatches or unintended logic changes.Correctness failures generate feedback for subsequent cycles.
- Evaluation: Benchmark evaluation runs across 87 CPU nodes, eight synthesis flows, ASAP7 technology, final QoR metrics, and intermediate structural signals.Collected signals include area, timing, critical-path delay, AIG nodes, depth, edges, mapper estimates, traversal statistics, and per-pass deltas.
- Self-Evolving Rulebase: The self-evolving rulebase coordinates agents, constrains modifications, and can relax or refine policies when they repeatedly block beneficial edits.Its behavior shifts from conservative stability toward more exploratory structural changes across evolution cycles.
4 Results and Discussion
The fully evolved ABC system improves QoR across benchmark suites while preserving high code quality and manageable iteration cost. Its strongest gains come from jointly evolving complementary synthesis subsystems, although novel algorithmic constructs remain less reliable without existing structural anchors.
- Self-Evolved ABC Evaluation: 0.917 normalized QoR is achieved when FlowTune, AIG Syn, and Map evolve jointly, an approximately 8.3% improvement over the vanilla integrated baseline.The evolved subsystems contribute complementary changes to structural simplification, logic depth and redundancy, and mapped-delay mitigation.
- Self-Evolved ABC Evaluation: 8 to 9% average worst-negative-slack improvement and roughly 8.3% area–delay-product reduction occur across all benchmark suites.Several EPFL arithmetic circuits improve by 12 to 15%, while AIG node counts and post-mapping depth also decrease.
- Computational Cost and Token Usage: 68% of total LLM usage is spent profiling ABC initially, while evolution cycles consume 21% and complete in approximately 2–3 hours per iteration.Each cycle costs an estimated $60–$80, with 87 CPU nodes evaluating benchmarks and correctness in parallel.
- Self-Evolved Code Quality and Discussion: The generated code converges to native ABC conventions, reproducing formatting, naming, macro organization, help strings, and Abc_Print usage patterns.The automatically generated abcFlowTune7.c module exemplifies this fidelity to hand-written ABC components.
- Self-Evolved Code Quality and Discussion: Agents reliably refine algorithmic directions with structural precedent, but entirely novel constructs more often fail through compilation, runtime, or correctness problems.The framework therefore amplifies and recombines human-curated priors more reliably than it discovers unsupported paradigms.
5 Conclusion
The paper concludes that multi-agent LLM programming combined with correctness-preserving compilation and QoR evaluation can autonomously improve ABC across its full codebase. It also emphasizes that current success depends on substantial domain knowledge and decades of prior EDA contributions.
- Conclusion: The framework autonomously improves an EDA tool by learning algorithmic strategies over the entire ABC codebase through correctness-preserving compilation and QoR-driven evaluation.The authors characterize this as a repository-scale, agentic, self-improving approach to EDA tool development.
- Conclusion: Current agents perform well only when guided by sufficient domain knowledge, building on foundational algorithms, tools, and knowledge developed by the EDA community.The conclusion explicitly frames the results as enabled by prior human contributions rather than created in isolation.