PaperlayerView exact revision on arXiv

Source-linked AI summary

Autonomous Evolution of EDA Tools: Multi-Agent Self-Evolved ABC

Cunxi Yu, Haoxing Ren

arXiv:2604.15082v1cs.ARcs.AI

TL;DR

ABC's tightly coupled codebase and the human-intensive work of developing synthesis heuristics make tool improvement difficult. The paper uses specialized LLM agents to evolve ABC under correctness and QoR evaluation, reporting improvements in timing and area–delay product across benchmark suites, including roughly 8.3% lower area–delay product.

  • Problem

    ABC extensions often remain external prototypes or scripts, while its tightly coupled, million-line codebase makes integrating and improving heuristics difficult for human developers.

    Source: §1 · p. 1, §2.1 · p. 2

  • Method

    Specialized LLM agents iteratively modify ABC subsystems, with correctness verification and QoR evaluation guiding evolution across benchmark circuits.

    Source: §1 · p. 2, §3.2 · p. 4

  • Results

    Across all benchmark suites, the evolved system improves static timing and area–delay product, with area–delay product reduced by roughly 8.3%.

    Source: §4.1 · p. 6

  • Takeaways & Limitations

    The study supports repository-scale, agentic self-improvement as a possible direction for EDA tool development.

    Source: §5 · p. 6

    Agents are more reliable at refining heuristics with structural precedent in ABC than at introducing entirely novel algorithmic constructs without scaffolding.

    Source: §4.3 · p. 6

Abstract

from arXiv · show

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 progress remains constrained by human-intensive, heuristic-driven development, and this paper introduces a multi-agent LLM framework that evolves ABC itself through correctness- and QoR-driven iteration.

1 Introduction

  • EDA progress is difficult because combinatorial search, interacting components, and expert-designed static heuristics make tools hard to evolve, while many ABC advances remain external or loosely integrated.The paper frames LLM code generation and iterative algorithm refinement as a promising route to autonomous EDA development, building on AlphaEvolve [21] and SATLUTION [28].Source: §1 · p. 1
  • ABC’s scale and interconnected layers pose challenges beyond prior evolution methods: AlphaEvolve targets small kernels [21], while SATLUTION evolves repositories on the order of tens of thousands of lines [28].ABC spans more than 1.2 million lines of C, over 4,000 source files, and four hierarchical abstraction layers; changes can have far-reaching effects.Source: §1 · pp. 1–2
  • The framework starts from ABC augmented with recent research extensions, then iteratively proposes module-level C changes, checks correctness, and evaluates QoR on benchmark circuits.Beneficial modifications are retained across generations.Source: §1 · p. 2
  • The framework demonstrates autonomous code evolution at the full scale of ABC, with evaluation across standard synthesis benchmarks showing improvements beyond human-engineered baselines.ABC contains more than 1.2 million lines of C code; the paper reports benchmark-based evaluation of the evolved tool.Source: §1 · pp. 1–2
  • A multi-agent architecture decomposes ABC into functional subsystems so specialized agents can collaboratively evolve shared code under a unified QoR-driven objective.Agents propose modifications to their respective modules, while beneficial changes are retained and accumulated over generations.Source: §1 · p. 2
  • Formal equivalence checking supplies correctness feedback that the authors say increases successful evolution steps while reducing LLM token usage and computational cost.The workflow checks that modified tools still produce correct logic transformations before evaluating QoR.Source: §1 · p. 2

2 Background

Logic synthesis transforms Boolean networks into technology-specific implementations through logic optimization and technology mapping, and ABC’s effectiveness relies on extensive hand-engineered heuristics. The section explains why improving ABC is difficult and why repository-scale, multi-agent evolution requires domain guidance and rigorous correctness and QoR feedback.

2.1 Logic Synthesis and the ABC Framework

  • Logic synthesis combines correctness-preserving logic optimization with technology mapping, and practical tools use multi-stage heuristics because both problems are NP-hard.ABC is a widely used open-source synthesis and verification platform containing algorithms for rewriting, resubstitution, refactoring, and cut-based mapping.Source: §2.1 · p. 2
  • ABC’s millions of lines of tightly coupled code, saturated human-driven QoR improvements, and slow manual iteration make heuristic changes difficult and error-prone [29].Potential gains from changing pass ordering, scoring functions, or mapping heuristics remain largely unexplored because manually evaluating them is prohibitively demanding; LLM coding agents [3] [7] could explore these variations continuously.Source: §2.1 · p. 2

2.2 Self-Evolving Programming

  • AlphaEvolve [21] improved compact algorithmic kernels, while SATLUTION [28] demonstrated repository-scale evolution of SAT solvers under strict correctness checks.SATLUTION’s evolved solvers surpassed human-engineered SAT Competition winners, but AlphaEvolve targets procedures with few dependencies and limited cross-module interaction.Source: §2.2 · p. 2
  • ABC’s scale, internal coupling, and conflicting synthesis objectives make existing agentic frameworks unsuitable without multi-agent coordination, domain guidance, and rigorous correctness and feedback loops.ABC comprises more than 1.2 million lines across over 4000 source files, and synthesis must jointly optimize area, delay, depth, node count, mapping cost, and correctness under technology constraints.Source: §2.2 · pp. 2–3

3 Approach

