WorksComputer Science
OpenLayout: An Open and Agentic-Driven Platform for Holistic VLSI Physical Design and Benchmarking
Abstract
Physical design automation of very large-scale integrated circuits (VLSI) has made significant strides, progressing from single-stage placement and routing toward increasingly integrated full-flow implementation. Yet, existing approaches struggle with the vast design space optimization (DSO) arising from diverse technology nodes, circuit designs, and varied constraints. The substantial runtime of physical-design tools further exacerbates this challenge, leaving industrial workflows heavily dependent on experienced engineers to navigate the design space and achieve power, performance, and area (PPA) targets, incurring significant engineering effort. We argue that large language models (LLMs) with strong reasoning capabilities, enriched with distilled human design expertise, offer a promising path toward efficient and automated DSO. Unlike traditional algorithms, LLMs can interpret complex design contexts and naturally incorporate human expertise expressed in natural language for reasoning, acting, observing, and adapting throughout the design process, a capability that conventional optimization methods cannot exploit. To this end, we present OpenLayout, an agentic platform that leverages multi-agent collaboration with embedded design knowledge to enable self-iterative DSO. We further introduce OpenLayout-Bench, a benchmark targeting advanced technology nodes with commercial EDA tools to systematically evaluate physical design automation capabilities of LLMs. Experimental results demonstrate that OpenLayout achieves state-of-the-art performance, with approximately 20% accuracy improvement over baseline methods. Our work is open-sourced at https://github.com/fenggev56/OpenLayout
Introduction
Very large-scale integrated circuits (VLSI) are the foundational hardware cornerstone for advancing nearly all modern critical technologies, such as supercomputing, physical AI, data centers, and quantum computing [39, 43]. The growing demand for more capable hardware places increasing pressure on chip designers to meet stringent power, performance, and area (PPA) targets while adhering to aggressive time-to-market constraints, particularly at advanced technology nodes [5, 38]. To accelerate design cycles and improve quality of results (QoR), recent efforts [3, 38, 41, 44] have increasingly explored full-flow physical design automation,
with industrial and open-source frameworks such as Fusion Compiler [38] and OpenROAD [3] serving as notable examples. Despite this progress, these approaches continue to face the formidable design space optimization (DSO) challenge, arising from the diversity of technology nodes, circuit designs, and design constraints [41]. Moreover, physical design is inherently hierarchical and tightly coupled: decisions across floorplanning, macro placement, power delivery network (PDN) synthesis, and clock tree synthesis (CTS) interact in complex ways, while each stage can incur substantial computational cost. Consequently, efficiently navigating the enormous cross-stage design space while achieving high-quality PPA remains a fundamental challenge for automated physical design.
We observe that experienced physical-design engineers navigate this complexity not through exhaustive exploration, but by interpreting design context, analyzing electronic design automation (EDA) tool logs, anticipating how upstream floorplanning decisions affect downstream routing congestion, and adapting strategies to process-specific constraints [22, 39]. Such contextual, cross-stage reasoning, typically conveyed through natural language and difficult to encode in conventional optimization algorithms, is largely absent from today’s automated flows. We posit that agentic AI offers a natural paradigm for holistic physical-design automation [36], because it can reason, act, observe, and adapt throughout the design process. Three structural properties of physical design particularly motivate this view. 1) Script-Driven Orchestration. Each design stage is controlled by parameterized tool commands (e.g., Tcl scripts for commercial place-and-route engines), whose effectiveness depends on expert choices of parameters, pin-assignment strategies, PDN configurations, placement-density targets, and CTS constraints. This script-centric interface provides an actionable mechanism for an agent to translate design intent and domain knowledge into concrete tool actions. 2) Structural Regularity.
This work is licensed under a Creative Commons Attribution-NonCommercial-NoDerivatives 4.0 International License.
ICCAD ’26, San Jose, CA, USA
© 2026 Copyright held by the owner/author(s).
ACM ISBN 979-8-4007-2873-0/2026/11
https://doi.org/10.1145/3831252.3834220 Designs within the same circuit family (e.g., successive CPU generations) often exhibit recurring architectural and physical-design patterns. This regularity enables successful strategies and expert knowledge acquired from prior designs to transfer across related instances, reducing the need to optimize each design from scratch.
3) Cross-Stage Coupling. Physical-design decisions are tightly coupled: floorplanning choices influence placement, CTS, and routing, while downstream outcomes can reveal problems that require revisiting upstream decisions. Effective automation therefore requires a closed-loop process that continuously observes intermediate outcomes and adapts subsequent actions, capabilities that isolated stage-wise optimizers and retrieval-augmented generators alone cannot provide. A large language model (LLM)-based agentic system can jointly exploit all three properties. It can translate natural-language domain knowledge into executable design actions, interpret heterogeneous EDA feedback, including logs, timing reports, and congestion metrics, and maintain a coherent decision trajectory across the entire physical-design flow. This enables a shift from stage-wise optimization toward context-aware, closed-loop automation, more closely mirroring how experienced engineers reason about and optimize complex physical designs.
Building on these insights, we introduce OpenLayout, an open-source, multi-agent platform for holistic physical design that formulates layout design as a collaborative, self-iterative optimization process driven by reasoning (Figure 5). Given a gate-level netlist, technology constraints, digital libraries, and user-specified design objectives, OpenLayout orchestrates a team of specialized agents through a hub-and-spoke message-passing architecture to produce a DRC-clean, timing-closed layout (Figure 1). The framework comprises five purpose-built agents, each encapsulating a distinct concern. For example, Planning Agent serves as the central hub, decomposing user intent into a directed acyclic graph (DAG) of subtasks, routing all inter-agent messages, and maintaining global execution state. Worker Agent interfaces with the target EDA tool (e.g., Cadence Innovus) via a persistent interactive shell, executing Tcl commands and returning structured results. Debug Agent diagnoses failures through LLM-powered root-cause analysis, correlating error signatures against known failure modes. Optimize Agent performs closed-loop parameter tuning guided by metric trajectories and domain knowledge. Each agent is equipped with dedicated domain knowledge distilled from the accumulated expertise of senior physical design engineers and researchers. This knowledge is organized into modular, self-contained skill packs, each encapsulating per-stage expertise: reference Tcl scripts, parameter tuning strategies, debug decision matrices, and cross-stage impact analyses. Skill packs are automatically discovered during initialization and dynamically retrieved through fuzzy matching, enabling the framework to incorporate new technology nodes and EDA toolchains without modifying the underlying agent logic. Together, these components transform physical design from a fixed, script-driven pipeline into an adaptive, knowledge-guided optimization process.
Figure 1. OpenLayout takes a netlist, PDK, digital libraries, and constraints as input and autonomously generates DRC-clean, timing-signed-off GDS. There is no human in the loop.
Figure 5. Overview of the OpenLayout Platform. (a) OpenLayout employs a hierarchical multi-agent system comprising a Planner (coordinator), Worker, Debugger, and Optimizer, augmented by Analyzer, where the Planner decomposes user instructions into structured plans. (b) Agents iteratively interact with EDA tools (e.g., Innovus) by submitting Tcl scripts, collecting execution results, and extracting key information via the Analyzer for closed-loop refinement. (c) The planning & working flow: The Planner decomposes tasks into subplans (init, floorplan, powerplan, etc.), which the Worker executes sequentially through the full physical design flow. (d) The debug and optimize flow: the Debugger performs checks (e.g., macro overlap) and applies fix strategies, while the Optimizer resolves timing and congestion optimization, both guided by the Design Context containing accumulated design information and previously validated scripts.
To evaluate our approach, we introduce OpenLayout-Bench, a benchmark suite tailored for layout-focused autonomous agents using commercial EDA tools at advanced technology nodes, a gap not addressed by existing benchmarks [44, 47]. OpenLayout-Bench consists of two components: (1) a holistic flow suite containing 10 circuits of varying complexity, spanning from floorplanning to final sign-off; and (2) an atomic task suite covering individual implementation steps, such as technology file loading, to evaluate fine-grained agent capabilities. Our main contributions are summarized as follows:
We introduce OpenLayout-Bench, a benchmark suite for evaluating agent capabilities in physical design using commercial EDA tools at advanced technology nodes. Evaluation results show that standalone LLMs perform poorly on this benchmark; for example, Gemini 3.1-pro-preview [17] achieves a pass rate of only 18.9%, highlighting the difficulty of the task and the need for a dedicated agentic framework.
We present OpenLayout, an open-source, multi-agent platform for holistic physical design automation, covering the complete flow from floorplanning to final sign-off.
Experimental results demonstrate that OpenLayout achieves state-of-the-art performance. Built on Gemini 3.1-pro-preview, our platform achieves a pass rate of 84.4%, representing a significant improvement over the standalone LLM baseline.
Background and Related Work
VLSI Physical Design Flow
A generic VLSI design flow spans from architectural design to packaging (Figure 2). Physical design is the most critical and complex design stage. After logic synthesis converts RTL code to a gate-level netlist, the physical design stage realizes the netlist as a geometrically placed and routed circuit ready for fabrication, comprising five tightly coupled steps [22]. Floorplanning partitions the die into spatial regions for macros and functional blocks, defines the core area, and determines pin positions along the chip boundary. Power planning constructs a hierarchical PDN (rings, straps, mesh, vias) to satisfy IR-drop and electromigration constraints with minimal routing overhead. Placement assigns legal locations to all standard cells and macros, minimizing wirelength and congestion under timing and density constraints. Clock Tree Synthesis (CTS) builds a buffered clock network that delivers the clock to all sequential elements with bounded skew, latency, and transition time. Routing assigns wire segments to metal layers for all signal nets, subject to design rule constraints (DRC), while minimizing wirelength, via count, and congestion. These stages are strongly coupled: floorplan quality constrains placement, which in turn determines the congestion and timing margins available to CTS and routing.
Figure 2. Modern VLSI design workflow. The pipeline spans architectural design through packaging, with physical design mainly encompassing floorplan, powerplan, placement, clock tree synthesis (CTS), routing, and ECO.
Related Work
AI has made significant advances in IC design automation [6, 7, 14, 15, 16, 24, 26, 29, 35, 42]. In digital VLSI design, AI-driven methods have been increasingly used for PPA optimization throughout the physical design flow. Early approaches can be broadly categorized into two paradigms: full-flow optimization, which jointly optimizes multiple stages of the physical-design flow, and stage-specific optimization, which targets individual stages such as placement, power planning, CTS, or routing [48]. We first review these two paradigms, then discuss the emerging use of LLMs for physical design and the benchmarks used to evaluate existing approaches.
(i) Full-Flow Optimization. Full-flow optimization seeks to automate multiple physical-design stages jointly. Commercial reinforcement learning (RL)-based platforms such as Synopsys DSO.ai [41] autonomously explore placement, CTS, and routing parameters, while Cadence Cerebrus [31] learns transferable AI models for warm starts across designs. OpenROAD [3] provides an open-source place-and-route flow on public PDKs. Yet, these approaches typically rely on predefined parameter spaces and hand-crafted objectives, limiting adaptability to novel designs, constraints, and optimization goals.
(ii) Stage-Specific Optimization. Substantial effort has also targeted individual physical-design stages. Floorplanning and Placement. DREAMPlace [27] formulates analytical placement as GPU-accelerated optimization, while AutoDMP [2] applies Bayesian optimization to macro and standard-cell placement. RL-based methods include MaskPlace [21], which learns pixel-level placement policies, and Mirhoseini et al. [32], which combine GNN-based netlist representations with RL for macro placement. Power Planning. OpeN-PDN [13] uses CNN-based PDN template selection with transfer learning, while GridNet [49] predicts IR-drop and enables localized repair. CTS and Routing. GAN-CTS [30] combines GANs and RL for CTS parameter optimization, while RouteNet [46] predicts DRC hotspots and congestion to reduce expensive routing iterations. Despite their effectiveness, stage-specific methods largely optimize individual stages and do not explicitly capture the strong dependencies between upstream and downstream design decisions.
(iii) LLMs for Physical Design. The emergence of LLMs introduces a complementary paradigm that shifts from task-specific optimization toward language-driven reasoning and tool interaction. Early work applies LLMs to EDA script generation. More recently, LLM-based agents have been used to drive complete physical-design flows with open-source EDA tools, including ChatEDA [44] and EDAid [45]. However, existing approaches primarily rely on LLM parametric knowledge, optionally augmented with retrieval-augmented generation (RAG), to interpret tool feedback and generate commands. As shown by our experiments (§ 5.4), this paradigm struggles with complex designs and advanced technology nodes, where the design space is large and design rules, tool behavior, and closure strategies are highly process-specific. These limitations motivate systematic evaluation of whether LLM agents can effectively acquire and apply such domain knowledge across the full design flow.
(iv) Benchmarks. Existing EDA benchmarks are predominantly stage-specific. For example, the GSRC and MCNC suites [19] remain widely used for floorplanning and macro placement. Yet, they lack the scale and complexity of modern SoCs. At the flow level, OpenROAD Flow Scripts (ORFS) [3] provides a reproducible RTL-to-GDSII framework using open-source designs and public PDKs such as NanGate45, and has become a common baseline for open-source full-flow PPA evaluation. However, the provided benchmarks largely focus on open-source tools and mature technology nodes, leaving advanced-node designs with commercial EDA tools, where design rules and constraints are substantially more stringent, without a standardized evaluation framework. This gap motivates OpenLayout-Bench, which targets advanced technology nodes and commercial EDA tools to enable systematic evaluation of agentic physical-design automation.
Benchmark Suite
We propose OpenLayout-Bench, a benchmark suite for systematically evaluating LLM agents on physical design across advanced technology nodes and diverse VLSI designs. It comprises two complementary components: the Atomic Task Suite, which evaluates step-level command proficiency across individual physical-design stages, and the Holistic Flow Suite, which evaluates an agent’s ability to execute the complete RTL-to-GDS flow end-to-end. The Atomic Task Suite is distilled from tapeout-validated design scripts whose results have been published at leading conferences, including ISSCC [12], VLSI Symposium [10], A-SSCC [11], and CICC [9]. The Holistic Flow Suite provides gate-level netlists and associated design inputs, requiring agents to autonomously navigate the full physical-design flow across diverse designs and technology nodes.
Atomic Task Suite
The Atomic Task Suite evaluates agent proficiency at the individual command and script level, covering the canonical steps of a complete physical design flow. Task categories include technology LEF/LIB ingestion, MMMC timing constraint setup, core area and utilization specification, power grid definition, and sign-off metric extraction. One example is shown in Figure 3. The distribution of questions is weighted by stage complexity and industrial importance, with denser coverage in static timing analysis (STA) and physical verification (PV) to reflect their disproportionate cost and criticality in industrial sign-off flows. The task distribution across physical design stages is shown in Figure 4. The STA task subset is curated from STA-focused questions used in physical design engineer interviews. To avoid data contamination, we retain only questions without a single deterministic answer. To ensure correctness, all reference answers are independently validated by three senior physical design engineers, whose consensus serves as the ground truth for evaluation. The Atomic Task Suite targets commercial flows (Cadence Innovus and Synopsys ICC2) and commercial process nodes (e.g., TSMC 28 nm), enabling evaluation under industrial-grade constraints that more faithfully reflect real deployment conditions.

