Dr. RTL: Autonomous Agentic RTL Optimization through Tool-Grounded Self-Improvement Wenji Fang, Yao Lu, Shang Liu, Jing Wang, Ziyan Guo, Junxian He, Fengbin Tu, Zhiyao Xie∗ Hong Kong University of Science and Technology (HKUST)
arXiv:2604.14989v1 [cs.AI] 16 Apr 2026
ABSTRACT Recent advances in large language models (LLMs) have sparked growing interest in automatic RTL optimization for better performance, power, and area (PPA). However, existing methods are still far from realistic RTL optimization: their evaluation is often unrealistic, based on manually degraded, small-scale RTL designs and weak open-source toolchains; their methods are also limited, relying on coarse design-level feedback and simple pre-defined rewriting rules. To address these limitations, we present Dr. RTL, an agentic framework for RTL timing optimization in a realistic evaluation environment, with continual self-improvement through reusable optimization skills. We establish a realistic evaluation setting with more challenging RTL designs and an industrial EDA workflow. Within this setting, Dr. RTL performs closed-loop optimization through a multi-agent framework for critical-path analysis, parallel RTL rewriting, and tool-based evaluation. We further introduce group-relative skill learning, which compares parallel RTL rewrites and distills the optimization experience into an interpretable skill library. Currently, this library contains 47 pattern–strategy entries for cross-design reuse to improve PPA and accelerate convergence, and it can continue evolving over time. Evaluated on 20 real-world RTL designs, Dr. RTL achieves average WNS/TNS improvements of 21%/17% with a 6% area reduction over the industry-leading commercial synthesis tool.
1
INTRODUCTION
Register-transfer level (RTL) design is a critical abstraction in modern digital ICs, manually developed by human engineers to bridge architectural specification and downstream logic synthesis. The quality of RTL largely determines the optimization space available to the subsequent synthesis and physical design tools. Modern RTL designs often incorporate deep pipelines, wide arithmetic datapaths, and tightly coupled control–data interactions [36], all of which make timing closure more challenging. Bottlenecks introduced at the RTL stage often propagate through the design flow, leading to repeated RTL revisions, conservative timing constraints, and suboptimal PPA trade-offs. Consequently, improving RTL quality before synthesis remains an important yet challenging task. Automatic synthesis optimization vs. manual RTL optimization. Synthesis and RTL optimization operate at different abstraction levels and complement each other. Synthesis improves PPA by transforming a fixed RTL into an optimized gate-level implementation through Boolean rewriting and technology mapping [4, 6, 9, 15, 18, 40, 46], but it remains constrained by the original RTL structure and cannot change higher-level design choices such as datapath organization or pipelining. Consequently, further PPA improvement often requires iterative manual RTL rewriting guided by synthesis feedback: engineers identify critical paths with timing reports, revise the RTL, and re-run synthesis to evaluate each change, as illustrated in Figure 1. However, this process remains labor-intensive, time-consuming, and heavily dependent on ∗ Corresponding Author ([email protected])
Realistic RTL Evaluation Environment Function Checking
Original RTL
Logic Synthesis
Opt RTL
Timing Report
Better PPA
iterative optimize
interact
Autonomous LLM Agent
enhance
Reusable Opt Skill library
Self-improving Analyze Optimize Evaluate
discover
Pattern
Strategy
Figure 1: Dr. RTL iteratively optimizes RTL PPA via closedloop interaction with industrial EDA tools, while distilling trajectories into reusable skills for self-improvement. implicit human expertise, making it difficult to automate systematically. More fundamentally, the RTL design space is vast, effectively infinite for practical purposes, while human-driven optimization typically evaluates only one candidate design per iteration, exploring only a negligible fraction of the possible optimization space. LLM for RTL Design. To reduce this manual effort, recent advances in large language models (LLMs) have sparked growing interest in RTL design automation, as summarized in recent surveys [7, 13, 16, 25, 29, 42]. Most prior works [1, 2, 8, 10–12, 14, 17, 20, 21, 24, 26, 27, 30, 33–35, 41, 43–45] focus on generating RTL from natural language specifications, with functional correctness as the primary objective and PPA only weakly considered. They are also typically evaluated on small-scale benchmarks such as VerilogEval [19] and RTLLM [22], which fall short of the complexity and critical-path behavior of real-world RTL designs. More recently, several studies [5, 23, 28, 37–39] start to explore RTL optimization, aiming to rewrite existing RTL for better PPA while preserving functionality, as summarized in Table 1. Limitations of existing LLM-based RTL optimization. Despite recent progress, existing approaches remain far from addressing realistic RTL optimization in both evaluation and methodology: From an evaluation perspective, they suffer from three key issues: (1) Weak starting RTL. Prior works [5, 23, 28, 37–39] evaluate on manually degraded RTL with injected degradation or redundancies. This makes the task easier and less realistic, reducing it to PPA repair rather than true optimization of well-written RTL. (2) Unrealistic toolchains. Most studies [5, 28, 37–39] rely on open-source synthesis tools that are much weaker than commercial ones, so some reported gains may already be absorbed by commercial tools and may reflect tool limitations rather than true RTL optimization. (3) Very limited scale. Existing evaluations [5, 23, 28, 37–39] focus on tiny modules and fail to reflect the scale and complexity of industrial RTL designs. From a methodology perspective, existing methods are limited by two factors. First, they rely mainly on LLM-based code inspection, without fine-grained EDA feedback to guide critical-path optimization. Second, they depend on pre-defined basic rewriting rules from
Table 1: Comparison with existing LLM-based RTL optimization benchmarks and methods. RTL Dataset Work RTLRewriter [39] SymRTLo [37] RTL-OPT [23] POET [28] CODMAS [5] Dr. RTL (ours)
LoC★
NoM★
Complexity
[8, 86, 1275] [1, 1, 14] Same as [39] Module [8, 31, 135] [1, 1, 1] Same as [23] Not publicly accessible [128, 812, 4615]
[1, 3, 7]
Tool Use
IP/Design
Planning
Memory
Coarse-grained design PPA only
Single LLM
Pre-defined rewriting rules
Fine-grained critical path
Orchestrator + Sub-agents
Opt Input
EDA Tool
PPA Feedback
Manual-degraded RTL
Yosys + Simulation Yosys/DC+ Simulation DC + CEC† Yosys + Simulation Yosys + Simulation DC + SEC†
Original humanwritten RTL
Multi-LLM Skill selfimproving
★ We report the [minimum, average, maximum] lines of code (LoC) and number of modules (NoM) for each dataset. Our dataset is around 10 × larger than existing ones. † Prior work relies on combinational equivalence checking (CEC), which cannot verify sequential changes. Our method employs sequential equivalence checking (SEC),
supporting both combinational and sequential optimization scenarios.
textbooks [37, 39], which are often ineffective under modern synthesis tools and restrict the discovery of non-trivial optimization strategies. These gaps motivate the following research questions:
knowledge, enabling cross-design reuse for better PPA, fewer invalid transformations, and faster convergence. Specifically, (1) Timing bottleneck patterns: realistic RTL timing bottlenecks are often recurrent, arising from structural patterns such as deep decode logic, wide comparisons, and mux-heavy selection, which reveal optimization opportunities beyond synthesis alone; (2) Effective strategies: for these patterns, effective strategies consistently emerge, including pre-computation, decomposition, and selective register insertion; and (3) Invalid strategies: many naive transformations are either absorbed by synthesis or violate equivalence, such as manual rebalancing of optimized logic or moving control updates across registers. In our current implementation, Dr. RTL extracts 47 pattern–strategy entries and releases them as a public skill library, which can be further expanded by applying the framework to more designs and incorporating expert knowledge from RTL designers. Together, Dr. RTL takes a step toward practical agentic RTL optimization that improves at test time without requiring LLM finetuning. More broadly, it points to a new paradigm of agentic design automation, in which humans define the task, VLSI workflow, and constrained EDA feedback, while the agent autonomously explores effective solutions and accumulates reusable knowledge within this environment for self-improvement. The contributions of this work are summarized as follows:
Q1. Evaluation: How should RTL optimization be evaluated to reflect the realistic industrial scenario? Q2. Method: How can we perform effective RTL optimization and discover reusable optimization knowledge? Q3. Optimization Gap: What optimization opportunities cannot be handled by industrial synthesis and therefore require RTL optimization? To address these questions, we propose Dr. RTL1 , a tool-grounded agentic RTL timing optimization framework with self-improving capability. As shown in Figure 1, built on a realistic evaluation setting (A1), Dr. RTL performs closed-loop optimization (A2) through iterative interaction with EDA tools while continually distilling reusable optimization knowledge into a skill library (A3). We first answer Q1: A1. Realistic industrial evaluation. We establish a realistic evaluation environment for RTL timing optimization with 20 larger-scale, human-written designs. Compared with prior works, it improves over three aspects: 1) Realistic starting RTL, starting from human-written RTL instead of manually degraded inputs, reflecting true optimization scenario; 2) Industrial-standard toolchain, using commercial synthesis for strong optimization and sequential equivalence checking (SEC) to ensure both combinational and sequential equivalence, ensuring high-fidelity PPA evaluation; and 3) Larger design scale, evaluating designs that are around 10× larger and more complex than prior small-scale designs, better capturing the hierarchy and critical-path complexity of real RTL. Under this evaluation, we answer Q2 with A2. Tool-grounded self-improving agentic RTL optimization. We propose two coupled techniques for effective RTL optimization and continual self-improvement: (1) Agentic optimization: it formulates RTL optimization as a tool-grounded search problem over equivalent RTL transformations, using a multi-agent framework to iteratively perform timing analysis, RTL candidate rewriting, and tool-based evaluation. This enables adaptive exploration and exploitation over a large optimization space guided by fine-grained critical-path feedback. (2) Group-relative skill learning: Dr. RTL compares parallel rewritten RTL candidates from the same parent RTL and distills their optimization trajectories into reusable, human-interpretable skills, enabling continual test-time self-improvement without supervision or parameter tuning. We further answer Q3 with A3. Reusable RTL optimization knowledge. The learned skills capture three forms of reusable
• Problem. We identify RTL timing optimization as a practical and underexplored problem, where strong humanwritten RTL must be improved beyond synthesis rather than merely repaired from degraded inputs. • Evaluation. We establish a realistic evaluation for RTL optimization, featuring challenging human-written RTL, commercial synthesis, and sequential formal verification. • Method. We develop Dr. RTL, a tool-grounded closed-loop agentic RTL optimization framework, together with grouprelative skill learning for continual self-improvement. • Knowledge. We extract explicit RTL optimization knowledge, consisting of 47 pattern–strategy pairs, for crossdesign reuse to improve PPA and accelerate convergence. • Result. Across 20 diverse RTL designs, Dr. RTL achieves average WNS/TNS improvements of 21%/17% while reducing area by 6% over commercial synthesis, demonstrating Pareto optimization beyond simple timing–area trade-offs.
2
PROBLEM FORMULATION
We formulate RTL timing optimization as an agentic optimization problem, where the LLM agent iteratively interacts with a commercial EDA environment. The synthesis and verification flow evaluates candidate RTL designs, and the agent proposes transformations
1 The RTL dataset, evaluation environment, agentic implementation, and learned opti-
mization skills are open-sourced at https://github.com/hkust-zhiyao/Dr_RTL. 2
Optimized RTL 𝒟 ∗
Multi-Agent Close-Loop RTL Optimization
Iterative Workflow (K rounds per design)
Harder real RTL opt task
Metrics
Input Agentic Optimizer RTL Design (rtl.v)
Dr. RTL (ours) HumanWritten RTL 𝒟0 Manual degraded
Existing Works
LLM Repair
Suboptimal ෪0 RTL 𝒟
Best PPA over k rounds
Optimized RTL i
Coordinate
Orchestrator
Iterate
Analysis Agent
Optimization Agent
Evaluation Agent
Fine-Grained Slack
+ Skill Guidance
SEC✓ PPA↑
Constraints (SDC.tcl)
SEC vs. Original
PPA Report (PPA/slack.txt)
Synthesis + STA
SEC Pass Rate
Original RTL
Toolchain (Syn + SEC)
Record PPAi (WNS, TNS, Area)
Convergence Steps
Parallel RTL Candidates
PPA Improve
pass
Select Current Best RTL
Easier PPA repair task
next round
Better RTL
Group-Relative Skill Self-Evolution Skill Learning Agent • Rank candidates • Extract patterns • Update skills
Skill Library Patterns – Strategies
(a) Evaluating agentic RTL timing optimization (Sec. 3) (b) Overview of Dr. RTL agentic framework (Sec. 4) Figure 2: Proposed industrial-standard RTL optimization evaluation and overview of Dr. RTL for agentic RTL optimization. based on the resulting feedback. Formally, given an initial RTL design D0 , the goal is to obtain an optimized design D ∗ that improves post-synthesis PPA while preserving functional equivalence. We assume fixed synthesis settings and preserve the original microarchitecture, including pipeline latency. Under this constraint, we allow both combinational transformations and latency-preserving sequential restructuring, such as retiming-like register redistribution or duplication. The optimization objective is defined as: min 𝑓 (WNS, TNS, Area) D
s.t.
D ≡ D0 .
Together, this workflow enables reliable evaluation of RTL optimization under realistic industrial constraints. (3) Agentic optimization metrics. To evaluate iterative agentic optimization, we report not only final PPA but also iteration metrics. Specifically, we measure: 1) best PPA over all iterations, reflecting the peak optimization result; 2) PPA improvement relative to the initial design D0 ; 3) SEC pass rate, reflecting the validity rate of proposed transformations; and 4) convergence steps, measuring how quickly the optimization stabilizes. Together, these metrics characterize both optimization quality and agentic behavior.
(1)
4
For PPA evaluation, we focus on timing optimization while controlling area as a trade-off. Power is excluded from the current objective because accurate power estimation is workload-dependent and cannot be reliably assessed through static evaluation alone.
3
DR. RTL METHODOLOGY
Figure 2(b) shows the overall architecture of Dr. RTL. The framework combines two tightly coupled aspects: (1) a closed-loop optimization framework that iteratively performs timing analysis, RTL transformation, and tool-based evaluation under industrial EDA feedback via three specialized agents, as illustrated in Section 4.1, and (2) a learning mechanism based on group-relative skill learning, which compares parallel transformations under the same optimization context and distills effective experience into reusable pattern–strategy skills, as detailed in Section 4.2. Together, they enable continual improvement in both optimization quality and efficiency. We describe them below.
AGENTIC RTL OPTIMIZATION EVALUATION ENVIRONMENT
Figure 2(a) illustrates our industrial-standard evaluation environment for agentic RTL timing optimization. Compared with prior benchmarks [5, 23, 39], our setup improves over three dimensions: input designs, toolchain, and evaluation metrics. (1) Input designs. We evaluate on original human-written RTL designs D0 collected from diverse open-source projects, rather than manually degraded RTL D̃0 constructed by injecting artificial degradations or redundancies into a reference design D0 . As summarized in Table 1, prior benchmarks are typically limited to small single-module designs, often with only tens of lines of code. In contrast, our dataset contains substantially larger and more complex designs, with 812 lines of code on average, deeper module hierarchies, and diverse design types and coding styles. This setting better reflects realistic RTL optimization to improve already strong human-written RTL. (2) Commercial synthesis with complete formal verification. We adopt an industrial-standard EDA workflow that combines commercial logic synthesis with sequential formal equivalence checking (SEC). Commercial synthesis provides stronger and more realistic optimization than open-source tools such as Yosys [5, 28, 37, 39], reducing the chance that simple RTL rewrites appear effective only because the synthesis is weak. SEC is used to ensure equivalence after both combinational and sequential transformations. This is stronger than simulation-based checking [5, 28, 37, 39], which is incomplete, and combinational equivalence checking [23], which cannot support sequential rewrites.
4.1
Agent Design and Responsibilities
Figure 3 illustrates our orchestrator–agent framework. The orchestrator coordinates three specialized agents: (1) a timing analysis agent that identifies critical-path bottlenecks from post-synthesis timing reports; (2) an RTL optimization agent that rewrites 𝑁 candidate designs in parallel through equivalent transformations guided by the timing analysis; and (3) an evaluation agent that runs synthesis and equivalence checking to return PPA and correctness feedback for the next round of analysis. This decomposition provides three benefits: (1) task specialization, where each agent focuses on a well-defined role aligned with the industrial workflow, improving reliability and interpretability; (2) parallel exploration, where parallel candidate generation and selection turn optimization into a tool-guided search over a non-convex design space; and (3) modular learning, where the decomposition enables optimization behaviors to be attributed, analyzed, and reused. Overall, this design aligns agent roles with tool boundaries, leverages feedback, and balances exploration with refinement. We describe each agent below. The empirical benefit of the decomposition is shown in Section 5.5. 3
Original RTL
Orchestrator: Iterative RTL Exploration & Selection Opt RTL 1: Seq. Rebalance
… Logic Synthesis
Parallel Explore SP1
Comb1
EP1
…
Original Report ▪ Baseline PPA WNS/TNS/Area ▪ Slack SP1→EP1:-0.36 … SPi→EPj:-0.13
Timing Analysis Agent • Top-k Paths • Path-to-RTL • Root Cause
Path 1 Analysis • Path: SP1 → EP1 • Path-to-RTL Reg SP1 → Decode → Mux → FIFO Write → EP1 • Root Cause Long control-data mux chain
❶ Fine-Grained Timing Slack Analysis Next Iteration
RTL Optimization Agent • Combinational • Sequential • Continual Skill Learning
Opt Report 1 Success ▪ Func. ▪ PPA trajectory WNS: ↓ ✓ ▪ Slack TNS: ↓
…
EP1: -0.28
Opt RTL 2: Comb. Simplify
… Opt RTL n: Seq. Duplication
…
Best PPA
Opt Report 2
• Control EDA Tools • PPA evaluation • Function check
▪ Func.
▪ PPA
▪ Slack
WNS: Failed TNS: Area: - trajectory
Syn
❷ Skill-Guided RTL Rewriting
Area: ↓
Evaluation Agent
EDA tools
SEC
❸ Automatic Evaluation
EP1: -
Opt Report n
Success ▪ Func. ▪ PPA trajectory WNS: ↓ ✓ ▪ Slack TNS: ↓ EP1: -0.24
Area: ↑
Figure 3: Multi-agent framework of Dr. RTL. Dr. RTL coordinates timing analysis, RTL optimization, and evaluation agents in a closed loop, using industrial EDA feedback to localize critical paths, explore RTL candidates in parallel, and promote the best SEC-passing design for iterative PPA improvement. 4.1.1 Orchestrator. The orchestrator has three responsibilities: executing the optimization loop, selecting among parallel candidates across iterations, and maintaining trajectory logs for subsequent skill learning. Starting from an initial design D0 , the system evolves over 𝑡 = 0, 1, . . . , 𝐾 following 𝑁 D𝑡 → {D𝑡(𝑖 ) }𝑖=1 → D𝑡 +1,
4.1.3 RTL Optimization Agent. The RTL optimization agent gen𝑁 in parallel based on timing erates 𝑁 candidate designs {D𝑡(𝑖 ) }𝑖=1 analysis and the accumulated skill library S (detailed in Section 4.2). Guided by critical-path information and root-cause analysis, it applies equivalent transformations to handle true bottlenecks. It first queries S for pattern–strategy entries matching the diagnosed bottleneck. If a match is found, the corresponding skill-guided transformation is applied to D𝑡 . Otherwise, the LLM proposes a new transformation conditioned on the timing feedback. This design balances exploration and exploitation. Exploration comes from generating multiple candidates in parallel, either by applying different transformations to the same bottleneck or by targeting different bottlenecks in the current iteration. Exploitation comes from promoting the best SEC-pass candidate D𝑡 +1 to the next iteration and from reusing effective skills in S across designs. Compared with prior methods driven by coarse design-level metrics and fixed basic rewriting rules, our optimizer uses critical-pathlevel feedback and learned skills to guide adaptive RTL transformations, improving both search efficiency and optimization quality.
(2)
where agents generate and evaluate 𝑁 candidate designs in parallel based on EDA tool feedback. To coordinate the framework, the orchestrator maintains a shared JSON state that serves as the communication interface across agents. This state records timing analysis results, candidate RTL edits, evaluation outcomes, and iteration history, allowing each agent to consume structured outputs from previous stages and write back its own results. The same structured logs are also used to maintain optimization trajectories for subsequent skill learning. We provide a detailed illustration in Section 4.2. To evaluate the PPA results, at each iteration, a scalar score is computed for each SEC-pass candidate: Score𝑖 = 𝛼 WNS𝑖norm + 𝛽 TNS𝑖norm + 𝛾 Area𝑖norm + penalty𝑖 ,
(3)
4.1.4 Evaluation Agent. The evaluation agent executes the synthesis and verification toolchain. Given a candidate design, it runs the commercial synthesis flow and sequential equivalence checking (SEC), and returns the resulting metrics (WNS𝑖 , TNS𝑖 , Area𝑖 , SEC𝑖 ). The evaluation agent performs no reasoning or report interpretation, ensuring a strict separation between execution and decisionmaking. This design guarantees that all optimization decisions are based solely on verified EDA feedback, avoiding hallucinations.
PPA𝑖 −PPAbaseline where PPA𝑖norm = PPA , and 𝛼, 𝛽, 𝛾 ∈ [0, 1] are weighting baseline 2 factors . Lower scores indicate better timing–area trade-offs. For
WNS and TNS, improvement means moving closer to zero. The next starting design is chosen as the best SEC-passing candidate: D𝑡 +1 = arg min Score𝑖 , (𝑖 )
s.t.
SEC𝑖 = 1,
(4)
D𝑡
where SEC𝑖 ∈ {0, 1} indicates functional correctness.
4.2
4.1.2 Timing Analysis Agent. The timing analysis agent identifies timing bottlenecks through fine-grained slack analysis, but does not directly propose fixes. Rather than relying on coarse design-level feedback such as a single WNS value, it uses detailed post-synthesis timing reports to localize critical-path issues back to RTL structure. Given the current design and timing report, the agent selects the top-𝑘 critical paths by slack. For each path, it performs path-to-RTL mapping by locating the startpoint and endpoint registers and tracing the intermediate combinational logic back to the corresponding RTL regions. It then diagnoses likely root causes of delay, such as excessive combinational depth, high fanout, control–data coupling, or reconvergent logic, to guide subsequent RTL optimization agent.
Group-Relative Skill Learning from Hierarchical Optimization Trajectories
A central goal of Dr. RTL is not only to optimize the current design, but also to accumulate reusable optimization knowledge over time. Without such skill learning, each iteration would rely mainly on local trial-and-error, making it difficult to systematically reuse successful transformations across iterations and designs. A reusable skill library is therefore important for improving PPA more efficiently, reducing invalid or unhelpful transformations, and accelerating convergence through cross-design reuse, and providing interpretable knowledge of what works and why. A key challenge, however, is determining which transformations are truly worth storing as skills. Because EDA outcomes are heuristic and design-dependent, absolute PPA values are often noisy and not directly comparable across candidates or iterations. This makes
2 In our experiments, we set 𝛼 = 0.5, 𝛽 = 0.35, and 𝛾 = 0.15. We set penalty = 0.5 𝑖 if Area𝑖norm > 0.1, and 0 otherwise, to discourage excessive area overhead. Different
settings can be used to target different PPA trade-offs. 4
Parallel new RTL candidates Opt RTL 1
PPA1
A1
Opt RTL 2
PPA2
A2
…
…
…
Opt RTL n
PPAn
An
as condition pre-computation, signal replication, or selective register insertion. We will provide detailed case studies in Section 6.1. Skill update. Based on these abstractions, Dr. RTL updates a confidence-aware skill library by merging newly extracted pattern– strategy pairs with existing entries and accumulating simple empirical statistics, including occurrence count, SEC-pass count, and mean relative advantage across iterations and designs. Skills that repeatedly appear in successful trajectories are assigned higher confidence, while unreliable or ineffective ones are deprioritized as invalid strategies. Overall, group-relative skill learning converts noisy absolute PPA feedback into more reliable relative signals, enabling continuous self-improvement without supervision or reward design.
Skill Learning Agent Group Relative Skill Learning 1. Group relative comparison
2. Pattern & strategy abstraction
3. Skill update
Learned Skills
Optimization Trajectories • PPA/SEC Opt 1 Reg 1/2 Rebalance ✓ + Better PPA analysis Opt 2 Comb 1 Simplify • Top-K path Opt n Reg1 Duplicate ✓ + tradeoff analysis
Pattern
Strategy
Impact
Long comb.
Reg. Rebalance
High fanout
Reg. Duplicate
Wide mux
Comb. Simplify
Timing ↓ Timing ↓ Area ↑ Unstable
…
…
…
Self-improve
Figure 4: Group-relative skill learning. Parallel RTL candidates are compared to extract patterns and strategies, which are stored as reusable skills for continuous improvement.
5 EXPERIMENTAL RESULTS 5.1 Experimental Setup
it difficult to attribute improvement to any single transformation, especially when multiple edits are composed over time. To address this, we propose group-relative skill learning, as illustrated in Figure 4. The core idea is to evaluate a strategy not by its absolute PPA outcome, but by how well it performs relative to other candidates generated from the same parent RTL under the same timing feedback and tool settings. We refer to the set of parallel 𝑁 in iteration 𝑡 as a group. This within-group candidates {D𝑡(𝑖 ) }𝑖=1 comparison provides a more stable signal for identifying effective strategies without external supervision. Hierarchical optimization trajectory. Each candidate design is associated with an optimization trajectory that records its full optimization context, including the timing analysis, applied RTL transformations, and resulting evaluation outcomes. We organize these trajectories as a three-layer hierarchy. The top layer contains the iteration round, recording the temporal evolution of optimization. Within each round, the second layer stores all parallel candidate designs together with their PPA and SEC results, preserving the within-group context needed for relative comparison. At the lowest layer, it records critical-path-level information, including the analyzed bottlenecks, their structural patterns and root causes, the transformations applied, and the resulting outcomes. This hierarchical trajectory connects analysis, optimization actions, and evaluation results across multiple granularities, providing the structured context needed for comparison and skill extraction. Group-relative comparison. Built on this trajectory representation, Dr. RTL compares parallel candidates within each group by computing a relative advantage signal: 𝐴𝑖 =
score𝑖 − 𝜇𝑡 , 𝜎𝑡
Diverse RTL design dataset. We evaluate Dr. RTL on 20 humanwritten Verilog designs selected using three criteria: complex functionality, full synthesizability, and size ranging from hundreds to thousands of lines of code. The dataset spans diverse IPs and systems, including buffers, processors, signal-processing modules, cryptographic designs, and SoCs, with a wide range of scales and structural complexity. Detailed statistics are summarized in Table 2, with an average of 812 LOC (min 128, max 4615) and 3 modules per design. We also report synthesized gate and register counts to reflect design complexity. For comparison, we further evaluate on all large designs from the representative benchmark of [39], detailed in Section 5.3. Evaluation workflow. We evaluate Dr. RTL and all baselines under a unified protocol. All designs are synthesized with Synopsys Design Compiler using the Nangate 45 nm library [31] under fixed synthesis constraints for fair comparison. In particular, we use a tight clock period of 0.1 ns to force aggressive synthesis optimization across all paths. Functional equivalence between design versions is verified by sequential equivalence checking using Cadence Jasper SEC [32]. For each design, every method runs 10 iterations with 5 parallel candidates per iteration, for 50 optimization attempts in total. At each iteration, the best SEC-passing candidate is selected by PPA and promoted to the next round. We report the best PPA improvement, SEC pass rate, and optimization trajectories. To explicitly evaluate skill generalization, we use 4-fold cross-validation in the skill application setting: in each fold, optimization skills are extracted from 15 designs and then applied to 5 unseen designs. The skill library is reset for each fold, and all prompts and examples are kept strictly fold-isolated, preventing leakage from benchmark overlap. This ensures that the reported results reflect cross-design skill reuse rather than design-specific memorization. Implementation of Dr. RTL. Dr. RTL is currently implemented on the Claude Code command-line interface (CLI), while the framework is agent-CLI agnostic and can be readily adapted to other agentic coding environments through the same markdown-based workflow specification. Unless otherwise noted, we use Claude Opus for the main experiments, and evaluate other Claude models such as Sonnet and Haiku in the scaling study to cover different capability–cost trade-offs [3]. We also include OpenAI GPT-5.3 and Qwen Coder 8B as baselines.
(5)
where 𝜇𝑡 and 𝜎𝑡 denote the mean and standard deviation of the candidate scores (Eq. (3)) in iteration 𝑡. Intuitively, 𝐴𝑖 measures whether a candidate performs better or worse than its peers under matched conditions, highlighting strategies that consistently outperform alternatives in the same optimization context. Pattern–strategy abstraction. Guided by the relative advantage signal, we employ an auxiliary skill learning agent to analyze the trajectories and extract reusable pattern–strategy pairs as optimization skills. A pattern captures a recurring structural bottleneck on critical paths, such as deep FSM/decode logic, high-fanout control signals, wide comparisons, or mux-heavy selection logic. A strategy describes the corresponding transformation principle, such 5
Table 2: PPA improvements of Dr. RTL over commercial logic synthesis on real-world RTL designs. Design
Statistics
Commercial Synthesis
w/ Dr. RTL Optimization
LoC
NoM
#. Gate
#. Reg
WNS (𝑛𝑠)
TNS (𝑛𝑠)
Area (𝑢𝑚 2 )
WNS (𝑛𝑠)
TNS (𝑛𝑠)
Area (𝑢𝑚 2 )
SEC Pass
vending ticket lstm dsp communicate spi1 cpu_fsm aes fifo spi2 uart controller router cpu_pipe pcie datapth i2c tv80 arm_cpu1 arm_cpu2
128 134 135 165 225 332 354 374 390 441 447 528 571 850 923 1065 1036 4615 2070 1450
1 1 4 5 3 2 1 2 7 3 4 1 5 5 7 7 3 5 1 1
20272 56 8379 3345 1023 647 13232 24294 13740 856 851 213 3036 2845 1773 6985 723 4431 11772 6132
4 6 0 196 232 131 4163 1419 4208 292 135 8 609 364 97 881 128 359 1222 736
-0.27 -0.23 -6.51 -2.61 -0.4 -0.32 -0.82 -0.7 -0.54 -0.26 -0.38 -0.38 -0.53 -0.38 -0.79 -0.88 -0.36 -1.31 -5.24 -1.01
-1.02 -1.24 -166.76 -154.64 -73.08 -33.42 -429.73 -913.49 -2002.1 -28.19 -23.17 -2.85 -289.91 -23.24 -23.83 -513.42 -26.67 -381.2 -3148.68 -662.7
20488 78 14828 4755 2092 1208 32268 33755 36061 1748 1272 235 5479 2622 2156 12137 1290 6044 22172 10688
-0.09 (-66.7%) -0.09 (-60.9%) -4.86 (-25.3%) -2.59 (-0.8%) -0.26 (-35.0%) -0.29 (-9.4%) -0.61 (-25.6%) -0.67 (-4.3%) -0.43 (-20.4%) -0.25 (-3.8%) -0.34 (-10.5%) -0.33 (-13.2%) -0.46 (-13.2%) -0.11 (-71.1%) -0.44 (-44.3%) -0.87 (-1.1%) -0.35 (-2.8%) -1.22 (-6.9%) -5.19 (-1.0%) -0.92 (-8.9%)
-0.5 (-51.0%) -0.47 (-62.1%) -116.16 (-30.3%) -147.42 (-4.7%) -58.84 (-19.5%) -33.53 (0.3%) -427.28 (-0.6%) -876.71 (-4.0%) -1681.97 (-16.0%) -27.75 (-1.6%) -23.08 (-0.4%) -2.57 (-9.8%) -246.66 (-14.9%) -2.69 (-88.4%) -19.75 (-17.1%) -504 (-1.8%) -25.96 (-2.7%) -362.09 (-5.0%) -3117.41 (-1.0%) -619.13 (-6.6%)
20533 (0.2%) 45 (-41.8%) 4753 (-67.9%) 4751 (-0.1%) 2446 (17.0%) 1276 (5.7%) 32157 (-0.3%) 33975 (0.7%) 36310 (0.7%) 1826 (4.5%) 1107 (-13.0%) 277 (18.0%) 5575 (1.8%) 2313 (-11.8%) 1426 (-33.9%) 12137 (0.0%) 1275 (-1.1%) 6200 (2.6%) 22257 (0.4%) 10995 (2.9%)
77% 65% 83% 83% 95% 63% 96% 81% 96% 100% 87% 94% 92% 90% 100% 92% 98% 92% 56% 87%
Avg.
812
3
6230
760
-21.3%
-16.9%
-5.8%
86%
/
Table 3: Comparison with existing single-shot LLMs and LLM-based RTL optimization methods. Method
WNS
TNS
Area
Single-Shot LLM
Claude Opus GPT 5.3
-2.4% -1.2%
-2.8% 0.3%
-0.7% 0.6%
SOTA Baselines★
RTLRewriter [39] SymRTLo [37]
-4.9% -7.1%
-6.3% -5.7%
-3.1% -1.4%
Ours
Dr. RTL
-21.3%
-16.9%
-5.8%
Table 4: Existing benchmarks fail to capture real RTL optimization. Dr. RTL not only repairs manually degraded RTL, but also consistently improves the original human-written RTL beyond the benchmark’s assumed upper bound. Manual-Degraded Suboptimal RTL Design
★ We use the same backbone LLM, Claude Opus, for both the state-of-the-art LLM-
TNS
Area
WNS
TNS
Area
WNS
TNS
Area
FFT
-3.2 (+2%)
-4446 (+0.4%)
160688 (-6%)
-3.14
-4431
170620
-1.73 (-45%)
-1746 (-61%)
110546 (-35%)
Huffman
-2.23 (0%)
-2705 (+0.4%)
73807 (-8%)
-2.23
-2695
80009
-2.21 (-1%)
-2562 (-5%)
71223 (-11%)
VMachine
-0.27 (+145%)
-1.02 (+15%)
20967 (+2%)
-0.11
-0.89
20488
-0.08 (-27%)
-0.38 (-57%)
21989 (+7%)
CNN CPU
Optimization Results
Per-design results. Table 2 summarizes Dr. RTL’s optimization results across all 20 designs. Notably, Dr. RTL improves timing on all 20 designs, achieving average WNS and TNS improvements of 21.3% and 16.9%, respectively, while even reducing area by 5.8%. This suggests that the gains mainly come from structurally efficient RTL transformations rather than area-expensive trade-offs. In particular, 9/20 designs achieve Pareto improvements, 8/20 incur only minor area overhead (< 5%), and only 3/20 show noticeable area increase. Dr. RTL also maintains high reliability throughout optimization, achieving an average SEC pass rate of 86%. Overall, these results show that Dr. RTL delivers consistent timing improvement on realistic human-written RTL through iterative, feedback-driven optimization beyond advanced synthesis. Comparison with baseline methods. As shown in Table 3, we compare Dr. RTL with single-shot LLMs and representative prior iterative methods [37, 39] on our real-world dataset. Single-shot models are evaluated in one pass, while iterative baselines use the same iteration budget and base model (i.e., Claude Opus) as Dr. RTL. In contrast, prior iterative methods rely mainly on design-level feedback and pre-defined rules, and do not accumulate reusable knowledge from interaction with the synthesis environment.
Better Optimized RTL by Dr. RTL
WNS
based RTL optimization baselines and our Dr. RTL to ensure a fair comparison.
5.2
Human-Written RTL (Baseline)
Cannot be synthesized using DC
Dr. RTL consistently outperforms all baselines, achieving the best overall results in WNS, TNS, and area. Among the singleshot baselines, Claude Opus performs better than GPT-5.3, so we adopt it as the backbone model of Dr. RTL. Notably, the iterative baselines [37, 39] also use the same backbone LLM, indicating that the gains mainly come from our agentic optimization framework rather than the underlying model alone.
5.3
Existing Benchmarks Miss Real Optimization
We further evaluate Dr. RTL on a representative RTL optimization benchmark [39], which contains large designs with manually degraded RTL. We include all large designs provided by the benchmark, and note that two of them are not even synthesizable under commercial tools due to syntax issues, further exposing the gap between open-source and industrial EDA evaluation. We also apply Dr. RTL to this benchmark, as shown in Table 4. Dr. RTL even further improves the original human-written RTL, which existing benchmarks treat as the optimization upper bound. In contrast, prior methods start from manually degraded designs 6
25% 20%
90%
21% 17%
15% 10%
10% 7%
9% 9%
6% 3%
5%
14% 11% 7% 2%
SEC Pass Rate
PPA Improvement
Figure 5: Optimization trajectories of Dr. RTL across iterations of two design examples (router and pcie). WNS, TNS, area, and score improve steadily while preserving functional equivalence. Parallel exploration selects better candidates at each step, and the skill-enhanced variant achieves faster convergence and better PPA than the baseline without skills. indicating that reusable optimization knowledge not only improves search quality but also steers the agent away from ineffective or risky transformations.
86%
85% 80%
78%
5.6
75%
0% Dr. RTL
w/o reg. slack w/o feedback multi-agent WNS
TNS
w/o learned skill
Dr. RTL
Area
w/o learned skill
The runtime of Dr. RTL is dominated by EDA execution, since each candidate requires synthesis and sequential equivalence checking. Because the 𝑁 candidates in each iteration are evaluated in parallel, wall-clock runtime scales mainly with the number of iterations rather than the total number of candidates, i.e., runtime ≈ 𝐾 × 𝑇EDA , where 𝐾 = 10 in our setup and 𝑇EDA is the runtime of one parallel EDA evaluation round. In practice, synthesis dominates 𝑇EDA , ranging from minutes to hours depending on design size. Compared with traditional manual RTL optimization, this parallel evaluation enables a substantially more efficient workflow that can run continuously (24×7). In our setup, optimizing all 20 designs required roughly one week of wall-clock time and about $50 in LLM usage. Overall, Dr. RTL provides a favorable cost–performance trade-off while substantially reducing manual effort.
Figure 6: Ablation studies of Dr. RTL on register-level slack feedback, multi-agent design, and learned skill library. and aim only to recover the original RTL. This shows that the original human-written RTL is not a true upper bound and can still be further optimized under realistic industrial evaluation. More broadly, these results suggest that realistic RTL optimization should be evaluated by whether a method can improve strong humanwritten RTL beyond synthesis, rather than merely recover it from artificial degradation.
5.4
Optimization Trajectory Visualization
6 DISCUSSION 6.1 Skill Discovery and Interpretability
We visualize the optimization trajectories of Dr. RTL in Figure 5. At each iteration, multiple RTL candidates are explored in parallel, and the best SEC-passing design is promoted to the next round. Dr. RTL shows steady improvement in WNS and TNS across iterations, indicating effective convergence. Compared with the variant without the learned skill library, the skill-enhanced version converges faster and reaches better PPA, showing that learned optimization knowledge improves both quality and convergence efficiency.
5.5
Runtime and Cost Analysis
Figure 7 shows how Dr. RTL converts raw optimization trajectories into reusable RTL optimization knowledge. Hierarchical trajectories record iteration rounds, parallel exploration, and critical-path analyses with root-cause diagnoses, providing structured logs for skill extraction. In our current implementation, this process yields 47 entries in total: 12 high-confidence strategies, 16 medium-confidence strategies, 6 low-confidence strategies, and 13 avoid strategies. The discovered skills are organized by confidence level according to their empirical success rates under real EDA feedback. Highconfidence skills correspond to consistently effective transformations (e.g., logic simplification, fanout management), while mediumconfidence skills represent conditionally useful strategies (e.g., restructuring or resource sharing), and low-confidence skills correspond to more aggressive or design-dependent transformations. Dr. RTL also explicitly identifies avoiding strategies that are ineffective, absorbed by synthesis, or violate equivalence. Each skill is externalized as a pattern–strategy pair with an implementation template, enabling direct reuse. This confidence-aware
Ablation Studies
We conduct ablation studies on the key components of Dr. RTL, as shown in Figure 6. Removing register-level slack feedback causes the largest drop, reducing WNS/TNS improvement from 21%/17% to 9%/9%, highlighting the importance of fine-grained timing information for understanding real critical paths and their root causes. Replacing the multi-agent framework with a single-agent setup reduces performance to 10%/7%, confirming that role decomposition helps structure the optimization process and enables more effective exploration. Disabling the skill library lowers WNS/TNS improvement to 14%/11% and reduces the SEC pass rate from 86% to 78%, 7
Hierarchical Optimization Trajectory
[1.1 Condition Pre-Computation]
RTL Optimization Skill Library
Pattern: Repeated comparison / complex condition Strategy: Extract (signal == value) comparison to wire // AFTER Template
▪ High-Confidence Strategies (>60% pass)
Design: CPU core
1.1 Condition Pre-Computation 1.2 Carry-Select Adder Transformation 1.3 Register Duplication / Signal Replication ……
Layer 1: Iteration Round Round 1 → Round 2 → … → Round k
Layer 2: Parallel RTL Exploration v1.1 SEC: ✓, PPA: ↑
v2.1 SEC:
...
...
...
v1.i SEC: ✓, PPA: ↓
v2.i SEC: ✓, PPA: ↓
vk.i SEC: ✓, PPA: ↓
▪ Medium-Confidence Strategies (~50% pass)
vk.1 SEC: ✓, PPA: -
, PPA: -
// BEFORE always @(*) begin if (a==b && c==d) … if (a==b && c==e) … end
2.1 Mux-Select with Unconditional Compute 2.2 Mux-Before-Adder Restructuring 2.3 Common Subexpression Elimination ……
[1.3 Combinational Signal Replication] Pattern: High-fanout combinational signals Strategy: Create multiple copies for cones Template
▪ Low-Confidence / Risky Strategies 3.1 Aggressive Mux Tree Restructuring 3.2 Count-Down Counter Restructuring
Layer 3: Critical paths
// BEFORE: // 4 fanout cones
Skill 3.3 …… Learning ▪ Invalid Strategies (DO NOT USE) Agent ▪ Already done by synthesis tool
[Path 1] • Start → End: discountC[0] → total_discount[1] • Structure: Carry-select adder path with speculative sum (c0/c1) + chained carry muxes • Root cause: 13-stage sequential carry-mux chain → linear delay (O(K)); prefix-tree attempt added overhead without reducing critical depth • Amenability: Combinational • Optimization: Replace linear carry propagation with parallel-prefix computation (Generate/Propagate), reducing depth from O(13) → O(4)
wire a = (b==c);
4.1 XOR Tree Balance / XOR Chain Flatten 4.2 Bit-Level Comparison Replace …… ▪ Will degrade timing 4.3 Pre-Registering Wide Concatenation …… ▪ Will break equivalence 4.4 Counter Direction Change ……
[Path 2] …
wire a_is_b = (a==b); wire c_is_d = (c==d); wire c_is_e = (c==e); always @(*) begin if (a_is_b && c_is_d) … if (a_is_b && c_is_e) … end
// AFTER: Replicated wire a_1 = (b==c); // Cone1 wire a_2 = (b==c); // Cone2 wire a_3 = (b==c); // Cone3 wire a_4 = (b==c); // Cone4
[2.3 Common Subexpression Elimination] Pattern: Repeated arithmetic or logic expressions Strategy: Extract to named wire, reuse across paths Template // AFTER wire xy_sum = x + y; always @(*) begin a = xy_sum + z; b = xy_sum + w; end
// BEFORE always @(*) begin a = x + y + z; b = x + y + w; end
100% 57% 60%
86%
73%
22%
20% 30%
Avg. PPA Improve
PPA Improvement
Avg. SEC Pass Rate
Figure 7: Distilling hierarchical trajectory into skill library. Optimization trajectories are organized across iterations, parallel explorations, and critical paths, enabling discovery of reusable RTL optimization strategies with different confidence levels and associated transformation templates.
21%
20%
12%
10%
1%
3%
0%
0% Qwen Coder 8B
2% Claude Haiku
Claude Sonnet
TNS
Area
WNS
17%
9% 5%
15%
17%
14% 13%
6% -2%
-5%
Post-Syn (DC)
1%
2%
4%
Post-Syn (Yosys)
Post-PR (Innovus)
-1%
Post-Syn (DC- Flow Tuning) WNS
TNS
Area
Figure 9: Impact of different EDA tools on Dr. RTL results.
Claude Opus
from gains that might depend on a particular backend tool or flow setting. Dr. RTL consistently improves timing across all settings, from open-source synthesis to commercial synthesis and post-route evaluation. The gains are largest with Yosys, where the weaker synthesis leaves more room for RTL improvement, while they are smaller but still clear with commercial DC and after place-androute in Innovus, where timing has already been more aggressively optimized. In contrast, simple DC flow tuning yields only marginal benefit, suggesting that parameter tuning is limited, while substantial further gains still come from improving the RTL itself. Overall, these results show that Dr. RTL effectively generalizes across both tools and design stages.
organization allows Dr. RTL to prioritize reliable transformations while adaptively exploring more complex strategies when beneficial. Overall, Dr. RTL converts raw trajectory experience into structured, interpretable, and reusable knowledge, enabling systematic and adaptive agentic RTL optimization.
Dr. RTL Scales with LLM Capability
We study how Dr. RTL scales with different LLM backbones, as shown in Figure 8. Stronger models consistently improve both optimization quality and reliability. Average WNS/TNS improvement increases from 1%/0% with Qwen Coder 8B, to 3%/2% with Claude Haiku, to 12%/9% with Claude Sonnet, and to 21%/17% with Claude Opus. Meanwhile, the average SEC pass rate rises from 22% to 57%, 73%, and 86%. These results suggest that Dr. RTL scales effectively with backbone capability. As smaller models continue to improve, fine-tuned or domain-specialized LLMs are a promising direction for better privacy, customization, and deployment flexibility.
6.3
29% 28% 21%
6%
Figure 8: Dr. RTL scales with LLM capability.
6.2
35%
7
CONCLUSION
We present Dr. RTL, an agentic framework for RTL timing optimization that formulates the task as an iterative, closed-loop process through interaction with industrial EDA tools, achieving consistent timing improvement with minimal area overhead on real-world designs. Beyond performance, our work advocates a shift toward agentic design automation driven by autonomous reasoning, accumulated chip design knowledge, and EDA environment interaction. By coupling realistic evaluation with reusable skill learning, Dr. RTL takes a step toward practical agentic design automation, and paves the way for future systems built on smaller specialized models, richer exploration strategies, and human-in-the-loop refinement.
Impact of EDA Tools
As shown in Figure 9, we evaluate Dr. RTL across multiple EDA tools and design stages, to distinguish true RTL-level optimization 8
REFERENCES
[25] Jingyu Pan, Guanglei Zhou, Chen-Chia Chang, Isaac Jacobson, Jiang Hu, and Yiran Chen. 2025. A Survey of Research in Large Language Models for Electronic Design Automation. ACM Transactions on Design Automation of Electronic Systems (TODAES) (2025). [26] Zehua Pei, Hui-Ling Zhen, Mingxuan Yuan, Yu Huang, and Bei Yu. 2024. BetterV: Controlled Verilog Generation with Discriminative Guidance. arXiv preprint arXiv:2402.03375 (2024). [27] Nathaniel Pinckney, Chenhui Deng, Chia-Tung Ho, Yun-Da Tsai, Mingjie Liu, Wenfei Zhou, Brucek Khailany, and Haoxing Ren. 2025. Comprehensive Verilog design problems: A next-generation benchmark dataset for evaluating large language models and agents on rtl design and verification. arXiv preprint arXiv:2506.14074 (2025). [28] Heng Ping, Peiyu Zhang, Zhenkun Wang, Shixuan Li, Anzhe Cheng, Wei Yang, Paul Bogdan, and Shahin Nazarian. 2026. POET: Power-Oriented Evolutionary Tuning for LLM-Based RTL PPA Optimization. arXiv preprint arXiv:2603.19333 (2026). [29] Arun Ravindran, Aditya Patra, Vahid Babaey, and Suresh Purini. 2025. Survey and Benchmarking of Large Language Models for RTL Code Generation: Techniques and Open Challenges. (2025). [30] Humza Sami, Pierre-Emmanuel Gaillardon, Valerio Tenace, et al. 2024. Aivril: Ai-driven rtl generation with verification in-the-loop. arXiv preprint arXiv:2409.11411 (2024). [31] Si2. 2018. NanGate 45nm Open Cell Library. [32] Cadence Design Systems. 2026. Cadence JasperGold Sequential Equivalence Checking App. https://www.cadence.com/en_US/home/tools/systemdesign-and-verification/formal-and-static-verification/jasper-verificationplatform/jaspergold-sequential-equivalence-checking-app.html. [33] Kimia Tasnia, Alexander Garcia, Tasnuva Farheen, and Sazadur Rahman. 2025. Veriopt: Ppa-aware high-quality verilog generation via multi-role llms. In 2025 IEEE/ACM International Conference On Computer Aided Design (ICCAD). IEEE, 1–9. [34] Kiran Thorat, Jiahui Zhao, Yaotian Liu, Amit Hasan, Hongwu Peng, Xi Xie, Bin Lei, and Caiwen Ding. 2025. LLM-VeriPPA: Power, Performance, and Area Optimization aware Verilog Code Generation with Large Language Models. In 2025 ACM/IEEE 7th Symposium on Machine Learning for CAD (MLCAD). IEEE, 1–7. [35] Kiran Thorat, Jiahui Zhao, Yaotian Liu, Hongwu Peng, Xi Xie, Bin Lei, Jeff Zhang, and Caiwen Ding. 2023. Advanced Large Language Model (LLM)-Driven Verilog Development: Enhancing Power, Performance, and Area Optimization in Code Synthesis. arXiv preprint arXiv:2312.01022 (2023). [36] Frank Vahid. 2010. Digital design with RTL design, VHDL, and Verilog. John Wiley & Sons. [37] Yiting Wang, Wanghao Ye, Ping Guo, Yexiao He, Ziyao Wang, Bowei Tian, Shwai He, Guoheng Sun, Zheyu Shen, Sihan Chen, et al. 2025. Symrtlo: Enhancing rtl code optimization with llms and neuron-inspired symbolic reasoning. In Advances in Neural Information Processing Systems (NeurIPS). [38] Zhihao Xu, Bixin Li, and Lulu Wang. 2025. Rethinking LLM-Based RTL Code Optimization Via Timing Logic Metamorphosis. arXiv preprint arXiv:2507.16808 (2025). [39] Xufeng Yao, Yiwen Wang, Xing Li, Yingzhao Lian, Ran Chen, Lei Chen, Mingxuan Yuan, Hong Xu, and Bei Yu. 2024. Rtlrewriter: Methodologies for large models aided rtl code optimization. In Proceedings of IEEE/ACM International Conference on Computer-Aided Design (ICCAD). [40] Jiaqi Yin, Zhan Song, Chen Chen, Qihao Hu, and Cunxi Yu. 2025. Boole: Exact symbolic reasoning via boolean equality saturation. In 2025 62nd ACM/IEEE Design Automation Conference (DAC). IEEE, 1–7. [41] Zhongzhi Yu, Mingjie Liu, Michael Zimmer, Yingyan Celine, Yong Liu, and Haoxing Ren. 2025. Spec2rtl-agent: Automated hardware code generation from complex specifications using llm agent systems. In 2025 IEEE International Conference on LLM-Aided Design (ICLAD). IEEE, 37–43. [42] Zelin Zang, Yuhang Song, Aili Wang, Bingo Wing-Kuen Ling, Qi Sun, Zhen Lei, Fuji Yang, Cheng Zhuo, and Jiebo Luo. 2025. The Dawn of Agentic EDA: A Survey of Autonomous Digital Chip Design. arXiv preprint arXiv:2512.23189 (2025). [43] Xinyu Zhang, Zhiteng Chao, Yonghao Wang, Bin Sun, Tianyun Ma, Tianmeng Yang, Jianan Mu, Jing Justin Ye, and Huawei Li. 2026. RTLSeek: Boosting the LLM-Based RTL Generation with Multi-Stage Diversity-Oriented Reinforcement Learning. arXiv preprint arXiv:2603.27630 (2026). [44] Yang Zhao, Di Huang, Chongxiao Li, Pengwei Jin, Ziyuan Nan, Tianyun Ma, Lei Qi, Yansong Pan, Zhenxing Zhang, Rui Zhang, et al. 2024. CodeV: Empowering LLMs for Verilog Generation through Multi-Level Summarization. arXiv preprint arXiv:2407.10424 (2024). [45] Yujie Zhao, Hejia Zhang, Hanxian Huang, Zhongming Yu, and Jishen Zhao. 2025. Mage: A multi-agent engine for automated rtl code generation. In 2025 62nd ACM/IEEE Design Automation Conference (DAC). IEEE, 1–7. [46] Matthew M Ziegler, Hung-Yi Liu, George Gristede, Bruce Owens, Ricardo Nigaglioni, and Luca P Carloni. 2016. A synthesis-parameter tuning system for autonomous design-space exploration. In 2016 Design, Automation & Test in Europe Conference & Exhibition (DATE). IEEE, 1148–1151.
[1] Mohammad Akyash, Kimia Azar, and Hadi Kamali. 2025. Rtl++: Graph-enhanced llm for rtl code generation. In 2025 IEEE International Conference on LLM-Aided Design (ICLAD). IEEE, 44–50. [2] Ahmed Allam and Mohamed Shalan. 2024. RTL-Repo: A Benchmark for Evaluating LLMs on Large-Scale RTL Design Projects. arXiv preprint arXiv:2405.17378 (2024). [3] Anthropic. 2026. Claude Code: Model Configuration. https://code.claude.com/ docs/en/model-config. [4] Alan Brayton, Robert Mishchenko, and A Mishchenko. 2006. Scalable logic synthesis using a simple circuit structure. In International Workshop on Logic and Synthesis (IWLS). [5] Che-Ming Chang, Prashanth Vijayaraghavan, Ashutosh Jadhav, Charles Mackin, Hsinyu Tsai, Vandana Mukherjee, and Ehsan Degan. 2026. CODMAS: A Dialectic Multi-Agent Collaborative Framework for Structured RTL Optimization. In Proceedings of the 19th Conference of the European Chapter of the Association for Computational Linguistics (Volume 5: Industry Track). 777–788. [6] Chen Chen, Guangyu Hu, Dongsheng Zuo, Cunxi Yu, Yuzhe Ma, and Hongce Zhang. 2024. E-syn: E-graph rewriting with technology-aware cost functions for logic synthesis. In Design Automation Conference (DAC). [7] Lei Chen et al. 2024. The Dawn of AI-Native EDA: Promises and Challenges of Large Circuit Models. Springer Science China Information Sciences (SCIS) (2024). [8] Luanrong Chen, Renzhi Chen, Xinyu Li, Shanshan Li, Rui Gong, and Lei Wang. 2026. IncreRTL: Traceability-Guided Incremental RTL Generation under Requirement Evolution. arXiv preprint arXiv:2603.25769 (2026). [9] Animesh Basak Chowdhury, Marco Romanelli, Benjamin Tan, Ramesh Karri, and Siddharth Garg. 2024. Retrieval-guided reinforcement learning for boolean circuit minimization. In International Conference on Learning Representations (ICLR). [10] Matthew DeLorenzo, Animesh Basak Chowdhury, Vasudev Gohil, Shailja Thakur, Ramesh Karri, Siddharth Garg, and Jeyavijayan Rajendran. 2024. Make every move count: Llm-based high-quality rtl code generation using mcts. arXiv preprint arXiv:2402.03289 (2024). [11] Chenhui Deng, Yun-Da Tsai, Guan-Ting Liu, Zhongzhi Yu, and Haoxing Ren. 2025. Scalertl: Scaling llms with reasoning data and test-time compute for accurate rtl code generation. In 2025 ACM/IEEE 7th Symposium on Machine Learning for CAD (MLCAD). IEEE, 1–9. [12] Chenhui Deng, Zhongzhi Yu, Guan-Ting Liu, Nathaniel Pinckney, and Haoxing Ren. 2026. ACE-RTL: When Agentic Context Evolution Meets RTL-Specialized LLMs. arXiv preprint arXiv:2602.10218 (2026). [13] Wenji Fang, Jing Wang, Yao Lu, Shang Liu, Yuchao Wu, Yuzhe Ma, and Zhiyao Xie. 2025. A survey of circuit foundation model: Foundation ai models for vlsi circuit design and eda. arXiv preprint arXiv:2504.03711 (2025). [14] Mingzhe Gao, Jieru Zhao, Zhe Lin, Wenchao Ding, Xiaofeng Hou, Yu Feng, Chao Li, and Minyi Guo. 2024. AutoVCoder: A Systematic Framework for Automated Verilog Code Generation using LLMs. In International Conference on Computer Design (ICCD). [15] Soha Hassoun and Tsutomu Sasao. 2012. Logic synthesis and verification. Vol. 654. Springer Science & Business Media. [16] Zhuolun He, Yuan Pu, Haoyuan Wu, Tairu Qiu, and Bei Yu. 2025. Large language models for eda: Future or mirage? ACM Transactions on Design Automation of Electronic Systems 30, 6 (2025), 1–53. [17] Wei-Po Hsin, Ren-Hao Deng, Yao-Ting Hsieh, En-Ming Huang, and Shih-Hao Hung. 2026. EvolVE: Evolutionary Search for LLM-based Verilog Generation and Optimization. arXiv preprint arXiv:2601.18067 (2026). [18] Miao Liu, Liwei Ni, Junfeng Liu, Xingyu Meng, Rui Wang, Xiaoze Lin, Xinhua Lai, Xingquan Li, and Jungang Xu. 2026. A Survey of Machine Learning Approaches in Logic Synthesis. ACM Transactions on Design Automation of Electronic Systems 31, 2 (2026), 1–43. [19] Mingjie Liu, Nathaniel Pinckney, Brucek Khailany, and Haoxing Ren. 2023. VerilogEval: Evaluating Large Language Models for Verilog Code Generation. arXiv preprint arXiv:2309.07544 (2023). [20] Shang Liu, Wenji Fang, Yao Lu, Qijun Zhang, Hongce Zhang, and Zhiyao Xie. 2024. RTLCoder: Fully Open-Source and Efficient LLM-Assisted RTL Code Generation Technique. IEEE Transactions on Computer-Aided Design of Integrated Circuits and Systems (TCAD) (2024). [21] Shang Liu, Yao Lu, Wenji Fang, Mengming Li, and Zhiyao Xie. 2024. OpenLLMRTL: Open Dataset and Benchmark for LLM-Aided Design RTL Generation. In International Conference on Computer-Aided Design (ICCAD). [22] Yao Lu, Shang Liu, Qijun Zhang, and Zhiyao Xie. 2024. RTLLM: An Open-Source Benchmark for Design RTL Generation with Large Language Model. In Asia and South Pacific Design Automation Conference (ASP-DAC). [23] Yao Lu, Shang Liu, Hangan Zhou, Wenji Fang, Qijun Zhang, and Zhiyao Xie. 2026. A New Benchmark for the Appropriate Evaluation of RTL Code Optimization. arXiv preprint arXiv:2601.01765 (2026). [24] Kyungjun Min, Kyumin Cho, Junhwan Jang, and Seokhyeong Kang. 2025. Revolution: An evolutionary framework for rtl generation driven by large language models. arXiv preprint arXiv:2510.21407 (2025). 9