LLM for EDA in Front-End Design: Challenges and Opportunities Kangwei Xu1 , Bing Li2 , Ulf Schlichtmann1
1 Chair of Electronic Design Automation, Technical University of Munich (TUM), Munich, Germany 2 Resource-Efficient AI Group, Technical University of Ilmenau, Ilmenau, Germany
Email: {kangwei.xu, ulf.schlichtmann}@tum.de, [email protected]
arXiv:2607.09616v1 [cs.ET] 10 Jul 2026
Abstract As chip complexity increases and time-to-market pressures grow, front-end design has become a critical bottleneck in chip development. Recently, Large Language Models (LLMs) have shown great potential in Electronic Design Automation (EDA). Beyond specification understanding, LLMs show the potential to serve as a unified intelligent interface for hardware description language (HDL) generation, testbench construction, and design space exploration. The rise of agentic AI, represented by pioneering systems such as OpenClaw, offers a strategic roadmap for the next generation EDA. From this perspective, this paper discusses the evolution of EDA from localized assistance to autonomous agentic execution. Then, we review representative advances of LLMs in front-end design, focusing on key tasks such as circuit and testbench generation from a shared specification, as well as design quality improvement in established workflows such as high-level synthesis. Finally, we discuss the key challenges and limitations of integrating LLMs into EDA, and outline future opportunities for advancing LLM-enabled front-end design, offering a systematic perspective for researchers interested in leveraging agentic AI technologies for EDA. ACM Reference Format: Kangwei Xu, Bing Li, and Ulf Schlichtmann. 2026. LLM for EDA in Front-End Design: Challenges and Opportunities. In 63rd ACM/IEEE Design Automation Conference (DAC ’26), July 26 – July 29, 2026, Long Beach, CA, USA. ACM, New York, NY, USA, 5 pages. https://doi.org/10.1145/3770743.3812057
1
Introduction
The rapid evolution of Large Language Models (LLMs) is propelling Electronic Design Automation (EDA) into a new technological frontier. Across the full chip design flow, front-end design is especially well aligned with LLM capabilities, because it relies heavily on natural language understanding and high-level logical reasoning. By learning from large collections of hardware description language (HDL) designs, LLMs can capture useful semantics and practical knowledge. As a result, the next generation of EDA is gradually moving beyond the traditional script-driven paradigm toward a more intelligent and automated workflow. Recent studies have demonstrated promising results across a wide range of front-end design tasks. As illustrated in Fig. 1, these tasks range from assistance-oriented such as question answering, specification interpretation [1], and report explanation [2], to more generation-oriented tasks, including HDL generation [3], testbench construction [4, 11], and script development [5]. Initial progress has also been demonstrated in HDL debugging tasks [6, 7]. These results indicate that LLMs are already effective for localized frontend tasks that involve high-level reasoning and explicit feedback. Despite this progress, moving beyond early-stage assistance and generation remains difficult. The core challenge is not merely the
This work is licensed under a Creative Commons Attribution 4.0 International License. DAC ’26, Long Beach, CA, USA © 2026 Copyright held by the owner/author(s). ACM ISBN 979-8-4007-2254-7/2026/07 https://doi.org/10.1145/3770743.3812057
S1: Assisting
S2: Generating
S3: Verifying
S4: Coordinating S5: Autonomy
·Answer Questions ·Draft HDL Designs ·Check Coverage ·Manage Tools ·Interpret Specs
·Make Decisions
·Write Testbenches ·Trace Failures
·Share Feedback ·Reach Targets
·Explain Reports ... ·Generate Scripts ... ·Debug HDL ...
·Organize Flows... ·Drive Loops...
Figure 1: Evolution Path of LLM Capabilities in Chip Design. Architectural Design
Initial Design Specification
System Model (C/C++, MATLAB...)
High-Level Synthesis
Consistency Check
EDA Agent Testbench & Property
< / > HDL module adder ( input [3:0] a...); endmodule
HDL Design (VHDL/Verilog ...)
Netlist and Physical Design
Testing
Figure 2: LLM-Based Agentic Chip Design Flow. automation of individual tasks, but preserving semantic consistency across different design stages. In hardware design, an implementation may be syntactically correct and pass basic test vectors, while still containing errors in timing boundaries, concurrent interactions, or corner cases. More importantly, even minor semantic mismatches introduced in early stages can propagate through downstream design steps and become harder to detect and debug later. By the time they are exposed during downstream verification, they no longer appear in their original high-level form, but only as low-level failure symptoms, making it difficult to trace them back to where the semantic deviation was first introduced. The rise of agentic AI provides a new system-level perspective for addressing this problem. Representative systems such as OpenClaw [8] demonstrate that the value of an intelligent agent lies not only in generating text, but also in orchestrating tool usage, maintaining long-horizon task consistency, leveraging persistent memory, and continuously advancing complex workflows. These properties are particularly important in EDA, where design, verification, and optimization are tightly coupled and inherently iterative. From this perspective, the EDA system requires a robust closedloop mechanism that can support the full process from design generation to automated debugging. Such a system could work in a way closer to an experienced engineer: decomposing complex requirements into manageable subtasks, internalizing HDL design heuristics, and iteratively debugging and refining designs based on feedback from external EDA tools. With accumulated design knowledge and retrievable past experience, LLMs may evolve from local assistants into autonomous agents capable of driving the front-end design flow, while human engineers focus increasingly on high-level decisions and design objectives. Motivated by this trend, this paper provides a systematic perspective on LLM applications in front-end design, with a particular focus on whether these advances represent a genuine technological breakthrough or primarily reflect optimistic expectations associated with the rise of agentic AI technologies.
Kangwei Xu, Bing Li, Ulf Schlichtmann
50
10
Verilog code c
30
# Samples
40
c
LLM gen TB
QwQ-32b Correctbench
50
50
c
c
10
(c) Post-rank 𝑐 , Cluster 1
Sim.
Baseline Avg VFocus Avg
VRank Avg1 Cluster
guided Fil. 55
code?
20
Functional Correctness (Pass@1 %)
40
Verilog 65 code 𝑐2 ……
30 … …20 # Samples
Cluster 2 40 … … 50
(b) Ranking
Refined 𝑐 ′ Extra info
Fig. 2:Design Overall framework of VFocus. Figure 3: Overview of Automated HDL with DensityGuided Filtering and and Simulation-Based 20].pre-ranking filtering, V A. Pre-Ranking Sampling Filtering: Focused Ranking Candidate [19,After Preparation
Functional Correctness (Pass@1%)
Functional Correctness (Pass@1%)
against the generated testben Baseline 100 85 VRank Given a natural language module specification, we first output traces. Following the p VFocus DeepSeek-R1 80 80 a reasoning candidates are clustered based sample multiple Verilog code candidates using across all test scenarios. LLM.60Prompt engineering is applied at this stage. We provide 75 Baseline Avg We define the ranking score the LLM with general guidelines [17] as well as highlight 40 Framework Correctness (Pass@1%)
30
# Samples
Chip design is a staged refinement process that progressively transforms natural-language specifications into precise hardware implementations, while maintaining semantic consistency and enabling verification convergence throughout the flow. As illustrated in Fig. 2, the process begins with the design specification, which is typically captured in text documents, presentation slides, or design notes. These artifacts describe functional objectives, performance targets, and design assumptions. At this stage, LLMs are primarily used to interpret design intent, and clarify descriptions into more structured inputs [1]. The next stage is architectural design, where high-level requirements are refined into module partitioning, datapath structure, and control strategy. Here, LLMs can assist with module decomposition, design planning, and clearer expression of design intent. Following the architecture definition, an initial system model is typically developed using high-level languages like C/C++ or MATLAB, which are used to describe algorithm behavior. A system model is much closer to executable semantics, and its simulation results can therefore serve as a more concrete reference for subsequent hardware implementation. In this stage, LLMs can support the generation of high-level behavioral prototypes [14] and support later consistency checking between different representations. HDL design lies at the center of the front-end flow. As shown in Fig. 2, there are two primary paths toward an HDL implementation. One path translates the design specification directly into Verilog or VHDL. Although this approach provides fine-grained control over circuit optimization, it requires substantial engineering effort. Moreover, direct LLM-based HDL generation along this path still suffers from limited functional correctness. The other path relies on high-level synthesis (HLS) [15] to convert system-level models, such as C/C++ and MATLAB, into HDL designs However, the quality of the generated circuits remains constrained by both the capabilities of the HLS toolchain and the quality of the input HLS code [16]. Verification is another key stage in front-end design, as it ensures design correctness. As shown in Fig. 2, testbenches and properties can be constructed from the specification. A testbench provides input stimuli and response checking, while properties capture timing relations and key behavioral constraints. At this stage, LLMs have shown strong promise in testbench generation [11], failure analysis [6], bug localization [7], and assertion completion [17]. After functional verification, the design proceeds to netlist generation and physical design. Recent studies have also shown that agentic AI can improve automation across backend workflows [18]. As indicated by the consistency-check path in Fig. 2, the system model also provides a key reference for testing by checking implemented behavior against the original functional intent. Taken together, these dependencies across specification, modeling, implementation, and verification reveal a central challenge in chip design: the need to preserve semantic consistency across heterogeneous design representations, rather than merely automating isolated tasks. From this perspective, the value of LLMs in EDA lies not only in generating stage-specific artifacts, but also in connecting stages through tool coordination, feedback interpretation,
Functional Correctness (Pass@1 %)
State of the Art of LLM Applications in EDA 10 20 65
Functional Correctness (Pass@1%)
2
Functional Correctness (Pass@1 %)
The rest of this paper is organized as follows. Section 2 reviews (a) Pre-ranking Module Specs. representative progress in LLM-based front-end design workflows. DeepSeek-R1 o3-mini-high 85 75 85 Section 3 presents case studies on HDL generation and testing, Sampling Veri. General Tips LLM Candidates 70 … 80 / / and further extends the discussion to High-Level Synthesis (HLS). 80 RetryAvg Discard Baseline Avg Baseline 65 Section 4 discusses future opportunities and key challenges for 75 VFocus Avg VFocus Avg 75 VRank Avg VRank Avg 60 Density Complete Verilog code 𝑐 LLMs in EDA. Section 5 concludes the paper. 1 70 70
Pass@1 (%) (%) Pass@1
DAC ’26, July 26–29, 2026, Long Beach, CA, USA
VFocus Avg
70 VRank Avg typical X 20 mistakes [6] it tends to make during Verilog generation. R(c) = n − To mitigate syntax errors, we introduce a retry mechanism. 65 0 R1 o3 QwQ R1 o3 QwQ R1 o3 QwQ c If a sampled candidate is syntactically incomplete 10 or invalid, 20 30 40 50 Human CMB(81) SEQ(75) we retry sampling up to a small limit (set to five attempts# Samples in ′ ℓstrict (c, c ) = m 85 75 this framework), with an increasing delay between retries. t QwQ-32b In 80 addition to o3-mini-high ensuring syntactic validity, 70 VFocus applies a Density-guided Filtering strategy to improve65sample quality where C denotes the candidat 75 Baseline Avg T represents the s Baseline Avg before ranking. Inspired by observations of 60 reasoning LLM candidates, VFocus Avg VFocus Avg indicator function. 70 we measure the VRank Avg behavior, token length of each candidate’s reaVRank Avg 55 The reward favors larger soning trace and retain only those falling within a “reasoning 65 50 of negligent that majority consistency corr sweet spot”—avoiding both40too-short (indicative 10 20 30 50 10 20 30 This 40 stage 50 follows the simula reasoning) and overly long (suggesting overthinking or devi# Samples # Samples established by VRank [9], b ation) candidates. Specifically, for each sampled candidate i, Figure 4: Comparison of Baseline, VRank, and VFocus for candidate set provided by our we retain it if its token length L satisfies: i Terms of Pass Rate [20]. HDL Design Generation in
C. Post-Ranking Refinement:
Lmin < L (1) Reasoning-Enhanced i < Lthe max emergence of agentic and iterative debugging. With AI, their Correcti role evolve localized assistance verifiable, While the majority clusteri whereshould Lmin and Lmax beyond are empirically determined lowertoward and upper bounds, Different models may adopt dif- still overlook subtle inconsiste traceable, andrespectively. closed-loop EDA agents.
address this, VFocus introduce intuition behind the stage is to ensures that downstream ranking operates on a set of higher- different implementations and LLM-based front-end design follows a tightly coupled design We employ two byofreasoning. quality, focused samples, ultimately leading to better finalloop generation, testing, and repair. This section therefore focuses on intra-cluster and tency, namely candidate selection. Intra-cluster key tasks such as the automatic generation of circuit designs and inconsistency B. Ranking Stage: Simulation-Based Self-Consistency Selec- pensate for the under-represent their corresponding testbenches from a shared specification, and tion to our imperfect testbenches t further illustrates how LLMs can improve design quality in highFor each candidate, we automatically generate a lightweight correct codes and incorrect level synthesis. Based on these examples, we evaluate both Therefore, the in this ste testbench consisting of multiple test cases to enable behavioral cluster. practical progress achieved so far and analyze how far current each top cluster, combined wi simulation. Each test case corresponds to either an input combination for advance a combinational circuit orfront-end a checkpoint in let LLMs try to find inconsis developments LLM-assisted EDA. a sequential circuit. Notably, the testbench does not check for this cluster. outputs LLM-based explicitly; instead,HDL it prints all relevant outputs for Inter-cluster inconsistency 3.1 Design Generation each test case. Testbenches are generated using the Correct- from top clusters to identify Applying to HDL remains challenging because Bench [18] LLMs framework, and generation further enhanced by reasoning outputs disagree. These diverg hardware design requires strict functional LLMs LLMs to ensure that, for sequential circuits, allcorrectness, information while behavioral uncertainty. For task related to prone the current checkpoint is printed for verification. waveform description or kmap are still to hallucinations. To out improve the quality of LLMferent (Lmin , Lmax ) values. We will discuss the choice of these
in the experiment section. This filtering 3thresholds LLMfurther for EDA in Front-End Design
generated HDL design, VRank [19] proposes a consistency-based framework for Verilog generation. The framework first uses LLMs to generate multiple HDL design candidates, then clusters and ranks Authorized licensed use limited to: Technische Universitaet Muenchen. Downloaded on March 20,2026 at 16:43:20 UTC them based on their simulation outputs under a shared testbench. Candidates with similar outputs are treated as functionally consistent, and larger clusters are considered more reliable. This allows VRank to more effectively select functionally correct designs. On the VerilogEval benchmark, VRank improves the functional correctness of the generated HDL designs by 10.5%, demonstrating its effectiveness in improving the accuracy of HDL generation. Building on this idea, VFocus [20] further shows that ranking candidate code only by simulation results is still not enough. In some cases, the problem is not simply that the model selects the wrong code candidate, but that it fails to reason clearly about key points
n
Bing Li
University of Siegen [email protected] LLM for EDA in Front-End Design: Challenges and Opportunities AutoBench
estbenches h different ) on them. The hrong”. Generaaborated in s similar to e validators nd Bing Li. ion Using s-unknown um Ma- If achontask. Lake City, “wrong”) 1145/3670 ognized as erformance personal or estbenches, distributed full citation ummarized, be honored. th the valvalidation decreased. h as wrong ming more nsequently, estbenches
the highest iterion emcomparable ccuracy for ng. A lower s a higher could result rt for these ation of the
onducted a framework Fig. 6 (b). e the points 56 Verilog validation hich aligns ’s intent to token cost
Reboot Self-Enhancement
Generation of Hybrid TB
.PY
+
1. Auto-Debug 2. Scenarios List Checking 3. Code Standardization
.V
</>
Modified Hybrid TB
Original C/C++ Program
TB
Benchmark dataset
1. Golden RTL Solution 2. Golden TestBench 3. Mutants of Golden RTL
Eval1
PPA Analysis
Eval2
Figure 5: 1: Overview Outline ofofAutoBench workflow Generation and AutoEval evalFigure Automated Testbench [11–13]. uation framework.
1
GPT-4o
Introduction
Claude-3.5-Sonnet
Power, Performance, Area
GPT-4o-mini
Simulation-based verification is one of the most common techAutoBench niques for hardware functional verification [23]. This verification Baseline is carried out using testbenches to validate the functionality of a 0 20 40 to 60recent 80 100studies 0 20 40 100 0 20 40 60 Group 80 100 DUT. According by 60the80Wilson Research Passof Ratio (%) Pass Ratio (%) in an IC/ASIC Pass Ratio (%) [7], around 49% a design engineer’s time project is Eval1 Eval0 Failed spent on conductingEval2 verification tasks. Thus, automating the genFig.Results 7. Performance on Different LLMs. Figure of Testbench Generation in Pass Rate [12]. eration 6: of testbenches is a of keyCorrectBench point of automating the whole EDA design process of digital circuits. Previous efforts, such as [12, 13], from the beginning. address this as shown in Fig. VFothree criteria were To compared in issue, this work. Thus, the3,70%havefirst sought to automate the of code-writing process. Butreasoning they still cus analyzes the number tokens used during the wrong criterion utilized in our work may not be the optimal need thefor test stimulus and reference signals designed byobservation engineers. process each generated design candidate. The choice. Nonetheless, the HDL limited experimental results already Random test case generation approaches, such as constrained ransuggests the that performance short reasoning oftenofindicates insufficient analysis, indicate trends the validators, with 70%dom generation (CRG) [10], have also been proposed to reduce the while overly long reasoning driftthe away from the design intent. wrong performing the best may among three criteria examined. humanon effort test stimulus but reasoning the reference signals Based this on insight, VFocus generation, normalizes the lengths of for Performance checking are on still needed from Thus, D. Other LLMs different candidates for the same taskhumans. and keeps onlythese thosestudies within not fully automated testbench generation, including both and the acould suitable range. It then simulation-based To demonstrate thatperforms our workflow serves clustering as a general selection of test vectors and the checking of DUT’s signals. ranking on this refined candidate As reported in Fig. with methodology applicable to all theset. LLMs, we repeat the 4,experto the limitations of conventional algorithms, previous rethisDue pre-ranking refinement, VFocus achieves a 30.9% improvement iments outlined in Section IV-B using two additional widelysearch has been unable to achieveand complete automation of testbench over the DeepSeek-R1 baseline a 16.3%(4o-mini) improvement over the used commercial LLMs: GPT-4o-mini and Claudegeneration. With the growing trend of AI applications in hardware self-consistency method used in VRank. 3.5-Sonnet (Claude). the Note that due tofacilitated stricter by daily token design[5], particularly advancements LLMs, reTaken together, these results indicate an initialacross breakthrough in usage limitations, we conducted CorrectBench 156 tasks cent studies [2, 3, 11, 18] on RTL generation using LLMs highlight localized HDL generation quality under benchmarked and feedbackon Claude only once. Furthermore, as the development of the proficiency of LLMs in digitalahardware design. driven settings. and For knowledge more complex HDL designs, more promising CorrectBench was conducted using GPT-4o, its application on Additionally, several studies have explored the application LLMs future direction is to introduce hierarchical generation and of verificaother LLMs mightprocess. encounter or [15, interface compatibility in the verification Forformat instance, 16]implementations investigate the tion mechanisms. In such a framework, candidate issues, potentially leading to suboptimal results. potential of LLMs in formal verification, while [25] employs LLMs for each submodule can first be clustered and ranked, so that funccomparison results arehigher-quality presented in modules Fig.7. The bars toThe generate hardware testand stimuli. [22] offers a case study on LLMtionally more consistent areblue retained. based processor verification. Despite these efforts, a systematic illustrate the Eval2 pass ratios, where both Claude and 4o-mini These selected submodules can then be used to construct and optiapproach for LLM-automated remains absent, exhibit improvement among thegeneration methods. This indicates mize thesimilar top-level design. Suchtestbench a strategy may further improve the leaving a blank in the automation of the entire simulation-based that our CorrectBench demonstrates consistent performance accuracy of LLM-based generation for large-scale HDL designs. verification across theseprocess. LLMs. In this paper, an LLM-based testbench generation 3.2 LLM-based Testbench Generation The performance of AutoBench in Eval1 and workflow, Eval0 on AutoBench, is4o-mini proposed automatically generate for Claude andthe istoon occasionally totestbenches the baseline. Following discussion HDL designinferior generation, another key CorrectBench
This can be attributed the fact that Eval0 andwhich Eval1 are the not task in front-end design to is testbench construction, forms exhaustive metrics; the simpler testbenches generated the basis of simulation-based hardware verification. Althoughby LLMs baseline havegreat a higher likelihood of avoiding syntax errors and have shown potential in automating HDL design, directly using thema to generate leads to low testbenches pass rates. reporting “pass” for testbenches the DUTs. often However, these of LLM-generated areTo notimprove correctthe andcorrectness consequently fail at Eval2. testbenches, as
shown in Fig. 5, AutoBench [11] improves testbench generation V. two C ONCLUSION by splitting the task into parts: a driver and a checker. The In this work, we propose CorrectBench, the firstdriving automatic driver is responsible for constructing test scenarios, the design under test (DUT), and exporting signals, while the checker testbench generation framework with functional self-validation generates the expected outputs and checks whether DUT behavand self-correction. CorrectBench improved the the generated testior matches them.toNotably, checker is implemented in Python bench pass ratio 70.13%the compared with the previous work’s rather than This design choice is important two reasons. 52.18% andVerilog. baseline’s 33.33%. Moreover, for for sequential cirFirst, our Python better suited for expressing high-level checking cuits, workis generates 66.18% more correct testbenches than logic. Second,and LLMs are generally in generating AutoBench almost 5 timesmore the stable baseline method. Python Future code thanwill HDLs. AutoBench further introduces AutoEval,criteria, which research explore the more advanced validation evaluates the quality of the modified hybrid testbench. As shown coverage-based self-validation, and extracting additional inin Fig. 6, compared with baseline that directly generates the full formation to enable thethecorrector to perform more advanced
correction.
ACKNOWLEDGMENT This work is funded by the Deutsche Forschungsgemein-
Testing
Discrepancy: · Overflow… · Truncation · FIFO Issue · Stack Issue Fix
HLSRewriter (Optimization)
Automatic Evaluation Eval0
Behavioral Verification
HLSTester (Equivalence)
HLSRepair (Synthesizability)
AutoEval
Synthesized Circuit </> PPA Evaluation Optimized HDL Design
PPA-Optimized Design HLS
</> Fixed HLS-C Program
Optimize
Baseline Design </> Functional Correct HLS-C Program
Figure 7: Overview of an Agentic HLS Flow [21–23]. Pass Rate (%)
GPT Baseline
100 80 60 40 20 100 80 60 40 20
DP
GPT-Baseline with Scripts
HT DNN LP
100 80 60 40 20
DynamicArray
Pointer
SVM FFT
BT KNN
Pass Rate (%)
1. RTL Description 2. Module header
Pass Rate (%)
# Tokens (k)
the coraditional on-based ulting in g expenMs) have sign flow. es suffers uce Autoal circuit ask under gn task tbenches. 125 checking 100 ated test75 valuation 50 hes from 25 0 hat Auto%-wrong iscriminators @1 ratio tbenches fully has iteria from baseline. urced at cc.) among fact DOI:
DAC ’26, July 26–29, 2026, Long Beach, CA, USA Synthesizable Synthesized C/C++ Circuit </> Syntax Repair HLS Correct HLS-C Program
Unsynthesizable Source
CC
FS
CR
AES
Proposed HLSRepair
LL
DFS BFS
GA
BS
DS
LIP MPoL QRD Filter
TE
Recursion
Pass Rate (%)
Munich m.de
Boolean Operation Incomplete Statement
100 80 60 40 20
ET
BitWidth
Unsupported Struct Exception-Handling
Figure 8: Results of HLS Program Repair in Pass Rate [21]. testbench, AutoBench improves pass@1 by 57%. On 75 sequential circuit tasks, its performance reaches 3.36× that of the baseline. CorrectBench [12] further extends testbench generation into a closed-loop self-correction process. It introduces a functional self-validator and an automatic repair module: the framework first generates imperfect HDL designs from the same specification, then uses them to check whether the generated testbench produces decisions consistent with simulation results across different scenarios. If mismatches appear in most HDL designs, the error is more likely to come from the testbench itself. CorrectBench then uses the LLM to revise the problematic parts of the testbench. As reported in Fig. 6, CorrectBench achieves a 70.13% overall pass rate, which is significantly higher than the 52.18% achieved by AutoBench. ConfiBench [13] further improves robustness through scenario masking and an ensemble of multiple generated testbenches, achieving a 72.22% overall pass rate, higher than CorrectBench’s 70.13%. These advances represent meaningful progress in automating a traditionally labor-intensive verification task, especially when generation is combined with decomposition and self-correction. Still, the broader vision of agentic verification remains only partially realized, because coverage closure, corner-case completeness, and robust co-evolution with design generation are not yet solved.
3.3
LLM-based High-Level Synthesis
High-Level Synthesis (HLS) has emerged as a prominent methodology that translates C/C++ programs into hardware description languages (HDLs), significantly shortening hardware development cycles [15]. However, realizing the full potential of HLS is currently hindered by several fundamental barriers, the Compatibility Gap, the Equivalence Gap, and the Optimization Gap [21–23]. As shown in Fig. 7, to bridge the Compatibility Gap, HLSRepair introduces an LLM-based repair framework that transforms regular C/C++ programs into synthesizable HLS-C versions [21]. To mitigate LLM hallucinations, a Retrieval-Augmented Generation mechanism is introduced to guide the LLMs toward correct repair. To resolve the Equivalence Gap, HLSTester introduces an LLMassisted testing framework to detect behavioral discrepancies between original C/C++ programs and synthesized hardware [22].
DAC ’26, July 26–29, 2026, Long Beach, CA, USA
The framework leverages existing C/C++ testbenches to guide the LLM in generating HLS-compatible counterparts. Test inputs are produced via dynamic mutation, with a reasoning chain to increase the likelihood of revealing discrepancies. To overcome the Optimization Gap, HLSRewriter introduces an LLM-aided program refactoring framework [23]. A decomposition strategy splits complex loop structures into smaller tasks, enabling efficient pipelining. It also integrates a bit-width optimization to balance the trade-off between precision and resource usage, alongside LLM-guided pragma tuning to improve hardware performance. As reported in Fig. 8, the proposed framework improves the repair pass rate by 23.33% over the direct use of the LLM. It also achieves 2.71× higher testing efficiency than traditional methods, while improving hardware efficiency, with average reductions of 24.99%, 12.69%, and 18.34% in area, power, and latency, respectively. Taken together, LLM applications in HLS have shown early tangible progress, benefiting from structured feedback from compilation, synthesis, and QoR evaluation. However, the field is still in its early stage, with challenges remaining in code quality [28], design optimization, and integration into realistic flows. A promising next step is to develop LLM-enhanced HLS agents that learn from paired HLS–HDL designs and improve through closed-loop feedback [29].
4
Challenges and Opportunities
Agentic AI has recently emerged as a promising technology for building more autonomous and interactive intelligent systems. Pioneering systems such as OpenClaw point to a promising direction for developing LLM-based systems by organizing model capabilities through retrieved skills and tool-use mechanisms. However, current OpenClaw-style agents still face major limitations when applied to EDA, and several challenges still need to be addressed before such systems can be reliably deployed in real industrial workflows. A major limitation is their difficulty in maintaining semantic consistency across design stages. Another major limitation is their high token consumption and low execution efficiency, since the model often has to process a large volume of lengthy skill documents. To build an OpenClaw-style framework suitable for EDA, the agent should focus on tasks that traditional scripts cannot easily handle, such as specification understanding, repair strategy generation, and cross-stage feedback interpretation, while deterministic scripts and EDA tools continue to handle simulation, synthesis, and data processing. At the same time, long skill descriptions should be compressed into structured and retrievable tool interfaces to reduce context overhead. Persistent state management, design memory, module-level tracing, and verifiable closedloops are also essential. From this perspective, Fig. 9 highlights several future directions that can be further explored to advance the development of agentic AI technologies in EDA. ◦ Dataset and Knowledge Base Construction: The performance of LLMs in EDA strongly depends on training data, but high-quality hardware datasets remain limited [26]. Compared with software repositories, hardware repositories are smaller, more fragmented, and often lack aligned annotations, such as specificationcode pairs or verified C++-Verilog mappings. EDA corpora should also include tool manuals, user guides, and report documentation, which provide essential knowledge for tool use and feedback interpretation. Future work should therefore focus on building largescale, diverse, and well-aligned datasets, together with structured and retrievable knowledge bases, for hardware design tasks. ◦ Design Specification Refinement: Writing clear and accurate architecture specifications is a critical first step in chip design
Kangwei Xu, Bing Li, Ulf Schlichtmann
Dataset & Knowledge Base Construction
Design Specification Refinement
Resource-Efficient Models
Hardware-Aware Algorithms
Multi-Agent Design Systems
Figure 9: Future Opportunities for EDA in Front-End Design. and is typically undertaken by experienced engineers. However, ambiguities or minor errors in specifications can still propagate through downstream design steps. Once such issues are exposed at lower levels of abstraction, they become significantly more difficult and costly to diagnose and correct. Therefore, specification refinement is an important direction for future research. LLMs may help improve specification quality through rewriting, clarification, consistency checking, and intent completion, thereby enhancing both the efficiency and reliability of the overall design workflow. ◦ From Natural Language to Hardware-Aware Algorithms: Recent work shows that LLMs can translate natural language into C/C++ with high accuracy [27]. A natural next step is to generate hardware-aware C/C++ directly from natural language specifications, thereby improving the accuracy and performance of downstream HDL designs generated through HLS. This direction can support an end-to-end flow from design intent to hardware implementation. Future work should also teach models to learn from expert design strategies, and common HDL patterns, allowing generated designs to better match experienced engineers’ practices. ◦ Collaborative Multi-Agent Design Systems: Front-end EDA involves tightly connected tasks such as architecture design, HDL generation, verification, and debugging. A single model is often not enough to handle all of them [9]. Future research should explore collaborative multi-agent systems, where different agents specialize in different tasks and coordinate toward shared design goals. With clear communication and role division, such systems may better reflect real engineering teams and improve end-to-end automation, especially for complex projects that require cross-stage reasoning. ◦ Resource-Efficient Models for EDA: As agentic EDA workflows grow in complexity and rely on multiple specialized models and frequent tool interactions, efficiency becomes a major concern. The challenge is not only to reduce model size, but also to jointly optimize model routing and reasoning depth. Future work should explore compact task-specific models, adaptive inference, and cost-aware reasoning strategies, so that LLM-based EDA systems can improve design quality without introducing excessive computational overhead in the practical front-end flow.
5
Conclusion
LLMs are opening a new direction for front-end EDA. As discussed in this paper, they have shown strong potential in key tasks such as specification understanding, HDL design generation, testbench construction, and HLS debugging. More importantly, the rise of agentic AI suggests that LLMs may evolve from local assistants into system-level agents that can coordinate tools, interpret feedback, and support closed-loop design flows. Although significant challenges remain, LLMs still hold strong promise for the future of front-end EDA. Realizing this vision will require not only stronger models, but also better datasets, tighter tool integration, and more reliable and verifiable agent frameworks. With continued progress along these directions, LLM-enabled EDA could become an important step toward more automated and intelligent chip design.
LLM for EDA in Front-End Design: Challenges and Opportunities
References
[1] M. Li, W. Fang, Q. Zhang, and Z. Xie, “SpecLLM: Exploring Generation and Review of VLSI Design Specification with Large Language Model,” in Proceedings of the International Symposium of Electronics Design Automation (ISEDA), 2025. [2] M. Liu et al., “ChipNeMo: Domain-Adapted LLMs for Chip Design,” arXiv preprint arXiv:2311.00176, 2023. [3] M. Liu, N. R. Pinckney, B. Khailany, and H. Ren, “Invited Paper: VerilogEval: Evaluating Large Language Models for Verilog Code Generation,” in Proceedings of the IEEE/ACM International Conference on Computer-Aided Design (ICCAD), 2023. [4] Z. Zhang, B. Szekely, P. Gimenes, G. Chadwick, H. McNally, J. Cheng, R. D. Mullins, and Y. Zhao, “LLM4DV: Using Large Language Models for Hardware Test Stimuli Generation,” in Proceedings of the IEEE International Symposium on Field-Programmable Custom Computing Machines (FCCM), 2025. [5] H. Wu, Z. He, X. Zhang, X. Yao, S. Zheng, H. Zheng, and B. Yu, “ChatEDA: A Large Language Model Powered Autonomous Agent for EDA,” IEEE Transactions on Computer-Aided Design of Integrated Circuits and Systems, vol. 43, no. 10, 2024. [6] S. Qiu, M. Wang, R. Afsharmazayejani, M. M. Shahmiri, B. Tan, H. Pearce, “Towards LLM-based Root Cause Analysis of Hardware Design Failures,” in Proceedings of the IEEE International Conference on Omni-layer Intelligent Systems, 2025. [7] J. Li, S. -Z. Wong, G. -W. Wan, X. Wang and J. Yang, “EDA-Debugger: An LLMBased Framework for Automated EDA Runtime Issue Resolution,” in Proceedings of the IEEE International Symposium on Quality Electronic Design (ISQED), 2025. [8] OpenClaw, “OpenClaw,” GitHub repository, 2026. [Online]. Available: https://github.com/openclaw/openclaw . Accessed: Apr. 15, 2026. [9] K. Xu, J. Sun, Y. Hu, X. Fang, W. Shan, X. Wang, and Z. Jiang, “MEIC: Re-thinking RTL Debug Automation using LLMs,” in Proceedings of the IEEE/ACM International Conference on Computer-Aided Design (ICCAD), 2024. [10] K. Xu, R. Qiu, Z. Zhao, G. L. Zhang, U. Schlichtmann, B. Li, “LLM-Aided Efficient Hardware Design Automation,” arXiv: 2410.18582, 2024. [11] R. Qiu, G. L. Zhang, R. Drechsler, U. Schlichtmann, and B. Li, “AutoBench: Automatic Testbench Generation and Evaluation Using LLMs for HDL Design,” in Proceedings of the ACM/IEEE International Symposium on Machine Learning for CAD (MLCAD), 2024. [12] R. Qiu, G. L. Zhang, R. Drechsler, U. Schlichtmann, and B. Li, “CorrectBench: Automatic Testbench Generation with Functional Self-Correction using LLMs for HDL Design,” in Proceedings of the IEEE/ACM Design, Automation & Test in Europe Conference & Exhibition (DATE), 2025. [13] R. Qiu, G. L. Zhang, R. Drechsler, T.-Y. Ho, U. Schlichtmann, and B. Li, “ConfiBench: Automatic Testbench Generation with Confidence-Based Scenario Mask and Testbench Ensemble using LLMs for HDL Design,” ACM Transactions on Design Automation of Electronic Systems (TODAES), 2026. [14] J. Gai, H. M. Chen, Z. Wang, H. Zhou, W. Zhao, N. Lane, and H. Fan, “Exploring Code Language Models for Automated HLS-based Hardware Generation: Benchmark, Infrastructure and Analysis,” in Proceedings of the IEEE/ACM Asia and South Pacific Design Automation Conference (ASP-DAC), 2025. [15] J. Cong, J. Lau, G. Liu, S. Neuendorffer, P. Pan, K. Vissers, and Z. Zhang, “FPGA HLS Today: Successes, Challenges, and Opportunities,” ACM Transactions on
DAC ’26, July 26–29, 2026, Long Beach, CA, USA Reconfigurable Technology and Systems (TRETS), vol. 15, no. 4, 2022. [16] S. Lahti, P. Sjövall, J. Vanne, T. Hämäläinen, “Are We There Yet? A Study on the State of High-Level Synthesis,” IEEE Transactions on Computer-Aided Design of Integrated Circuits and Systems (TCAD), 2019. [17] Z. Yan, W. Fang, M. Li, M. Li, S. Liu, Z. Xie, H. Zhang, “AssertLLM: Generating Hardware Verification Assertions from Design Specifications via Multi-LLMs,” in Proceedings of the IEEE/ACM Asia and South Pacific Design Automation Conference (ASP-DAC), 2025. [18] A. Ghose, A. B. Kahng, S. Kundu, B. Pramanik, “Invited: Agentic AI for Physical Design R&D: Status and Prospects,” in Proceedings of the IEEE International Symposium on Physical Design (ISPD), 2026. [19] Z. Zhao, R. Qiu, I.-C. Lin, G. L. Zhang, B. Li, U. Schlichtmann, “VRank: Enhancing Verilog Code Generation from LLMs via Self-Consistency,” in Proceedings of the IEEE International Symposium on Quality Electronic Design (ISQED), 2025. [20] Z. Zhao, B. Li, G. L. Zhang, and U. Schlichtmann, “VFocus: Better Verilog Generation from Large Language Model via Focused Reasoning,” in Proceedings of the IEEE International System-on-Chip Conference (SOCC), 2025. [21] K. Xu, G. L. Zhang, X. Yin, C. Zhuo, U. Schlichtmann, and B. Li, “Automated C/C++ Program Repair for High-Level Synthesis via Large Language Models,” in Proceedings of the ACM/IEEE International Symposium on Machine Learning for CAD (MLCAD), 2024. [22] K. Xu, B. Li, G. L. Zhang, and U. Schlichtmann, “HLSTester: Efficient Testing of Behavioral Discrepancies with LLMs for High-Level Synthesis,” in Proceedings of the IEEE/ACM International Conference on Computer-Aided Design (ICCAD), 2025. [23] K. Xu, G. L. Zhang, X. Yin, C. Zhuo, U. Schlichtmann, and B. Li, “HLSRewriter: Efficient Refactoring and Optimization of C/C++ Code with LLMs for High-Level Synthesis,” ACM Transactions on Design Automation of Electronic Systems, 2026. [24] K. Xu, et al., “Logic Design of Neural Networks for High-Throughput and LowPower Applications,” in Proceedings of the IEEE/ACM Asia and South Pacific Design Automation Conference (ASP-DAC), 2024. [25] Q. Xu, L. Stok, R. Drechsler, X. Wang, G. L. Zhang, I. L. Markov, “Revolution or Hype? Seeking the Limits of Large Models in Hardware Design,” in Proceedings of the IEEE/ACM International Conference on Computer-Aided Design (ICCAD), 2025. [26] Q. Xu, L. Stok, R. Drechsler, X. Wang, G. L. Zhang, I. L. Markov, “Revolution or Hype? Seeking the Limits of Large Models in Hardware Design,” in Proceedings of the IEEE/ACM International Conference on Computer-Aided Design (ICCAD), 2025. [27] Z. Yu, Y. Zhao, A. Cohan, and X.-P. Zhang, “HumanEval Pro and MBPP Pro: Evaluating Large Language Models on Self-invoking Code Generation Task,” in Findings of the Association for Computational Linguistics (ACL), 2025. [28] K. Xu, G. L. Zhang, U. Schlichtmann, and B. Li, “CorrectHDL: Agentic HDL Design with LLMs Leveraging High-Level Synthesis as Reference,” arXiv preprint arXiv:2511.16395, 2025. [29] K. Xu, D. Schwachhofer, J. Blocklove, I. Polian, P. Domanski, D. Pfluger, S. Garg, R. Karri, O. Sinanoglu, J. Knechtel, Z. Zhao, U. Schlichtmann and B. Li, “Large Language Models (LLMs) for Electronic Design Automation (EDA) : Special Session Paper,” in Proceedings of the IEEE International System-on-Chip Conference, 2025.