Figure 3. An example task from the Timing Analysis category (OCV Derate Configuration).
Figure 4. Distribution of benchmark questions across physical implementation stages for the Cadence Innovus and Synopsys ICC2 commercial flows. Static timing analysis intentionally over-sampled beyond its stage count to reflect its critical role in industrial sign-off closure.
Holistic Flow Suite
The Holistic Flow Suite comprises 10 open-source RTL designs spanning varying design complexity, organized into three categories: Processor Cores, Arithmetic & Accelerators, and Control & Communication Circuits, as summarized in Table 1. Processor Cores. TinyRISC-V [25] is a lightweight 32-bit RV32IM 3-stage in-order core for microcontroller workloads; Open910 [8] is a high-performance out-of-order RV64GC core representative of large, macro-rich designs with deep timing paths. Arithmetic & Accelerator Kernels. A parameterized systolic array [1] and a 16b pipelined multiplier cover regular compute-dense circuits. NVDLA [33] is included in both small and large configurations, spanning medium- to large-scale accelerator complexity. AES-256 [20] provides a cryptographic circuit with structured regular logic and strict timing constraints. Control & Communication. A UART controller [40], an Ethernet MAC [34], and an elevator finite state machine (FSM) represent I/O-intensive and control-dominated designs, each posing distinct challenges in pin placement and state encoding.
| Category | Design | #Cells |
| Processor Cores | TinyRISC V | 15012 |
| Processor Cores | Open910 | 754,981 |
| Arithmetic & Accelerator | Systolic array | 41198 |
| Arithmetic & Accelerator | 16b pipelined mult. | 342 |
| Arithmetic & Accelerator | AES-256 | 15516 |
| Arithmetic & Accelerator | NVDLA-small | 270,072 |
| Arithmetic & Accelerator | NVDLA-large | 1,478,865 |
| Control & Communication | UART controller | 368 |
| Control & Communication | Elevator FSM | 176 |
| Control & Communication | Ethernet MAC | 35172 |
Table 1. Benchmark designs used for evaluation, categorized by design types with corresponding cell counts.
Example Task: OCV Derate Configuration
Context: To account for On-Chip Variation (OCV) during the pre-CTS stage, timing derates must be applied to introduce pessimism. For setup checks, the launch path (clock and data) is made late (slower) and the capture path is made early (faster). Because hold optimization typically occurs after CTS, both setup and hold views are initially set to the cmax corner.
Question: Provide the Innovus commands to set the analysis view for both setup and hold to core_view_cmax. Additionally, for the core_corner_cmax corner, apply a clock derate of 0.952 (early) and 1.048 (late), and a data derate of 1.081 (late).
Answer:
set_analysis_view -setup {core_view_cmax} -
hold {core_view_cmax}
set_timing_derate -delay_corner {
core_corner_cmax} -early 0.952 -late
1.048 -clock
set_timing_derate -delay_corner {
core_corner_cmax} -late 1.081 -data
Verification: Exact Match
Evaluation Metrics
Implementation Task Suite. For individual implementation tasks, we adopt and accuracy as primary metrics, measuring whether the agent produces a correct, executable solution on the first attempt and within five attempts, respectively. End-to-End Layout Implementation. For full RTL-to-GDS flow evaluation, we record two complementary dimensions per design. First, stage completion status: a binary pass/fail indicator for each flow stage (init, floorplan, placement, CTS, routing, and sign-off), capturing whether the agent successfully advances the flow to completion. Second, layout quality metrics at flow completion: total cell area (), core utilization (%), worst negative slack (WNS) for timing, and design rule violation (DRV) count. Together, these metrics distinguish an agent that merely executes a flow from one that produces a PPA-optimized, sign-off-clean layout.
OpenLayout Framework
Overview
OpenLayout is a multi-agent framework for autonomous physical design that formulates layout design as a collaborative, iterative optimization process driven by reasoning, as illustrated in Figure 5(a) and (b). Given a gate-level netlist, technology constraints, digital libraries, and design objectives, OpenLayout orchestrates five specialized agents through a hub-and-spoke message-passing architecture to generate a DRC-clean, timing-closed layout.
Following the natural structure of physical design, we organize the process into four phases: planning, implementation, debugging, and optimization. These phases form a closed loop, enabling the system to iteratively diagnose failures, refine design decisions, and drive the layout toward convergence. Accordingly, OpenLayout comprises a Planning Agent, Worker Agent, Debugger Agent, and Optimizer Agent, augmented by an Analyzer Agent that extracts actionable metrics from verbose EDA tool logs. Together, these agents provide coordinated planning, execution, diagnosis, analysis, and optimization across the full physical-design flow.
Agent Roles. Each agent encapsulates a distinct concern: (i) Planner serves as the central hub, decomposing user intent into a directed acyclic graph (DAG) of subtasks, routing all inter-agent messages, and maintaining global execution state; (ii) Worker interfaces with the EDA tool (e.g., Innovus) via a persistent interactive shell, executing TCL commands and returning structured results (Figure 5(c)); (iii) Analyzer extracts quantitative metrics, such as timing (WNS/TNS), physical (DRC, utilization), and power, from EDA logs; (iv) Debugger diagnoses failures through LLM-powered root-cause analysis; (v) Optimizer performs parameter tuning guided by metric trajectories and domain knowledge, as shown in Figure 5(d). Hub-and-Spoke Communication. All inter-agent messages are routed through the Planning Agent, which maintains full observability of the system state and enforces execution ordering. The sole exception is tool interaction: any agent may directly invoke EDA tool commands via a synchronous execute_tool interface, bypassing hub routing to avoid latency overhead for frequent tool queries. This hybrid topology balances centralized coordination with efficient tool interaction. Skill Packs. Domain knowledge is organized into skill packs, self-contained directories structured as skills_{tech}_{tool}/ (e.g., skills_tsmc28nm_innovus/). Each skill pack contains per-stage skill files encoding expert knowledge: reference TCL scripts, parameter tuning strategies, debug decision matrices, and cross-stage impact analyses. Skills are autodiscovered at initialization and resolved dynamically via fuzzy matching, enabling seamless extension to new technology nodes and EDA tools without modifying agent code. Privacy-Preserving Deployment. OpenLayout never exposes proprietary design data to LLMs: technology libraries, netlists, and raw EDA logs remain local, and only distilled metrics (e.g., PPA, DRC counts) are sent to the model. Agents thus act on the design solely through local TCL execution (see [23] for more details).
Agent Design
Each agent inherits from a common BaseAgent class that provides message handling, LLM access, tool query primitives, and a shared DesignContext. The DesignContext is a cached representation of the active design, populated by querying the EDA tool after initialization, including macro locations, die/core area, and clock topology. It is shared across all agents to maintain consistent design state throughout the optimization loop.
Worker Agent. The Worker Agent maintains a persistent EDA session and executes subtasks in three modes: (1) skill-guided generation, where the LLM synthesizes Tcl scripts from skill content and design context; (2) script execution, where reference Tcl scripts are sourced and run directly; and (3) optimization application, where targeted optimizations requested by the Optimizer Agent are applied and coordinated through the Planner Agent. Executed scripts, logs, and layout snapshots are organized by stage in a session history with manifest tracking, ensuring full traceability and enabling downstream agents to reference artifacts from any prior stage.
Analyzer Agent. The Analyzer Agent is selectively activated at analysis-critical stages (e.g., placement, CTS, and routing), where raw EDA tool logs are verbose and difficult to interpret directly. At each activated stage, it extracts a structured StageMetrics vector covering timing, utilization, routing, clock, and power metrics, and passes this condensed summary to the Debugger and Optimizer Agents for closed-loop refinement. Lightweight stages such as floorplanning and powerplanning bypass analysis, reducing runtime overhead without sacrificing QoR at critical design junctures.
Debugger Agent. After the Worker Agent completes a stage, the Debugger Agent checks for DRC violations and other errors by executing an iterative diagnosis loop. It loads the stage-specific debug skill, initializes a multi-turn LLM conversation with the skill content, EDA output, and convergence state as context, then iteratively performs check→fix→check cycles via direct tool queries. Each step is tracked in an AgentStageContext that maintains the full conversation history, violations found and fixed, and budget consumption. Skills provide the check criteria and corresponding fix strategies for each stage. To prevent unbounded iteration, a three-tier budget hierarchy is enforced: (1) micro-level, handling syntax errors with up to 2 retries; (2) meso-level, handling parameter adjustments with up to 4 retries; and (3) macro-level, handling cross-stage rollback with up to 2 retries. When the budget is exhausted, the Debugger Agent escalates to the Optimizer Agent for more aggressive intervention.
Optimizer Agent. The Optimizer Agent operates in two modes. In iterative mode, it conducts a multi-turn LLM-guided loop analogous to the Debugger Agent: checking current metrics, adjusting parameters (e.g., placement effort illustrated in Figure 5(d)), informed by stage-specific optimization skills and the full iteration trajectory stored in MetricsDB, then verifying improvements. In tree-of-thought mode, triggered on escalation or LLM-directed exploration, it performs branching design space exploration by generating multiple solution candidates and executing them either in parallel or sequentially, as described in § 4.3.
Closed-Loop DSO Mechanism
The DSO mechanism in OpenLayout operates at two levels: a stage-level that progresses through the physical design flow, and a parameter-level that explores the design space within each stage.
Stage-Level Execution. The Planning Agent maintains a plan of subtasks ordered by dependency. For each subtask , execution follows one of two paths based on the tool output:
(1) Success path: Tool Planner Analyzer Optimizer Planner advance or re-run;
(2) Failure path: Tool Planner Debugger Planner {retry, fix, rollback, skip, escalate}. The convergence state, classified as improving, stalled, or diverging based on the metric trajectory across iterations, informs action selection at each decision point.
Parameter-Level Exploration. When the Optimizer Agent determines that local parameter adjustments are insufficient, for example upon escalation from the Debugger Agent or detection of a stalled convergence state, it activates a tree-of-thought search over the parameter space. The search proceeds in batches: at each batch , the LLM generates candidate parameter configurations , such as redoing macro placement or revising the power plan to reduce routing layer pressure, each accompanied by the corresponding EDA commands and evaluation queries. Each candidate is evaluated by saving a design checkpoint, applying the parameter modifications, executing the evaluation commands, and extracting the resulting metrics. The design is then restored to the checkpoint before the next candidate is evaluated.
The fitness of each candidate is computed as a stage-aware weighted score: , where denotes the metric set for stage , the stage-specific weight, and the normalized metric value. The best candidate becomes the starting point for batch . The search terminates when stage requirements are satisfied (e.g., DRC count = 0 for routing), the score improvement falls below threshold , or the batch budget is exhausted.
Iteration Tracking. A persistent MetricsDB records the full parameter to metric mapping across all iterations, including parameter provenance, capturing which agent modified which parameter and
the rationale behind each change. This trajectory data serves two purposes: it provides the Optimizer Agent with historical context for informed tuning decisions, and it enables post-hoc analysis of the DSO process for reproducibility and insight.
Experiments
We first describe the setup, including models, EDA tools, technology nodes, and server configuration. We then report the evaluation results, followed by a comparison against RAG-based method to further validate our proposed method.
Experimental Setup
Models. We evaluate both open-source and commercial LLMs. For open-source models, we select the multimodal model Qwen3-VL [4] in 8B and 30B parameter variants. For commercial models, we use GPT-4o [18], DeepSeek-V3 [28], Gemini-3.1-pro-preview [17], and GPT-5-Thinking [37], accessed via their respective APIs. All models are evaluated at a temperature of 0.1 unless otherwise specified.
EDA Tools. The primary goal of our work is to benchmark the capabilities of LLMs/VLMs for VLSI physical design, not to compare or rank different EDA tools. We use Cadence Innovus 22, Synopsys IC Compiler II (ICC2) 2022, Synopsys PrimeTime (PT) 2022, and Synopsys StarRC 2022 as our commercial EDA tools for implementation and signoff. Command-level differences across tool versions are minimal; we validate that our generated scripts are compatible with versions 2018 and 2020. Technology Nodes. For experiments using commercial EDA tools, we target the TSMC 28nm. Platform. All local models are deployed on a server equipped with 12 NVIDIA A6000 GPUs and an AMD EPYC 7313 CPU.
Evaluation on Atomic Task Suite
Evaluation results on OpenLayout-Bench atomic task suite are summarized in Table 2. Standalone LLMs perform poorly across all tools; for example, even the powerful Gemini 3.1-pro achieves only 18.9% on the Tool A task set and 19.3% on the Tool B task set, comparable to the much smaller Qwen3-VL-8B. We attribute this to the scarcity of EDA-related data in public corpora, as EDA tools and scripts are often proprietary and not widely available online. Upon investigating the failure cases, we find that many errors are minor in nature, such as syntax mistakes or incorrect parameter usage, suggesting that the models demonstrate basic domain awareness and generate structurally reasonable scripts, but lack the precise tool-level knowledge required for successful execution. This observation further underscores the value of targeted skill augmentation, as even small corrections can unlock substantially higher pass rates.
| Model | Tool A P@1 | Tool A P@5 | Tool B P@1 | Tool B P@5 | STA P@1 | STA P@5 |
| Qwen3-VL-8B | 0.122 | 0.156 | 0.136 | 0.182 | 0.182 | 0.364 |
| Qwen3-VL-30B | 0.089 | 0.156 | 0.102 | 0.205 | 0.273 | 0.364 |
| DeepSeek-V3 | 0.167 | 0.200 | 0.182 | 0.227 | – | – |
| GPT-4o | 0.167 | 0.211 | 0.205 | 0.239 | 0.364 | 0.454 |
| Gemini-3.1-pro | 0.189 | 0.222 | 0.193 | 0.216 | 0.636 | 0.727 |
| GPT-5-Thinking | 0.178 | 0.222 | 0.205 | 0.261 | 0.545 | 0.636 |
| RAG-DS | 0.556 | 0.622 | 0.591 | 0.614 | – | – |
| RAG-Gemini | 0.600 | 0.656 | 0.625 | 0.659 | 0.636 | 0.727 |
| OpenLayout-DS | 0.778 | 0.822 | 0.807 | 0.841 | – | – |
| OpenLayout-Gemini | 0.800 | 0.844 | 0.841 | 0.864 | 0.636 | 0.727 |
| OpenLayout-GPT5 | 0.789 | 0.822 | 0.818 | 0.852 | 0.545 | 0.636 |
Table 2. Evaluation on OpenLayout-Bench atomic task suite across 2 commercial place-and-route tools, anonymized as Tool A and Tool B (in arbitrary order), and one static timing analysis (STA) tool. Pass@1 and Pass@5 denote the success rate on the first and fifth attempt, respectively. The best result in each column is bolded. “–” indicates that results are unavailable due to the absence of multimodal input support in the corresponding model. Gemini and DS refer to Gemini 3.1-pro-preview and DeepSeek-V3, respectively.
Interestingly, standalone LLMs perform significantly better on the STA task set, which relies heavily on mathematical reasoning, indicating that these models possess strong general mathematical capability but lack domain-specific EDA knowledge. In contrast, OpenLayout substantially improves pass rates across all models and tools. For example, OpenLayout built on Gemini 3.1-pro achieves 84.4% on the Tool A task set and 86.4% on the Tool B task set, representing a relative improvement of > 4x over the standalone baseline. These results demonstrate that for domain-knowledge-intensive tasks such as physical design, an agentic framework equipped with domain-specific skills is essential.
Evaluation on Holistic Flow Suite
Evaluation results of OpenLayout on the OpenLayout-Bench holistic flow suite are summarized in Table 3, using Gemini 3.1-pro-preview as the backbone model. The results show that OpenLayout is capable of executing a holistic physical design flow end-to-end, performing self-iterative design space exploration, autonomously resolving DRC violations, and optimizing the design toward timing closure. The consistent performance across diverse designs demonstrates the generality of our method. On average, OpenLayout completes the full flow through 53 interactions with the EDA tools, reflecting the iterative nature of physical design optimization.
| Design | init | floorplan | powerplan | place | CTS | CTSopt | Route | Routeopt | Total tokens |
| TinyRISCV | 5ns, WNS: 1.362ns Setup successfully | Util: 0.65 DRC Vio: 0 | DRC Vio: 0 | WNS : -0.014ns DRC Vio: 0 Density: 0.715 | WNS : -0.127ns DRC Vio: 0 Density: 0.7165 | WNS : 0.001ns DRC Vio: 0 Density: 0.713 | WNS : 0.021ns DRC Vio: 1 Density: 0.722 | WNS : 0.021ns DRC Vio: 0 Density: 0.722 | 334K |
| Open910 | 1.5ns, WNS: 0.465ns Setup successfully | Util: 0.60 DRC Vio: 0 | DRC Vio: 0 | WNS : -0.05ns DRC Vio: 55 Density: 0.584 | WNS : -0.009ns DRC Vio: 2 Density: 0.653 | WNS : 0.001ns DRC Vio: 0 Density: 0.654 | WNS : -0.431ns DRC Vio: 127 Density: 0.703 | WNS : 0.008ns DRC Vio: 125 Density: 0.731 | 1.31M |
| Systolic array | 3.4ns, WNS: 1.11ns Setup successfully | Util: 0.5 DRC Vio: 0 | DRC Vio: 0 | WNS : 0.013ns DRC Vio: 0 Density: 0.464 | WNS : 0.003ns DRC Vio: 0 Density: 0.464 | WNS : 0.003ns DRC Vio: 0 Density: 0.464 | WNS : -0.312ns DRC Vio: 0 Density: 0.464 | WNS : 0.002ns DRC Vio: 0 Density: 0.466 | 232K |
| 16b pipelined mult. | 2.6ns, WNS: 0.808ns Setup successfully | Util: 0.55 DRC Vio: 0 | DRC Vio: 0 | WNS : 0.02ns DRC Vio: 0 Density: 0.625 | WNS : -0.008ns DRC Vio: 0 Density: 0.6289 | WNS : 0.012ns DRC Vio: 0 Density: 0.629 | WNS : 0.251ns DRC Vio: 0 Density: 0.629 | WNS : 0.251ns DRC Vio: 0 Density: 0.629 | 148K |
| AES-256 | 3.5ns, WNS: 1.003ns Setup successfully | Util: 0.60 DRC Vio: 0 | DRC Vio: 0 | WNS : 0.003ns DRC Vio: 0 Density: 0.613 | WNS : 0.006ns DRC Vio: 0 Density: 0.615 | WNS : 0.006ns DRC Vio: 0 Density: 0.615 | WNS : 0.12ns DRC Vio: 303 Density: 0.615 | WNS : 0.119ns DRC Vio: 0 Density: 0.615 | 264K |
| NVDLA-small | 2ns, WNS: 0.65ns Setup successfully | Util: 0.60 DRC Vio: 0 | DRC Vio: 0 | WNS : -1.06ns DRC Vio: 46 Density: 0.424 | WNS : 0.002ns DRC Vio: 0 Density: 0.554 | WNS : 0.002ns DRC Vio: 0 Density: 0.554 | WNS : -0.005ns DRC Vio: 21 Density: 0.556 | WNS : 0.002ns DRC Vio: 19 Density: 0.556 | 1.28M |
| NVDLA-large | 2.5ns, WNS: 0.69ns Setup successfully | Util: 0.60 DRC Vio: 0 | DRC Vio: 0 | WNS : -0.024ns DRC Vio: 68 Density: 0.487 | WNS : -0.145ns DRC Vio: 0 Density: 0.586 | WNS : -0.063ns DRC Vio: 0 Density: 0.594 | WNS : 0.021ns DRC Vio: 242 Density: 0.596 | WNS : 0.021ns DRC Vio: 85 Density: 0.598 | 1.62M |
| UART controller | 3.4ns, WNS: 1.108ns Setup successfully | Util: 0.65 DRC Vio: 0 | DRC Vio: 0 | WNS : 1.1ns DRC Vio: 0 Density: 0.782 | WNS : 1.4ns DRC Vio: 0 Density: 0.789 | WNS : 1.59ns DRC Vio: 0 Density: 0.789 | WNS : -0.445ns DRC Vio: 0 Density: 0.85 | WNS : -0.09ns DRC Vio: 0 Density: 0.85 | 132K |
| Elevator FSM | 2.5ns, WNS: 0.708ns Setup successfully | Util: 0.7 DRC Vio: 0 | DRC Vio: 0 | WNS : 0.703ns DRC Vio: 2 Density: 0.664 | WNS : 0.702ns DRC Vio: 2 Density: 0.665 | WNS : 0.703ns DRC Vio: 0 Density: 0.667 | WNS : 0.622ns DRC Vio: 0 Density: 0.667 | WNS : 0.622ns DRC Vio: 0 Density: 0.667 | 179K |
| Ethernet MAC | 10ns, WNS: 5.621ns Setup successfully | Util: 0.60 DRC Vio: 0 | DRC Vio: 0 | WNS : 5.62ns DRC Vio: 25 Density: 0.62 | WNS : 5.475ns DRC Vio: 23 Density: 0.624 | WNS : 5.47ns DRC Vio: 0 Density: 0.628 | WNS : 5.53ns DRC Vio: 69 Density: 0.624 | WNS : 5.53ns DRC Vio: 0 Density: 0.625 | 453K |
Table 3. Full-flow implementation of OpenLayout-Gemini on the holistic flow suite (TSMC 28nm). WNS and DRC violations are reported at each stage; positive WNS indicates timing closure. Utilization (Util.) is reported after floorplanning. The last column reports the total (input + output) LLM token consumption of the entire flow.
Our method performs well on small and medium-complexity designs, achieving timing closure with zero or minimal DRC violations at the final Routeopt stage. However, on larger and more complex designs such as NVDLA-large and Open910, residual DRC violations remain after Routeopt, and timing closure is not fully achieved in all cases. We attribute these limitations not only to the inherent complexity of the design space at advanced technology nodes, but also to the current lack of more sophisticated ECO and DRC fixing capabilities in our framework, which we identify as a promising direction for future work. We anticipate that future work building upon OpenLayout can achieve improved timing slack, higher utilization, cleaner DRC results, and reduced interaction overhead through more advanced optimization strategies.
Comparison Against RAG Baseline
We further evaluate two RAG-enhanced LLM baselines, which retrieve relevant content from EDA command reference manuals and physical design guidebooks, using Gemini 3.1-pro-preview and DeepSeek-V3 as backbone models for fair comparison. Atomic task suite results are summarized in Table 2 (RAG-DS and RAG-Gemini rows), and holistic flow suite results are reported in Table 4. Although RAG-enhanced methods improve over standalone LLMs, RAG-Gemini achieves 60.0% Pass@1 on Innovus compared to 18.9% for standalone Gemini, they still fall substantially short of OpenLayout, which achieves 80.0% Pass@1 on the same tool. For the holistic flow suite, the RAG-enhanced method fails to complete most designs beyond the first two stages. We attribute this performance gap to the highly structured and interdependent nature of physical design flows: each stage comprises multiple steps with precise tool-level syntax and context-specific requirements, which general-purpose retrieved documentation is too coarse-grained to fully capture. Unlike OpenLayout, which encodes actionable, stage-specific skills, the RAG-based approach lacks the procedural knowledge necessary to handle tool-specific errors, and adapt parameters across designs, and drive the flow to completion.
| Design | init | floorplan | powerplan |
| TinyRISCV | 5ns, WNS: 1.362ns Setup failed | Pin placement failed | Failed to use the correct layer |
| Open910 | 1.5ns, WNS: 0.465ns Setup failed | Pin placement failed | Failed to addRing |
| Systolic array | 3.4ns, WNS: 1.11ns Setup successfully | Pin placement failed | DRC Vio: 346 |
| 16b pipelined mult. | 2.6ns, WNS: 0.808ns Setup failed | Util: 0.65 DRC Vio: 0 | Missing Bottom and Top Power Rings |
| AES-256 | 3.5ns, WNS: 1.003ns Setup failed | Pin placement failed | Stripes Not Connected to Power Ring |
| NVDLA-small | 2ns, WNS: 0.65ns Setup failed | Pin placement failed | Missing Bottom and Top Power Rings |
| NVDLA-large | 2.5ns, WNS: 0.69ns Setup failed | Pin placement failed | Missing Bottom and Top Power Rings |
| UART controller | 3.4ns, WNS: 1.108ns Setup successfully | Util: 0.65 DRC Vio: 0 | Stripes Not Connected to Power Ring |
| Elevator FSM | 2.5ns, WNS: 0.708ns Setup successfully | Util: 0.7 DRC Vio: 0 | Stripes Not Connected to Power Ring |
| Ethernet MAC | 10ns, WNS: 5.621ns Setup failed | Pin placement failed | Missing Bottom and Top Power Rings |
Table 4. Early-stage physical design results using a RAG-based LLM method on the OpenLayout-Bench circuit suite (TSMC 28nm). Results cover the first three implementation stages: synthesis, floorplanning, and power planning. The RAG-based approach exhibits consistent failures across all stages, including setup errors, pin placement failures, and incomplete power networks, demonstrating its limited capability in automated physical design.
Limitations and Future Work
Limitations. Our platform currently covers the physical design workflow from initialization to ECO, but has several notable limitations. First, LVS (Layout versus Schematic) verification is not yet supported, leaving an important signoff step unaddressed. Second, DRC fixing remains incomplete, particularly for violations that require GUI-based interactions, which are difficult to automate through scripted flows. Third, our evaluation is currently limited to the TSMC 28nm technology node, which may not fully reflect performance across other process nodes. Finally, the OpenLayout-Bench suite would benefit from a broader collection of large-scale industrial VLSI designs to more comprehensively stress-test the framework.
Future Work. We plan to extend OpenLayout along several directions. First, we will expand technology node support beyond 28nm to include both advanced nodes (e.g., 16nm, 7nm) and mature nodes (e.g., 65nm, 130nm), enabling broader applicability. Second, we will enrich OpenLayout-Bench with larger and more complex VLSI designs to improve benchmark coverage and difficulty. Third, we will develop more fine-grained, stage-specific optimization skills and algorithms, such as automated macro placement and congestion-driven floorplanning.
Conclusion
In this work, we introduce OpenLayout, an open agentic platform for automated physical design, along with OpenLayout-Bench, a comprehensive benchmark suite for evaluating LLM agent capabilities at advanced technology nodes. OpenLayout supports a holistic physical design flow from initialization to Routeopt, enabling efficient iterative design space exploration, autonomous violation fixing, and timing closure across diverse circuit designs. Extensive experiments demonstrate that OpenLayout achieves SOTA performance, substantially outperforming both standalone LLMs and RAG-enhanced baselines. We hope that our work will inspire further research into agentic frameworks for fully automated physical design, encouraging the community to contribute additional benchmarks and domain-specific knowledge to advance the field.
Acknowledgments
This work is supported in part by NSF grants under OAC-2514071 and OAC-2613629.
References
References
- [1]Ahmed Abdelazeeem. 2021. Systolic Array Implementation in RTL for TPU. https://github.com/abdelazeem201/Systolic-array-implementation-in-RTL-for-TPU. Accessed: Apr. 2026.
- [2]Anthony Agnese, Puranjay Rajvanshi, Tian Yang, Geraldo Pradipta, Austin Jiao, Ben Keller, Brucek Khailany, and Haoxing Ren. 2023. Automdp: Automated dreamplace-based macro placement. In Proceedings of the 2023 International Symposium on Physical Design. 149–157.
- [3]Tutu Ajayi and David Blaauw. 2019. Openroad: Toward a self-driving, open-source digital layout implementation tool chain. In Proceedings of Government Microcircuit Applications and Critical Technology Conference.
- [4]Shuai Bai, Yuxuan Cai, Ruizhe Chen, Keqin Chen, Xiongchui Chen, Zesen Cheng, Lianghao Deng, Wei Ding, Chang Gao, Chunjiang Ge, et al. 2025. Qwen3-vl technical report. arXiv preprint arXiv:2511.21631 (2025).arxiv.org/abs/2511.21631
- [5]Cadence Design Systems. 2023. Innovus Implementation System: Delivering Better PPA at Advanced Nodes. Technical Report. Cadence Design Systems. https://www.cadence.com
- [6]Weidong Cao, Mouhacine Benosman, Xuan Zhang, and Rui Ma. 2022. Domain knowledge-infused deep learning for automated analog/radio-frequency circuit parameter optimization. In Proceedings of the 59th ACM/IEEE Design Automation Conference (San Francisco, California) (DAC ’22). Association for Computing Machinery, New York, NY, USA, 1015–1020. doi:10.1145/3489517.3503501DOI
- [7]Weidong Cao, Jian Gao, Tianrui Ma, Rui Ma, Mouhacine Benosman, and Xuan Zhang. 2025. SoSE-Opt: Robust and Efficient Analog Circuit Parameter Optimization With Knowledge-Infused Reinforcement Learning. IEEE Transactions on Computer-Aided Design of Integrated Circuits and Systems 44, 2 (2025), 627–640. doi:10.1109/TCAD.2024.3435692 [8] Chen Chen, Xiaoyan Xiang, Chang Liu, Yunhai Shang, Ren Guo, Dongqi Liu, Yimin Lu, Ziyi Hao, Jiahui Luo, Zhijian Chen, et al. 2020. Quantie-910: A commercial multi-core 12-stage pipeline out-of-order 64-bit high performance RISC-V processor with vector extension: Industrial product. In 2020 ACM/IEEE 47th Annual International Symposium on Computer Architecture (ISCA). IEEE, 52–64.
- [9]Quan Cheng, Qiufeng Li, Weirong Dong, Mingtao Zhang, Ruilin Zhang, Mingqiang Huang, Hao Yu, Yiyu Shi, Hiromitsu Awano, Takashi Sato, Longyang Lin, and Masanori Hashimoto. 2025. A 22nm Resource-Frugal Hyper-Heterogeneous Multi-Modal System-on-Chip Towards In-Orbit Computing. In 2025 IEEE Custom Integrated Circuits Conference (CICC). 1–3. doi:10.1109/CICC63670.2025.10983627DOI
- [10]Quan Cheng, Qiufeng Li, Zhengke Yang, Zhen Kong, Gaoqiang Niu, Yuan Liang, Jiamin Li, Jeong Hoan Park, Wang Liao, Hiromitsu Awano, Takashi Sato, Longyang Lin, and Masanori Hashimoto. 2025. A Radiation-Hardened Neuromorphic Imager with Self-Healing Spiking Pixels and Unified Spiking Neural Network for Space Robotics. In 2025 Symposium on VLSI Technology and Circuits (VLSI Technology and Circuits). 1–3. doi:10.23919/VLSITechnologyandCircuits61989.2025.11075180DOI
- [11]Quan Cheng, Longyang Lin, Mingqiang Huang, Qiufeng Li, Zhengke Yang, Liuyao Dai, Hao Yu, Yu-Jen Chen, Yiyu Shi, and Masanori Hashimoto. 2024. A 13-34 TOPS/W Edge-AI Processor Featuring Booth-Value-Confined Accelerator, Near-Memory Computing, and Contiguity-Aware Mapping. In 2024 IEEE Asian Solid-State Circuits Conference (A-SSCC). 1–3. doi:10.1109/A-SSCC60305.2024.10849341DOI
- [12]Quan Cheng, Zhengke Yang, Haoyuan Li, Qiufeng Li, Zhen Kong, Gaoqiang Niu, Yuan Liang, Jiamin Li, Jerald Yoo, Masanori Hashimoto, and Longyang Lin. 2026. A Radiation-Hardened Self-Healing CMOS Imager with Online Pixel/Logic Annealing and Tile-Adaptive Compression for Space Applications. In 2026 IEEE International Solid-State Circuits Conference (ISSCC), Vol. 69. 390–392. doi:10.1109/ISSCC49663.2026.11408995DOI
- [13]Vidya A Chhabria and Sachin Sapatnekar. 2021. Openpnd: A neural-network-based framework for power delivery network synthesis. IEEE Transactions on Computer-Aided Design of Integrated Circuits and Systems 41, 10 (2021), 3515–3528.arxiv.org/abs/2110.14184
- [14]Hezhao Dong, Weidong Cao, Muhan Zhang, Dacheng Tao, Yixin Chen, and Xuan Zhang. 2023. CktGNN: Circuit graph neural network for electronic design automation. arXiv preprint arXiv:2308.16406 (2023).
- [15]Jian Gao, Weidong Cao, Junyi Yang, and Xuan Zhang. 2025. AnalogGenie: A Generative Engine for Automatic Discovery of Analog Circuit Topologies. arXiv preprint arXiv:2503.00205 (2025).arxiv.org/abs/2503.00205
- [16]Jian Gao, Weidong Cao, and Xuan Zhang. 2025. AnalogGenie-lite: Enhancing scalability and precision in circuit topology discovery through lightweight graph modeling. In Forty-second International Conference on Machine Learning.
- [17]Google. 2025. A new era of intelligence with Gemini 3. https://blog.google/products/gemini/gemini-3
- [18]Aaron Hurst, Adam Lerner, Adam P Goucher, Adam Perelman, Aditya Ramesh, Aidan Clark, AJ Ostrow, Akila Welihinda, Alan Hayes, Alec Radford, et al. 2024. Gpt-4o system card. arXiv preprint arXiv:2410.21276 (2024).
- [19]Andrew B Kahng, Jens Lienig, Igor L Markov, and Jin Hu. 2011. VLSI physical design: from graph partitioning to timing closure. Vol. 312. Springer.
- [20]Joachim Kinder. 2014. AES: Verilog Implementation of the Advanced Encryption Standard (AES-256). https://github.com/secworks/aes. Accessed: Apr. 2026.
- [21]Yao Lai, Yao Mu, and Ping Luo. 2022. Maskplace: Fast chip placement via reinforced visual representation learning. Advances in Neural Information Processing Systems 35 (2022), 24019–24030.
- [22]Luciano Lavagno, Louis Scheffer, and Grant Martin. 2018. EDA for IC implementation, circuit design, and process technology. CRC press.
- [23]Qiufeng Li, Rongqian Chen, Quan Cheng, Chengkuan Wang, Sizhe Tang, Chia-Tung Ho, David Z Pan, Tian Lan, and Weidong Cao. 2026. PDAGENT-BENCH: Characterizing, Grounding, and Architecting LLM/VLM Agents for VLSI Physical Design. arXiv preprint arXiv:2606.17253 (2026).arxiv.org/abs/2606.17253
- [24]Qiufeng Li, Shu Hong, Tian Lan, and Weidong Cao. 2025. AnalogFed: Privacy-Preserving Discovery of Analog Circuits at Scale with Federated Generative AI. arXiv e-prints, Article arXiv:2507.15104 (July 2025), arXiv:2507.15104 pages. arXiv:2507.15104 [stat.ML] doi:10.48550/arXiv.2507.15104arxiv.org/abs/2507.15104
- [25]Kangnan Liang. 2020. TinyRISC-V: A Simple RISC-V Core. https://github.com/liangkangnan/tinyriscv. Accessed: Apr. 2026.
- [26]Yiwen Liang, Qiufeng Li, Shikai Wang, and Weidong Cao. 2025. When Forgetting Builds Reliability: LLM Unlearning for Reliable Hardware Code Generation. arXiv preprint arXiv:2512.05341 (2025).arxiv.org/abs/2512.05341
- [27]Yibo Li, Shounak Dhar, Wuxi Li, Haoxing Ren, Brueck Khailany, and David Z Pan. 2019. Dreamplace: Deep learning toolkit-enabled gpu acceleration for modern vlsi placement. In Proceedings of the 56th Annual Design Automation Conference 2019. 1–6.
- [28]Aixin Liu, Bei Feng, Bing Xue, Bingxuan Wang, Bochao Wu, Chengda Lu, Chenggang Zhao, Chengqi Deng, Chenyu Zhang, Chong Ruan, et al. 2024. Deepseek-v3 technical report. arXiv preprint arXiv:2412.19437 (2024).arxiv.org/abs/2412.19437
- [29]Shang Liu, Wenji Fang, Yao Lu, Jing Wang, 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 44, 4 (2024), 1448–1461.DOI
- [30]Yi-Chen Lu, Jehyun Lee, Anthony Agnesina, Kambiz Samadi, and Sung Kyu Lim. 2019. GAN-CTS: A generative adversarial framework for clock tree prediction and optimization. In 2019 IEEE/ACM International Conference on Computer-Aided Design (ICCAD). IEEE, 1–8.
- [31]Rod Metcalfe. 2021. Machine Learning-Driven Full-Flow Chip Design Automation. Accessed: Mar 1 (2021), 2024.
- [32]Azalia Mirhoseini, Anna Goldie, Mustafa Yazgan, Joe Wenjie Jiang, Ebrahim Songhori, Shen Wang, Young-Joon Lee, Eric Johnson, Omkar Pathak, Azade Nova, et al. 2021. A graph placement methodology for fast chip design. Nature 594, 7862 (2021), 207–212.
- [33]NVIDIA. 2017. NVDLA: Open Source Deep Learning Accelerator. https://github.com/nvdla/hw. Accessed: Apr. 2026.
- [34]OpenCores. 2001. Ethernet MAC 10/100 Mbps. https://opencores.org/projects/ethmac. Accessed: Apr. 2026.
- [35]Sauradip Poddar, Chia-Tung Ho, Ziming Wei, Weidong Cao, Haoxing Ren, and David Z Pan. 2025. HeaRT: A hierarchical circuit reasoning tree-based agentic framework for AMS design optimization. arXiv preprint arXiv:2511.29689 (2025).arxiv.org/abs/2511.19669
- [36]Yuhan Qin, Yuan Pu, Tairu Qiu, Zhuolun He, and Bei Yu. 2026. Infusing EDA Knowledge into LLM Systems: An Information-Source Perspective. In Proceedings of the 2026 International Symposium on Physical Design. 112–120.DOI
- [37]Aaditya Singh, Adam Fry, Adam Perelman, Adam Tart, Adi Ganesh, Ahmed El-Kishky, Aidan McLaughlin, Aiden Low, AJ Ostrow, Akhila Ananthram, et al. 2025. Openai gpt-5 system card. arXiv preprint arXiv:2601.03267 (2025).arxiv.org/abs/2601.03267
- [38]Synopsys Inc. 2022. Fusion Compiler Design Planning and Implementation. Technical Report. Synopsys. https://www.synopsys.com
- [39]Yuan Taur and Tak H Ning. 2021. Fundamentals of modern VLSI devices. Cambridge university press.
- [40]Ultra-Embedded. 2020. UART Controller IP Core. https://github.com/ultraembedded/cores. Accessed: Apr. 2026.
- [41]Piyush Verma. 2024. Aso. ai-distributed system to optimize physical design flows. In Proceedings of the 2024 International Symposium on Physical Design. 115–116.
- [42]Shikai Wang, Qiufeng Li, Houbo He, Jian Gao, Zining Wang, Yu Sun, Xuan Zhang, Taiyun Chi, and Weidong Cao. 2025. Multi-Agent Generative Synthesis for Analog/RF Circuit: from Scalable Topology Generation to Efficient Inverse Design. In 2025 IEEE/ACM International Conference on Computer-Aided Design (ICCAD). IEEE, 1–9.DOI
- [43]Neil H E Weste and David Harris. 2015. CMOS VLSI design: a circuits and systems perspective. Pearson Education India.
- [44]Haoyuan Wu, Zhuolun He, Xinyun Zhang, Xufeng Yao, Zu Zheng, Haisheng Zheng, and Bei Yu. 2024. ChatEDA: A large language model powered autonomous agent for eda. IEEE Transactions on Computer-Aided Design of Integrated Circuits and Systems 43, 10 (2024), 3184–3197.
- [45]Haoyuan Wu, Haisheng Zheng, Zhuolun He, and Bei Yu. 2025. Divergent thoughts toward one goal: Llm-based multi-agent collaboration system for electronic design automation. In Proceedings of the 2025 Conference of the Nations of the Americas Chapter of the Association for Computational Linguistics: Human Language Technologies (Volume 1: Long Papers). 1710–1721.
- [46]Zhiyue Xie, Yu-Hung Huang, Guan-Qi Fang, Haoxing Ren, Shao-Yun Fang, Yiran Chen, and Nvidia Corporation. 2018. RouteNet: Routability prediction for mixed-size designs using convolutional neural network. In Proceedings of the International Conference on Computer-Aided Design. 1–8.DOI
- [47]Ning Xu, Zhaoyang Zhang, Senlin Shu, Lei Qi, Jiaq i Lv, Wensuo Wang, Tianhao Zhao, Chao Zhang, Zhaoliang Yang, Xiangyu Li, et al. 2026. iScript: A Domain-Adapted Large Language Model and Benchmark for Physical Design Tcl Script Generation. arXiv preprint arXiv:2603.04476 (2026).arxiv.org/abs/2603.04476
- [48]Bei Yu. 2023. Machine learning in EDA: When and how. In 2023 ACM/IEEE 5th Workshop on Machine Learning for CAD (MLCAD). IEEE, 1–6.
- [49]Han Zhou, Wentian Jin, and Sheldon-X-D Tan. 2020. GridNet: Fast data-driven EM-induced IR drop prediction and localized fixing for on-chip power grid networks. In Proceedings of the 39th International Conference on Computer-Aided Design. 1–9.DOI