The framework bootstraps ABC with integrated synthesis components and specialized agents, then evolves designated subsystems through an iterative cycle of planning, code changes, correctness checks, benchmark feedback, and rule refinement. Formal equivalence checking rejects functionally incorrect changes before QoR evaluation.

3.1 Knowledge Bootstrapping

  • The bootstrap selects FlowTune as an ABC-integrated flow-tuning backbone and uses codebase analysis to identify mapper heuristic injection points and technology-independent optimization opportunities.The preparation surveyed prior work in flow tuning, mapping [17], and technology-independent optimization [2, 12, 13, 16, 17]; external mapping implementations were not directly reused because of integration challenges.Source: §3.1 · pp. 3–4

3.2 Agent Setups and Agent Roles

  • Three specialized coding agents evolve flow scheduling, technology mapping, and technology-independent optimization in distinct ABC subsystems toward better QoR without changing functional semantics.Only cycle 0 receives human-provided context; later planning and execution are autonomous, with intervention limited to safety triggers after more than ten consecutive compilation or equivalence-checking failures.Source: §3.2 · p. 4

3.3 Evolutionary Iteration Workflow

  • Each evolution cycle coordinates subsystem-specific planning and coding, compiles changes, checks correctness, evaluates QoR, and feeds results into subsequent evolution.Evaluation runs benchmarks under eight flows on 87 CPU nodes and uses collected structural and end-of-flow metrics to compute rewards and QoR deltas; improvements can enter the champion version, while regressions trigger rollback. The self-evolving rulebase constrains subsystem edits and can be refined under global safety constraints as feedback patterns emerge.Source: §3.3 · pp. 4–5
  • Cycle 0 equips the planner with structured repository profiling, Markdown implementation guidance, and synthesis-flow explanations to support reliable planning.For later cycles, the planner uses QoR feedback, agent hypotheses, and code changes to choose the next evolution step.Source: §3.3 · p. 4

3.4 Correctness guided by Equivalence Checker

  • CEC screens every modification before QoR evaluation, rejecting mismatches and returning counterexamples as corrective feedback.The approach checks combinational designs directly and sequential designs with a single-frame bounded-model formulation (BMC depth 1), since the evolved algorithms do not alter retiming or sequential behavior.Source: §3.4 · p. 5

4 Results and Discussion

The fully evolved ABC system achieves its best normalized QoR when FlowTune, AIG Syn, and Map evolve jointly, with improvements in timing and area–delay product across benchmark suites. The results also describe computational costs and show both strong adherence to ABC coding conventions and limitations when agents attempt unsupported novel algorithms.

4 Results and Discussion

  • Experiments used eight ASAP7 7 nm synthesis flows on 87 AMD EPYC CPU nodes, with benchmarks spanning ISCAS’85/’89, ITC’99, EPFL, VTR DSP, and arithmetic blocks.The multi-agent system used Claude 4.5 Sonnet models in the enterprise-version Cursor environment.Source: §4 · p. 5

4.1 Self-Evolved ABC Evaluation

  • The strongest gains arise when all three subsystems evolve jointly, achieving the best result of 0.917, corresponding to an overall improvement of approximately 8.3% relative to the vanilla integrated baseline.Source: §4.1 · p. 6
  • Worst negative slack improves approximately 8 to 9% on average, while area–delay product falls roughly 8.3% versus the vanilla integrated baseline.EPFL arithmetic circuits show 12 to 15% timing improvements; AIG node counts decrease 3 to 8% on arithmetic-heavy designs, and post-mapping depth decreases 4 to 6%.Source: §4.1 · p. 6

4.2 Computational Cost and Token Usage

  • $2,400 is the approximate total token cost of the full system, and each full iteration takes approximately 2–3 hours on 87 parallel CPU nodes.Initial ABC profiling accounts for 68% of LLM usage and external-codebase profiling for 11%; evolution cycles use the remaining 21%. Each cycle costs an estimated $60–$80, and full-design equivalence checking means more than 90% of tokens are spent on semantically valid code states.Source: §4.2 · p. 6

4.3 Self-Evolved Code Quality and Discussion

  • Evolved agents closely reproduce ABC’s native C coding conventions, including formatting, naming, comments, macros, and Abc_Print usage.The generated abcFlowTune7.c example follows ABC’s header layout and namespace structure and reproduces parameter help strings, indentation, and macro-driven defaults.Source: §4.3 · p. 6
  • Agents reliably refine heuristics with structural precedent in ABC, but unsupported novel algorithmic constructs more often fail through compile errors, crashes, or correctness violations.The results characterize the framework as effective at amplifying and recombining human-curated priors, but less reliable at proposing new paradigms without scaffolding.Source: §4.3 · p. 6

5 Conclusion

The framework autonomously improves EDA tools by combining LLM-based multi-agent programming with correctness-preserving compilation and QoR-driven evaluation across the ABC codebase. The authors present this as a repository-scale self-improving approach, while emphasizing its dependence on domain guidance and foundational EDA work.

5 Conclusion

  • The framework learns algorithmic strategies while autonomously improving EDA tools across the entire ABC codebase.It couples LLM-based multi-agent programming with correctness-preserving compilation and QoR-driven evaluation.Source: §5 · p. 6
  • The work presents repository-scale, agentic, self-improving tool development as a possible path toward future EDA development.Source: §5 · p. 6
  • The agents perform well only with sufficient domain knowledge, and their success builds on decades of foundational contributions from the EDA community.Source: §5 · p. 6

Related papers

Loading 2604.15082v1…