Paper deep dive
SynAct: A Reasoning-Acting Large Language Model Agent for Adaptive Synthesis Optimization
Fangzhou Liu, Peiyi Han, Jiawei Liu, Yuan Pu, Zhuolun He, Rongliang Fu, Tsung-Yi Ho, Bei Yu
Intelligence
Status: succeeded | Model: Gemma-4-26B-A4B | Prompt: intel-v1 | Confidence: 92%
Last extracted: 8/17/2026, 3:52:04 AM
Summary
The paper introduces SynAct, an adaptive closed-loop Large Language Model (LLM) reasoning-acting agent designed for logic synthesis optimization. SynAct iteratively diagnoses live synthesis reports, retrieves relevant tool knowledge via a multi-layer GraphRAG module, and leverages historical optimization experience through Bayesian Optimization (BO) over a GrammarVAE latent space to issue targeted commands. Experiments on 14 designs using a commercial synthesis tool demonstrate that SynAct reduces average Worst Negative Slack (WNS) to 27% of that from bootstrap synthesis while maintaining balanced area and power trade-offs.
Entities (10)
Relation Signals (8)
SynAct → improves → WNS
confidence 95% · SynAct focuses on improving timing, particularly worst negative slack (WNS)
SynAct → optimizes → Logic Synthesis
confidence 95% · SynAct: A Reasoning-Acting Large Language Model Agent for Adaptive Synthesis Optimization
SynAct → reduces → WNS
confidence 95% · SynAct reduces average WNS to 27% of that from bootstrap synthesis.
SynAct → uses → GraphRAG
confidence 95% · SynAct ... mitigating information overload through a multi-layer GraphRAG module
SynAct → uses → Bayesian Optimization
confidence 95% · Bayesian optimization over a GrammarVAE latent space leverages historical optimization experience
Bayesian Optimization → operateson → GrammarVAE
confidence 90% · Bayesian optimization over a GrammarVAE latent space
GraphRAG → retrieves → Tool Knowledge
confidence 90% · GraphRAG module ... retrieves scenario-relevant command documentation on demand
SynAct → isbasedon → ReAct
confidence 85% · Built on ReAct [13] for coupled reasoning and action
Cypher Suggestions (0)
No Cypher suggestions yet.
Abstract
Abstract:Logic synthesis transforms RTL designs into gate-level netlists, where PPA results are highly sensitive to the choice of optimization commands, making synthesis tuning both high-dimensional and expensive. Previous approaches fall into two categories: automated methods, which perform black-box search over fixed action spaces with limited decision-level interpretability, and LLM-based methods, which typically generate static scripts upfront and cannot adapt to evolving circuit states. We present SynAct, an adaptive closed-loop LLM reasoning--acting agent that iteratively diagnoses live synthesis reports and reasons over the current circuit state, retrieved tool knowledge, and historical optimization experience to issue targeted commands. SynAct focuses on improving timing, particularly worst negative slack (WNS), while maintaining balanced area and power trade-offs. Experiments on a commercial synthesis tool across 14 designs show that SynAct reduces average WNS to 27% of that from bootstrap synthesis.
Tags
Links
- Source: https://arxiv.org/abs/2608.12751v2
- Canonical: https://arxiv.org/abs/2608.12751v2
Trouble viewing inline? Open PDF directly →
Full Text
67,818 characters extracted from source content.
Expand or collapse full text
SynAct: A Reasoning-Acting Large Language Model Agent for Adaptive Synthesis Optimization Fangzhou Liu,Peiyi Han,Jiawei Liu,Yuan Pu,Zhuolun He,Rongliang Fu,Tsung-Yi Ho,Bei Yu Abstract—Logic synthesis transforms RTL designs into gate- level netlists, where PPA results are highly sensitive to the choice of optimization commands, making synthesis tuning both high- dimensional and expensive. Previous approaches fall into two categories: automated methods, which perform black-box search over fixed action spaces with limited decision-level interpretabil- ity, and LLM-based methods, which typically generate static scripts upfront and cannot adapt to evolving circuit states. We present SynAct, an adaptive closed-loop LLM reasoning–acting agent that iteratively diagnoses live synthesis reports and reasons over the current circuit state, retrieved tool knowledge, and historical optimization experience to issue targeted commands. SynAct focuses on improving timing, particularly worst negative slack (WNS), while maintaining balanced area and power trade- offs. Experiments on a commercial synthesis tool across 14 designs show that SynAct reduces average WNS to 27% of that from bootstrap synthesis. Index Terms—Electronic design automation, large language models, logic synthesis, retrieval-augmented generation. I. INTRODUCTION L OGIC synthesis transforms RTL designs into gate-level netlists. As shown in Fig. 1, a typical flow com- prises translation, logic optimization, and technology mapping, where the latter two stages involve extensive algorithmic choices that commercial tools encapsulate into large com- mand sets with diverse configurable parameters. Prior studies show that the choice and ordering of commands significantly affect PPA outcomes [1], making synthesis tuning a high- dimensional and high-cost design-space exploration challenge. Among the PPA metrics, timing is particularly critical, as vio- lations can necessitate flow re-tuning and additional place-and- route iterations, thereby substantially prolonging the design cycle [2]. Prior work on logic synthesis flow optimization falls into two paradigms, as shown in the upper right of Fig. 1. The first treats synthesis tuning as combinatorial search over AIG- level operator sequences on ABC [3], with methods spanning manual tuning, reinforcement learning (RL) [4], Bayesian opti- mization (BO) [5], [6], Monte Carlo Tree Search (MCTS) [7], and bandits [8]. Although effective, these methods are confined Fangzhou Liu, Peiyi Han, Jiawei Liu, Yuan Pu, Zhuolun He, Rongliang Fu, Tsung-Yi Ho, and Bei Yu are with the Department of Computer Science and Engineering, The Chinese University of Hong Kong, Hong Kong SAR. Bei Yu and Rongliang Fu are the corresponding authors (e-mail: byu@cse.cuhk.edu.hk; rlfu@cse.cuhk.edu.hk). This work has been submitted to the IEEE for possible publication. Copyright may be transferred without notice, after which this version may no longer be accessible. Synthesis Flow RTL code Unoptimized IR Optimized IR Optimized Netlist Logic opt. Tech. mapping Fixed action set RL/BO/MCTS/Bandits action state reward Black-box decision Non-adaptive script No feedback loop Ours: SynAct Action Generation + Rationales LLM-based Reasoning Agent Follow-up Report Diagnostics Experience Refinement RAG Retrieval Prior work Translation LLM-based Flow Automation one-shot Fig. 1 Traditional synthesis flow vs. our LLM-based agent SynAct. “IR” denotes intermediate representation. to fixed action spaces, rely on black-box rewards, and provide limited interpretability regarding how their decisions relate to the current circuit state. These limitations become more pronounced on commercial tools with far richer command vocabularies. The second paradigm emerges from the growing use of large language models (LLMs) in EDA. Works such as ChatEDA [9], ChipNeMo [10], and ChatLS [11] generate complete Tcl scripts or command sequences for commercial tools directly from user intent and tool documentation, thereby avoiding a fixed action space. However, these end-to-end methods rely on “one-shot” generation and produce complete static scripts upfront. As a result, later commands cannot adapt to evolving circuit states after each command, potentially leading to suboptimal results. A key observation is that commercial synthesis tools support a continuous interaction model: the tool session remains open across commands, allowing an agent to issue commands and observe updated PPA reports after each iteration, making syn- thesis a natural fit for a closed-loop LLM agent. This suggests that rather than generating a script upfront or searching over a fixed action space, the agent should interact directly with the tool, diagnosing the current circuit state and retrieving relevant knowledge at each iteration to guide its next decision. However, two challenges arise: (1) at each iteration, the LLM must locate relevant content within extensive command doc- umentation, where irrelevant information can cause reasoning errors; (2) pure LLM reasoning lacks systematic reuse of prior experience, making it difficult to reuse commands proven 1 arXiv:2608.12751v2 [cs.AR] 14 Aug 2026 effective in previous iterations and leading to inefficient long- horizon exploration. To address these challenges, we present SynAct, an adap- tive closed-loop LLM reasoning–acting agent that iteratively optimizes PPA on a commercial synthesis tool, with partic- ular emphasis on WNS. At each iteration, SynAct condi- tions its decision on the latest timing reports and diagnostic outputs, mitigating information overload through a multi- layer GraphRAG module [12] that retrieves scenario-relevant command documentation on demand. To improve exploration efficiency, Bayesian optimization over a GrammarVAE latent space leverages historical optimization experience accumu- lated in earlier iterations. Built on ReAct [13] for coupled reasoning and action and AutoGen-style multi-agent collabora- tion [14] for role coordination, SynAct continuously interprets circuit feedback and produces each optimization command with an explicit rationale, as illustrated in Fig. 1. Our main contributions are as follows: 1) A closed-loop LLM agent that iteratively optimizes PPA by adapting decisions to the current circuit state. 2) A multi-layer GraphRAG module for scenario-relevant knowledge retrieval, mitigating information overload. 3) A BO-guided experience refinement mechanism over a GrammarVAE latent space for experience-guided explo- ration. 4) SynAct reduces average WNS to 27% of that from bootstrap synthesis while maintaining balanced area and power trade-offs. The remainder of this paper is organized as follows. Sec- tion I reviews the necessary background. Section I presents the SynAct framework, and Section IV details its knowledge- and experience-guidance modules. Section V provides a practi- cal example of the framework in operation. Section VI reports the experimental results, and Section VII concludes the paper. I. PRELIMINARIES A. Logic Synthesis Logic optimization and technology mapping are key stages in logic synthesis, respectively restructuring Boolean networks and mapping them to library cells under timing, area, and power constraints. Numerous algorithms have been proposed for these tasks [3]. Commercial synthesis tools offer a much richer command space that includes combinational and se- quential optimization, retiming, power-aware optimization, and physically aware synthesis [15]. These capabilities create a larger and more context-dependent action space that must be explored effectively to achieve high-quality PPA results. Because each command alters the circuit state and subse- quent actions rely on the updated netlist and PPA reports, syn- thesis optimization can be formulated as a Markov Decision Process (MDP) M = (X, A, F, R), forming the basis of our agent design. • X is the state space, where each state x t includes the current netlist, PPA summary, and detailed timing, area, and power reports. • A is the action space of executable synthesis commands. • F : X× A→ X is the transition function realized by the synthesis tool under fixed settings. • R : X× A →R is the reward function, which uses a weighted aggregation of WNS and other PPA metrics to capture timing, area, and power trade-offs. Bootstrap synthesis is the initialization flow that configures the technology library, reads and elaborates RTL, applies timing constraints, and runs the initial optimization. It excludes recipe-level tuning and yields the common initial state x 0 and reference PPA for all compared methods on each design. Starting from x 0 , the agent iteratively selects one command a t , executes it within the tool session, and observes the resulting reports as the next state x t+1 until the optimization target is met or the budget is exhausted. B. LLMs for EDA LLM-based EDA increasingly combines knowledge re- trieval with agentic tool interaction. Retrieval-Augmented Generation (RAG) [16] grounds generation in retrieved knowl- edge, and its retrieval models can be fine-tuned on EDA tool documentation to improve domain-specific retrieval [12]. Beyond retrieval, ReAct [13] interleaves reasoning and action so that observations inform later decisions. AutoGen [14] supports coordination among specialized agents through structured conversations in complex workflows. In practice, ChatEDA [9] decomposes user requests before generating and executing RTL-to-GDSII scripts, while ChipNeMo [10] com- bines domain adaptation and retrieval for tasks including EDA script generation. ChatLS [11] uses retrieved tool knowledge and chain-of-thought prompting to customize synthesis scripts, whereas LLSM [17] uses EDA-guided prompting to integrate circuit information extracted from RTL with structural fea- tures. These studies show that LLMs can retrieve domain knowledge, reason about design tasks, coordinate specialized agents, and invoke EDA tools, laying the foundation for SynAct’s closed-loop PPA optimization. I. SYNACT FRAMEWORK A. Overview The left side of Fig. 2 shows the overall flow. Given an RTL design and designer inputs, SynAct first performs bootstrap synthesis to establish the initial circuit state. It then iterates through LLM-guided command generation, optimization exe- cution, and termination checking until the request is satisfied or the iteration budget n iter is exhausted. The resulting netlist is then written out. The right side lists the designer inputs, including a request, the command manual, and environment variables. The request specifies the optimization preferences and quantitative PPA targets, while the manual and variables provide tool-specific information for command generation. SynAct can prioritize any selected PPA metric. In this work, we use WNS as the primary objective and treat the remaining metrics as secondary objectives. 2 SynAct Framework Overall Flow LLM-guided command generation Execute optimization Check if request satisfied or iteration ended Netlist output Bootstrap synthesis Analysis Agent Preprobe Prompt Update Reports Prompt Postprobe Prompt call llm analysis ************************************************************************** * Report : Timing * * Command : analyze_timing -nworst 1 * ************************************************************************** Beginpoint: cpsr_m_reg[4] (re-triggered flip-flop clocked by clk) Endpoint: reg_ans_reg[52] (re-triggered flip-flop clocked by clk) Path Group: clk Delay Type: max Point (Gate Type) Inc. Path ------------------------------------------------------------------------ clock clk (re) 0.00 0.00 clock tree delay (ideal) 12.00 12.00 cpsr_m_reg[4]/CLK (DFFASRHQNx1_ASAP7_75t_R) 0.00 12.00 R ........................................... reg_ans_reg[52]/D (DFFASRHQNx1_ASAP7_75t_R) 0.00 1053.36 R ------------------------------------------------------------------------ data required time 1032.51 data arrival time -1053.36 ------------------------------------------------------------------------ slack (VIOLATED) -20.85 original circuit PPA reports parse Command Manual Env. Variables Designer Request WNS: 0.0 #ps TNS: 0.0 #ps static_power: 6.0 #uW dynamic_power: 17.1 #mW area: 6651 #um² opt_preference: “WNS” User Guide optimize ?-mode mode_type? ?-incremental? ?-no_boundary_opt? init_tdopt -dontchange sweep_design -mapped init_tdopt -undo VariableDescription hdl_resource_s haring Operator resource sharing level during synthesis enable_sentine l_data_path Enable sentinel path for dynamic power reduction sta_case_analy sis_through_se quential_cell Case value propagation mode through sequential cells ...... optimize -mode timing -map_effort high -incremental GraphRAG-Based Knowledge Grounding preprocessing document retrieval scenario-driven construction graph "best_candidates": [ "id": "llm_i2_c0", "slack": -6.26, “cmd”: "optimize -mode timing -map_effort high -incremental", "summary": "Best overall; stable timing improvement.”], "failed_candidates": [ "id": "llm_i2_c3", "slack": -146.53, “cmd”: "fix_fanouts -limit 32", "reason": "slack_drop>20.0", "summary": "Over-aggressive fanout fix degraded timing."], "key_insights": [ "Best command: incremental timing optimization (c0).", "Safe timing-driven methods outperform aggressive fixes."] LLM sample output "summary": "Timing failure: WNS -8.5, worst path cpsr_m_reg[4]-> reg_ans_reg[52].", "recommended_reports": [ "cmd": "analyze_clock_timing -type latency -clock clk", "why": "Check clock latency/skew impact.", "cmd": "analyze_net -transition u32084/Y u31936/Y", "why": "Check transition on critical nets."] "summary": "Critical path violation:cpsr_m_reg[4] ->reg_ans_reg[52] (-20.85ns).", "module_hypotheses": [ "object": "cpsr_m_reg[4] -> reg_ans_reg[52]", "hypothesis": "High fanout causes deep buffer chain", "evidence": "Multiple 2-4 stage chains observed", "object": "u32084/u37829", "hypothesis": "Wide fanin gates are local delay bottlenecks", "evidence": "Large gate delay contribution”.], "strategies": [ "Reduce fanout load","Restructure wide gates", "Rebalance/resize buffer chain" ] call llm call llm Candiate Selection update support Optimization Agent extraction CMD NAMEARG FLAG VA L optimize -incremental select best and decode BO-Guided Experience Refinement latent encoding surrogate fitting latent decoding retime_register ... trust region update evaluate & RTL design and designer inputs Fig. 2 The overall framework of SynAct. The center of Fig. 2 details three main components of SynAct. Inspired by ReAct [13], the Analysis Agent examines the current reports and produces a diagnosis. The Optimization Agent combines this diagnosis with retrieved tool knowledge and historical experience to generate command candidates. Candidate Selection chooses the best safe command from the evaluated candidates for execution. Executing the command updates the circuit state, and the resulting reports inform the next iteration, forming a closed reasoning–acting loop. The following subsections detail these three components. B. Analysis Agent Existing search-based methods guide optimization primarily using scalar PPA summaries [5], [6], [8], but these summaries provide limited information, making it difficult to uncover the circuit-level causes of PPA violations. SynAct therefore introduces an Analysis Agent that inspects detailed timing, area, and power reports to diagnose potential performance bottlenecks through two stages: Preprobe and Postprobe. In Preprobe, the agent parses raw report logs of the current design to identify performance bottlenecks. When the available data lacks sufficient detail, it proactively constructs follow-up probes using analyze_ * commands described in the tool documentation to obtain the necessary information. For precise and context-aware diagnosis, the agent is guided to generate targeted commands for specific design objects such as clock domains, timing constraints, circuit instances, or buffer chains through the following prompt: System: role = analysis agent (PREPROBE); diagnose root causes and propose analyze_ * probes; prefer object-level Tcl- braced probes User: user request, current/previous metrics, raw report log, and preprobe policy Expected JSON: summary, recommended probes A typical output may include probes such as: analyze_clock_timing -type latency analyze_inst -pin... analyze_buffer_chain -from... In Postprobe, the outputs collected by executing the probes from the previous stage are incorporated into the user prompt to help the agent refine its diagnosis. The refined result is then returned as a structured diagnosis that forms part of the Optimization Agent’s input. For example, it may conclude that one path group dominates the timing bottleneck and that the next actions should focus on buffer optimization, cell sizing, or local restructuring under area and power guardrails. The corresponding Postprobe prompt is: System: role = analysis agent (POSTPROBE); refine diagnosis using collected probe evidence User: user request, raw report text, extra analysis reports ExpectedJSON:summary,goals,violations, module hypotheses, suggestedstrategies, reflection C. Optimization Agent The Optimization Agent takes the structured diagnosis and user request as input and generates executable synthesis command candidates. This constitutes our second key design: 3 rather than optimizing over a small fixed action set, SynAct performs context-aware command generation within a large, structured command space. This generation process is sup- ported by two complementary guidance modules, which are detailed in Section IV: • RAG-grounded candidates C RAG , which are derived from scenario-relevant manual sections retrieved by GraphRAG; • BO-seeded candidates C BO , which adapt historically effective command patterns with minimal syntax changes. By combining these sources, the agent generates commands that reflect the current diagnosis while leveraging retrieved knowledge and prior experience. Each candidate is accom- panied by a concise rationale. The corresponding structured prompt is: System: role = optimization agent; generate command candidates User: user request, Postprobe diagnosis, RAG-retrieved manual sections, BO seed recommendation Expected JSON: recommendedcandidates, rationale D. Candidate Selection Given the candidates produced by the Optimization Agent, SynAct first performs safety filtering, removing those whose WNS falls beyond a preset threshold (e.g., −20 ps) or whose reward drops below 0.2 × r boot , where r boot is the initial reward from bootstrap synthesis. Among the remaining safe candidates, it then selects the one with the highest score (defined below). If no candidate passes filtering, the previous checkpoint is retained. Each candidate command C is evaluated by the score score(C) = r(C) + κσ(z)− ρ(C),(1) where r(C) is the reward measuring objective satisfaction, κ controls exploration strength, and ρ(C) penalizes recent repetitions (waived for large WNS improvements). Here σ(z) represents a local uncertainty estimate from the BO surrogate at latent point z, encouraging exploration of under-explored regions. All candidates, whether from C BO or C RAG , are encoded into this shared latent space, enabling the surro- gate to generalize learned experience and provide consistent exploration guidance across both sources. The latent space and surrogate model are detailed in Section IV-B. This score balances high reward, moderate exploration, and redundancy avoidance. The reward r ∈ (0, 1] aggregates violations across all objectives: r = exp − X i w i log(1 + err i ) ! ,(2) err i = max(0, target i − metric i ), i∈WNS, TNS, max(0, metric i − target i ) |target i | , i∈area,P dyn ,P stat , (3) Optimization Commands Optimization Scenarios create_clock set_max_delay set_area_target set_power_opt set_leakage Timing Opt. Area Opt. Power Opt. Configurable Variables clock_period max_fanout area_effort power_mode vth_range Intra-layer Inter-layer Fig. 3 Three-layer structure of the proposed GraphRAG framework. The optimization scenario layer (center) connects related commands (left) and configurable variables (right), forming inter- and intra-layer relationships. where target i is the user-specified target and metric i is the current measured value. Timing metrics (WNS, TNS) are max- imized, while area and power are minimized and normalized by target magnitude. The log(1+err i ) term compresses large violations to reduce their influence in the aggregate reward. Each weight w i is assigned a base value, upweighted for the user-selected primary objective, and then normalized to ensure P i w i = 1. Thus r = 1 when all targets are met and decreases faster for larger or higher-priority violations. IV. KNOWLEDGE- AND EXPERIENCE-GUIDED OPTIMIZATION The Optimization Agent is supported by two complemen- tary modules shown in Fig. 2: GraphRAG grounds candidate generation in scenario-relevant tool knowledge, while BO reuses historical synthesis experience in a GrammarVAE latent space. This section details these two modules. A. GraphRAG-Based Knowledge Grounding The Optimization Agent requires precise, context-aware domain knowledge to generate effective synthesis commands. A natural approach is to retrieve relevant documentation via RAG; however, forming effective synthesis strategies requires connecting applicable scenarios, specific commands, and con- figurable variables scattered across disparate documentation sections. This structured, multi-hop reasoning process goes beyond the ability of traditional vector-similarity retrieval. To address this, we develop a multi-layer GraphRAG module that unifies graph-based reasoning and retrieval augmenta- tion [18], [19], detailed in the following four parts. Document Preprocessing. Building the GraphRAG module begins with extracting relevant content from the synthesis tool documentation. We manually curate document sections related to optimization commands and categorize them into three functional roles: 1) Applicable scenarios: describe design goals (e.g., timing, area, power) with typical associated commands and vari- ables; 4 2) Executable commands: define specific tool operations, including syntax, structure, and invocation patterns; 3) Configurable variables: specify tunable parameters, valid ranges, and default configurations. This taxonomy follows practical EDA usage: optimizations are scenario-driven, executed through commands, and tuned by variables. Based on this categorization, we organize the extracted content into a three-layer graph of scenarios, com- mands, and variables. Entity and Relationship Extraction. An LLM is prompted to convert the unstructured text into structured entities be- longing to the three layers defined above. We introduce three disjoint sets of entities corresponding to the three layers, where E S = s 1 ,s 2 ,...,s n S , E C = c 1 ,c 2 ,...,c n C , and E V = v 1 ,v 2 ,...,v n V represent scenarios, commands, and variables, respectively. The semantic structure of the knowledge graph is built through two complementary processes: intra-layer and inter- layer relationship identification. For intra-layer relationships, we use an LLM-based identification function to detect seman- tic connections within a single layer, defined as follows: R (intra) = R C ∪ R V V ,(4) R C =(c i ,c j ,r ij )| c i ,c j ∈ E C , LLM rel (c i ,c j ) = True, (5) R V V =(v i ,v j ,r ′ ij )| v i ,v j ∈ E V , LLM rel (v i ,v j ) = True. (6) Here, LLM rel (·,·) determines whether two entities share a semantic dependency based on their descriptions and usage patterns. For inter-layer relationships, scenarios are linked to related commands and variables that co-occur in documentation ex- amples, formalized as follows: R (inter) = R SC ∪ R SV ,(7) R SC =(s,c)| s∈ E S , c∈ E C , c∈ C (cmds) s ,(8) R SV =(s,v)| s∈ E S , v ∈ E V , v ∈ C (vars) s .(9) A link (s,c) or (s,v) is established when the LLM identi- fies co-occurrence between scenario s and the corresponding command or variable in application examples. Hierarchical Knowledge Graph Construction. Based on the extracted entities and relations, we construct a hierarchical knowledge graph defined as: G = (E, R),(10) where E = E S ∪E C ∪E V denotes the set of all entities, which is partitioned into disjoint subsets of scenarios, commands, and variables, and R = R (intra) ∪ R (inter) represents intra-layer and inter-layer relations. The scenario layer acts as the central hub connecting the command and variable layers, providing the foundation for subsequent reasoning and retrieval, as illustrated in Fig. 3. Scenario-Driven Retrieval. Before retrieval, the Analysis Agent diagnoses optimization bottlenecks and generates an analysis report A, which serves as the input query. Given A, GraphRAG retrieves relevant synthesis knowledge via four compact steps: 1) Scenario description generation: An LLM summarizes an optimization scenario description d scene from A. 2) Semantic embedding: scenario description d scene and scenario entity s are encoded into vectors using a domain- customized text embedding model [12], fine-tuned on EDA tool documentation via supervised contrastive learn- ing. This model better captures EDA terminology and semantics than general-purpose embeddings, ensuring all entities/descriptions in GraphRAG share a consistent EDA-aware vector space for precise retrieval. 3) Scenario selection: Top-k relevant scenarios are retrieved by semantic similarity: S ∗ = arg max S⊆E S ,|S|=k X s∈S sim(Embed(d scene ), Embed(s)). (11) 4) Knowledge expansion: Retrieve commands and variables directly connected to S ∗ as the initial associated set C 0 /V 0 , and further retrieve their top-k intra intra-layer neighbors via k-nearest neighbor (KNN) to form the final expanded set. Specifically: C 0 = c | (s,c) ∈ R SC , s ∈ S ∗ , C ∗ = C 0 ∪ KNN(C 0 ,k intra ), (12) V 0 = v | (s,v) ∈ R SV , s ∈ S ∗ , V ∗ = V 0 ∪ KNN(V 0 ,k intra ). (13) Here, k intra denotes the number of intra-layer neighbors retrieved for each seed entity. The final retrieved knowledge set is K = S ∗ ∪ C ∗ ∪ V ∗ , providing the Optimization Agent with concise, scenario- specific, non-redundant EDA synthesis knowledge. The hierarchical GraphRAG mechanism tightly couples knowledge grounding with design diagnosis, which allows the Optimization Agent to leverage structured, reliable synthesis knowledge for improved reasoning accuracy and decision reliability. B. BO-Guided Experience Refinement Commands validated in earlier iterations provide design- specific evidence for promising optimization directions [5], [6], [8]. Inspired by this, the Optimization Agent reuses executed commands and their feedback as experience. In practice, reapplying a previously effective command can yield further gains and sometimes outperform one newly generated from retrieved documentation. This motivates an experience- guided search based on Bayesian optimization (BO), which uses accumulated evaluations to efficiently identify promising commands. Applying BO directly to discrete command strings remains inefficient because the search space is large and similar com- mands can exhibit different optimization behavior. Inspired by 5 Latent space 풵 trust region 풯 optimize -mode timing -incremental ε SCRIPT CMD GENERIC CMD_NAME GEN_ARGS GEN_ARG GEN_ARGS -modetiming -incremental FLAG VA L GEN_ARG FLAG Parse and extract rules optimize encode decode z best z best z next z next Fig. 4 GrammarVAE encoding and latent-space BO. A com- mand is parsed into a grammar tree and encoded into latent space Z; BO then identifies z best and proposes z next within the trust region T, which is decoded back into a command recommendation for the Optimization Agent. Algorithm 1 BO-Guided Experience Refinement Input: Experience log D, trust region T, last commit reward r prev , diagnosis Φ, RAG docs R Output: Updated log D ′ , updated trust region T ′ , BO seed ˆ C BO 1: /* Surrogate Fitting */ 2: w i ← min(w max , 1+λ max(0,r i )) for each (z i ,r i )∈ D 3: Refit RBF surrogate on D to obtain μ(z), σ(z) 4: /* UCB Acquisition and Latent Decoding */ 5: Sample pool P⊂ T 6: z next ← arg max z∈P [μ(z) + κ acq σ(z)] 7: ˆ C BO ← Dec(z next )▷ GrammarVAE decode 8: C← OptAgent( ˆ C BO , Φ, R) 9: /* Evaluation and Trust Region Update */ 10: D ′ ← D 11: for C ∈ C do 12:Execute C; record r(C) 13: z ← Enc(Norm(C))▷ GrammarVAE encode 14:D ′ ← D ′ ⊕ (z,r(C))▷ ⊕: insert or replace 15: end for 16: C safe ←C ∈ C| C passes safety filter ▷ Section I-D 17: C ⋆ ← arg max C∈C safe score(C)▷ see Equation (1) 18: z best ← Enc(Norm(C ⋆ )) 19: Recenter T ′ on z best ; expand if r(C ⋆ ) > r prev , else shrink 20: return (D ′ , T ′ , ˆ C BO ) grammar-based VAEs that map discrete grammatical structures into continuous spaces [20], [21], we adapt GrammarVAE to encode synthesis commands for BO. This representation enables smooth optimization while preserving syntactic valid- ity [22]. BO then iteratively fits a surrogate model, proposes and evaluates candidates, and updates its data to focus on empirically effective regions. Latent Encoding. Each synthesis command C is normal- ized by Norm(·) and encoded into a latent vector z = Enc(Norm(C)) ∈R d via the GrammarVAE encoder [20], where z is a point in latent space Z⊆R d . As shown in Fig. 4, a command is first parsed into a context-free grammar tree, then compressed into z, such that nearby points in Z corre- spond to grammatically similar commands. Because synthesis- command syntax encodes the optimization mode, transforma- tion scope, effort level, and parameter configuration, these grammar-preserving neighborhoods provide a structured local prior that BO calibrates with measured synthesis rewards. GrammarVAE is pre-trained offline on a corpus of synthesis commands using the standard VAE objective (reconstruction and KL regularization); during BO, each command is mapped to the encoder’s posterior mean for a consistent latent repre- sentation. Definition 1 (Trust Region T). BO limits its search to an axis- aligned trust region T ⊆ Z, centered at the latent point of the current best command z best , to focus optimization on the most promising area. The radius of T adapts across iterations: it expands when performance improves and shrinks otherwise. Definition 2 (Experience Log D). The experience log D = (z i ,r i ) N i=1 stores the latent encoding and reward of each executed command C i , with z i = Enc(Norm(C i )) and r i defined in Equation (2). During bootstrap synthesis, D is initialized from the default optimize command, and T is centered at its latent point. Algorithm 1 illustrates how the refinement procedure is executed within one iteration: it takes D, T, last commit reward r prev , the Analysis Agent’s diagnosis Φ, and RAG- retrieved documents R as input, and returns updated D ′ , T ′ , and BO seed ˆ C BO . Surrogate Fitting. At each iteration, a reward-weighted RBF surrogate [23] is refit from scratch on the full D (lines 2– 3). Each observation (z i ,r i ) is assigned a weight w i = min(w max , 1 + λ max(0,r i )), where λ ≥ 0 scales how aggressively positive rewards upweight a point in the fit and w max caps each w i , so that high-reward regions receive greater influence while no single sample dominates. The surrogate estimates the expected reward and local uncertainty through kernel-weighted averages: μ(z) = P i w i K(z,z i )r i P i w i K(z,z i ) , σ 2 (z) = P i w i K(z,z i )[r i − μ(z)] 2 P i w i K(z,z i ) , (14) where K(z,z i ) = exp(−∥z − z i ∥ 2 /2ℓ 2 ) is the RBF kernel. The resulting σ(z) is smoothed and clipped for numerical stability and serves as the local uncertainty estimate used by the commitment score described in Section I-D. UCB Acquisition and Latent Decoding. BO samples a pool P ⊂ T and selects the next latent point by maximizing the UCB acquisition function [24] (lines 5–6): α(z) = μ(z) + κ acq σ(z),(15) where μ(z) exploits known high-reward regions and κ acq σ(z) promotes exploration of regions with high local uncertainty. The selected z next is decoded by GrammarVAE into a com- mand string ˆ C BO (line 7) and passed to the Optimization Agent as the BO seed recommendation. While GrammarVAE 6 decoding enforces grammatical validity, the decoded com- mand may still contain tool-level errors (e.g., unsupported flags or invalid parameter ranges). The Optimization Agent retains ˆ C BO as an explicit conditioning input and refines it with retrieved tool documentation to produce C BO , while independently generating C RAG from the retrieved knowledge; together they form the full candidate set C = C BO ∪ C RAG (line 8). Evaluation and Trust Region Update. All candidates in C are executed from the same parent checkpoint and their rewards recorded (lines 11–12). Each candidate is then re- encoded and logged into D ′ (lines 13–14), including those that fail or yield poor results, as broader latent-space coverage helps BO distinguish effective from ineffective regions and improve future proposals. The committed command C ⋆ is selected by first filtering C for safe candidates C safe (line 16), and then maximizing the score function score(C) defined in Equation (1) (line 17). The trust region T ′ is recentered on z best = Enc(Norm(C ⋆ )) and expanded if r(C ⋆ ) > r prev , otherwise shrunk (lines 18–19). V. RUNNING EXAMPLE To illustrate the practical use of SynAct, Fig. 5 presents a five-iteration run on arm9. Starting from the initial synthesis report, SynAct follows a reasoning, acting, and observation loop. At each iteration, the LLM interprets the tool feedback, explains the optimization intent, and produces an executable Tcl command. After execution, the updated circuit state is reflected in new synthesis reports, which serve as observations for the next iteration. In the first two iterations, the LLM follows BO guidance and selects incremental timing optimization to limit changes to the current implementation. It then uses updated timing observations and retrieved tool knowledge to select tdopt, register retiming, and phase assignment. The figure records the reasoning, committed command, and PPA observation at each iteration. Over the five iterations, WNS changes from −20.85 ps to −3.70 ps. VI. EXPERIMENT A. Experimental Setup All experiments are conducted on a workstation equipped with an Intel® Xeon® Gold 6226R CPU (2.90 GHz) and an NVIDIA GeForce RTX 3090 GPU. SynAct is implemented in Python with PyTorch for neural modules and connects to large language models via an OpenAI-compatible API supporting both commercial and internal endpoints. It integrates with AltiSyn ® , the commercial logic synthesis tool from ZeniSyn Design Systems [25], for automated command execution and report collection. The synthesis flow employs the standard-cell library from the 7 nm ASAP7 edge-cut PDK [26]. SynAct is implemented as a multi-agent system comprising an Analysis Agent for report-driven diagnosis and an Opti- mization Agent for command generation. The Optimization (Example) SynAct Optimization Trajectory of casearm9(k=5) Bootstrap synthesis Reasoning:Bootstrap phase: Initial design setup and baseline transformation via a default optimize. Act 0:set db_path ...; set rtl_path ...; read_db ...; read_design ...; create_clock -period 1050 ...; verify_design; optimize Obs 0:wns=-20.85, tns=-419.62, area=2031.81,P dyn =1.821mW,P static =2.078μW Iteration 1 Reasoning:BO-guided incremental timing optimization with high mapping effort to address the critical timing violation while minimizing disruption to the current implementation. Act 1:optimize -mode timing -map_effort high -incremental Obs 1:wns=-8.50, tns=-118.71, area=2031.61,P dyn =1.816mW,P static =2.072μW Iteration 2 Reasoning:BO-recommended incremental timing optimization with high mapping effort to improve timing without major structural changes. This conservative approach maintains current structure while focusing on timing-critical paths. Act 2:optimize -mode timing -map_effort high -incremental Obs 2:wns=-6.26, tns=-65.84, area=2029.78,P dyn =1.815mW,P static =2.065μW Iteration 3 Reasoning:RAG-guided: Focused critical path optimization usingtdoptwith high effort and area constraint. The analysis shows a specific critical path with multiple high-incidence cells that need aggressive timing optimization. Act 3:tdopt -flat -resyn2 -area 1.000000 Obs 3:wns=-4.03, tns=-41.65, area=2035.0,P dyn =1.818mW,P static =2.078μW Iteration 4 Reasoning:RAG-guided sequential retiming optimization. Attempts register retiming to im- prove timing by moving registers across combinational logic, which could help reduce the long critical path identified in the analysis. Act 4:retime_register -period 0 -effort high Obs 4:wns=-3.85, tns=-39.64, area=2038.9,P dyn =1.820mW,P static =2.100μW Iteration 5 Reasoning:RAG-guided candidate: Phase assignment optimization for timing recovery, par- ticularly effective for buffer-heavy designs. This can help optimize signal phases in the complex buffer chains identified in the analysis. Act 5:phase_assign -flat -mode timing -effort medium Obs 5:wns=-3.70, tns=-37.42, area=2038.79,P dyn =1.819mW,P static =2.100μW Fig. 5 An actual SynAct run on arm9, showing the reasoning, committed action, and tool observation at each iteration. Agent performs Bayesian optimization in a GrammarVAE latent space to efficiently explore discrete synthesis commands and utilizes a Neo4j-based multi-layer GraphRAG module for structured knowledge retrieval. Semantic retrieval within this module uses the transformer model fine-tuned for EDA documentation in [12]. For evaluation, we use 14 open-source RTL designs col- lected from OpenCores [27]. TABLE I summarizes the bench- mark statistics obtained after importing each design and running a bootstrap synthesis pass, including the number of nets, leaf, sequential, buffer, and inverter cell instances, and the configured clock period (CPD). Appropriate clock periods are assigned according to design size and fixed across all methods to ensure sufficient optimization margin. Across all experiments, we set WNS as the primary optimization objective, with quantitative targets specified at the input stage (a configuration example is shown in Fig. 2). Additionally, we track TNS, area, dynamic power, and static power as secondary metrics to assess overall PPA quality. To account for stochastic variation, each experiment is repeated five times, and the average results are reported unless otherwise specified. 7 TABLE I Benchmark statistics. Benchmarks#Nets#Leaf#Seq.#Buf.#Inv.CPD. 1 uart1655030573006605143336310 picorv32919390911556268688390 yacc105041036311024871285560 aescore11816115575305211091365 wb2axip125391138119002571221335 wbconmax18170170407704921354365 arm91926719195122282326341050 sha3249272416129496742903365 spimaster383653831387058623909320 ethernet44765446371054310973390385 ecg5361353071767611167807340 linkruncca69138691341660617204879480 xgemac815648135821667295896135 fft25619898119889742432312921095490 1 CPD: Clock period (ps). TABLE I Original PPA metrics after bootstrap synthesis. BenchmarksWNS(ps)TNS(ps)Area (μm 2 )DP (mW) 1 SP (μW) 2 uart16550-7.45-10.10400.941.5720.392 picorv32-15.70-3132.971128.683.5291.248 yacc-26.86-1592.031153.774.0951.300 aescore-8.03-482.041192.063.6951.316 wb2axip-20.54-12344.791325.095.1581.169 wbconmax-11.35-3840.851698.474.3991.481 arm9-20.85-419.622031.811.8212.078 sha3-14.41-3446.742892.5017.9302.874 spimaster-16.96-151.505459.9811.2906.182 ethernet-9.83-213.096435.6823.4807.433 ecg-5.04-205.585873.9622.7605.765 linkruncca-41.40-146498.4410380.1428.33012.290 xgemac-5.86-43.8612747.577.55614.090 fft256-17.14-550.5326638.8172.63031.600 Ratio Avg.100.00%100.00%100.00%100.00%100.00% 1 Dynamic Power. 2 Static Power. B. Overall PPA Improvement Comparison setup and method reproduction. TABLE I reports the PPA metrics after the mandatory bootstrap syn- thesis, which configures the technology library and timing constraints, reads and elaborates each RTL design, and runs the default optimize command without additional recipe- level tuning. These metrics serve as the reference for subse- quent comparisons. The “Ratio Avg.” is the mean of the per- design ratios between each method and bootstrap synthesis. Each ratio is computed by dividing the method result by its bootstrap value. For WNS and TNS, the reported value is first converted to its violation magnitude, max(0,−slack), so timing closure contributes zero. A lower “Ratio Avg.” indicates greater improvement. TABLE I compares two baselines representing distinct paradigms of synthesis optimization. We set SynAct’s iteration limit to n iter = 5. To control optimization depth, all methods commit five actions, each consisting of a command or com- mand sequence. This equalizes the committed-action budget but not the oracle-query budget, because the methods require different numbers of candidate evaluations, as detailed below. We therefore report the end-to-end runtime in TABLE IV alongside the PPA results. ChatLS [11] is an LLM-based end-to-end script customiza- tion method that combines multimodal RAG and chain-of- thought reasoning. As its one-shot script cannot use feedback from intermediate synthesis results, it provides a natural coun- terpart to SynAct’s iterative optimization. Since its source code is unavailable, we reproduce ChatLS following the published methodology. Under its original seven-benchmark 45 nm FreePDK setup, our reproduction matches every reported result within 5%. We then port it without further tuning to our 14-design setup using ASAP7 and AltiSyn ® , retaining the same prompts, retrieval configuration, and five-step script. The resulting comparison represents our controlled reproduction rather than the official implementation. CBTune [8] is a LinUCB-based contextual bandit method originally developed for synthesis sequence generation in ABC [3]. We reproduce it using its public implementation. 1 Unlike ChatLS and SynAct, LinUCB requires predefined, enumerable arms for reward estimation and action selection, so adapting CBTune to AltiSyn ® requires bounding the tool’s much larger command space. We manually construct the seven entries in TABLE V from documented AltiSyn ® commands and the optimization categories used by CBTune onABC. They cover timing optimization, mapping, sizing, phase as- signment, retiming, and resynthesis, and remain fixed across all 14 benchmarks without design-specific tuning. At each of five steps, CBTune evaluates the arms, updates LinUCB using short- and long-term rewards, and applies the selected arm. SynAct performs five sequential iterations without a fixed action list, enabling it to reason over a broader command space than CBTune. In each iteration, the Analysis Agent diagnoses the latest synthesis reports, and the Optimization Agent com- bines this diagnosis with GraphRAG-retrieved documentation and BO-based experience to generate ten candidates. After synthesis evaluation, SynAct commits the best safe command to optimize the circuit and feeds the updated reports into the next iteration. Both agents use DeepSeek V3.1. Optimization results with WNS as the primary objective. As shown in TABLE I, with WNS as the primary opti- mization objective, SynAct achieves the best overall timing improvement among all methods. In terms of “Ratio Avg.”, SynAct reduces the remaining WNS violation to 27.03% of that from bootstrap synthesis, substantially outperforming ChatLS [11] (71.73%) and CBTune [8] (66.67%). It achieves nonnegative WNS on two designs, whereas neither baseline does. Notably, for wb2axip, SynAct achieves WNS of -6.78 ps versus -9.23 ps (ChatLS) and -16.22 ps (CBTune); for arm9, it reaches -3.70 ps versus -8.25 ps and -8.44 ps, respectively. For picorv32 and wb conmax, SynAct further approaches timing closure with WNS values of 0.06 ps and 0.01 ps. For secondary metrics, TNS is assigned lower priority than WNS and tends to improve as WNS becomes tighter. SynAct reduces TNS to 17.86% of the bootstrap synthesis result, compared with 96.43% for ChatLS and 77.14% for CBTune. In terms of area and power trade-offs, SynAct keeps metrics close to the bootstrap synthesis levels, with slight reductions in area and power (99.28% area, 98.92% dynamic 1 https://github.com/sallyliu921/CB-EVO 8 TABLE I Five-run average PPA comparison with WNS as the primary objective and TNS/area/power as secondary metrics. Benchmarks WNS (ps)TNS (ps)Area (μm 2 )Dynamic Power (mW)Static Power (μW) [11][8]SynAct[11][8]SynAct[11][8]SynAct[11][8]SynAct[11][8]SynAct uart16550-6.62-2.04-1.18-6.69-2.04-1.30403.57393.19397.731.5751.5701.5730.3940.3840.391 picorv32-11.92-2.940.06-329.10-268.320.001123.331146.731123.563.4893.5243.5101.1901.2871.276 yacc-12.42-18.61-4.38-595.46-996.20-68.271155.381155.901159.374.1154.1624.1501.3061.3331.304 aescore-9.83-3.68-3.41-869.29-108.98-118.371249.871210.611194.674.0203.7653.7031.3901.3691.316 wb2axip-9.23-16.22-6.78-4170.73 -8771.95 -3488.091393.821523.991328.595.4985.5735.1621.2221.6871.173 wbconmax-12.20-11.120.01-3562.51 -4704.210.001700.231686.601684.224.1414.3924.0401.3681.4691.314 arm9-8.25-8.44-3.70-120.85-149.88-37.422022.951971.412038.791.8121.7851.8192.0591.9832.100 sha3-14.33-6.32-3.82-8183.41 -1849.45 -705.504079.152901.762837.7530.54015.38017.2103.9793.2612.761 spimaster-13.51-4.47-3.04-142.14-35.01-53.205448.905428.245415.6511.28011.27011.2406.1656.1666.128 ethernet-3.56-6.53-2.85-304.41-67.81-25.056438.156449.116406.1423.62023.28023.3207.0807.4657.378 ecg-3.35-4.56-2.23-22.11-453.69-33.095838.976304.305842.2922.65023.96022.6805.7147.0895.714 linkruncca-6.40-3.14-6.19-12595.18 -801.79 -5865.339832.239950.359876.5627.39027.77027.66011.52011.87011.730 xgemac-6.30-7.04-4.36-34.54-35.47-25.7712613.77 12622.96 12668.157.4787.5407.54113.97013.96014.010 fft256-12.68-34.27-7.90-1805.46 -1794.78 -137.3726628.94 26475.57 26617.7372.66072.70072.66031.59031.01031.570 Ratio Avg. 1 71.73% 66.67% 27.03%96.43%77.14%17.86%103.14% 101.02%99.28%105.33% 99.79% 98.92%101.67% 105.51% 98.64% 1 “Ratio Avg.” averages per-design metric ratios relative to bootstrap synthesis; lower values indicate greater improvement. TABLE IV Runtime and token usage averaged over five runs. Benchmark Total execution time (s)Token usage Boot. 1 [11][8]SynActAnal. 2 Opt. 3 uart1655019.02187.93428.59425.204338195823 picorv3283.86225.471617.28783.494374796444 yacc101.57225.552232.63898.454226296144 aescore93.88351.182478.491078.544395595322 wb2axip84.40265.932323.97822.284510395840 wbconmax121.26258.713427.691383.274479595416 arm9617.47980.1710229.676941.714500296493 sha3248.03515.755218.053242.304358095474 spimaster325.07594.117005.902084.523658595186 ethernet327.66848.576408.452706.385118294415 ecg253.50567.905083.021850.213795196071 linkruncca1219.773379.1324823.5110079.574283695464 xgemac381.86866.177669.931573.924099196447 fft2561551.272169.1129751.5510167.444106096651 Ratio Avg.100.00%289.83%2174.18%988.62%-- 1 Bootstrap synthesis. 2 Analysis Agent. 3 Optimization Agent. TABLE V Bounded action space for CBTune reproduction. ID Command 1 optimize -mode timing -map_effort high 2 tdopt -flat -perturb -stop 1 -area 1.0; phase_assign -mode area_recovery 3 optimize -mode timing -map_effort high -incremental 4 tdopt -flat -resyn2 -area 1.000000 5 retime_register -period 0 -effort medium; optimize -incremental 6 impl_select -mode down -scope s+ -tns; resize -mode normal -cost c>s>a -flat -area 1.0 7 pre_td; phase_assign -flat -mode timing -effort medium; tdopt -flat -stop 10 1.0 -area 1.000000 power, 98.64% static power). These results show that SynAct achieves substantial improvements in both WNS and TNS while maintaining overall PPA balance and efficiency. Runtime and LLM API token cost. TABLE IV summarizes the end-to-end execution time of all methods. All methods begin with the same bootstrap synthesis stage, whose runtime is reported in the “Boot.” column and included in each method’s total runtime. The percentages represent end-to-end runtime normalized to the bootstrap time. ChatLS has the lowest normalized runtime, averaging 289.83% of the boot- strap synthesis time, because it generates the script in a single pass. CBTune has the highest runtime at 2174.18% due to its 84.85% Candidate Evaluation Pool 10.4% Bootstrap Synthesis 2.56% Analysis Agent 1.67% Optimization Agent 0.52% Other Overhead Fig. 6 Runtime breakdown of SynAct. bandit-based exploration. SynAct strikes a favorable balance at 988.62%, less than half of CBTune’s runtime, while achieving the best WNS ratio of 27.03%, compared with 71.73% for ChatLS and 66.67% for CBTune. The additional runtime relative to single-pass ChatLS comes from feedback-driven candidate evaluation, which enables iterative refinement. Fig. 6 further breaks down the internal runtime composition of SynAct. Candidate evaluation dominates the runtime at 84.85%. Each iteration evaluates ten LLM-generated candi- dates in parallel and commits the best safe action. This setting balances server capacity and robustness to LLM stochasticity: fewer candidates reduce synthesis cost, whereas more broaden exploration. Despite parallelism, repeated synthesis remains the primary bottleneck. Bootstrap synthesis, the required ini- tialization step, accounts for the second-largest share at 10.4%. The Analysis and Optimization Agents account for 2.56% and 1.67%, respectively, while GrammarVAE encoding, decoding, and result processing account for the remaining 0.52%. Future work may consider early stopping upon WNS saturation or lightweight candidate filtering before execution to reduce unnecessary synthesis runs. Token usage in TABLE IV is consistent across all 14 benchmarks. On average, SynAct consumes about 139k tokens per design, with 69% from the Optimization Agent and 31% from the Analysis Agent. The Optimization Agent uses more tokens because it processes more documents, even after RAG filtering. Total usage varies slightly from 132k to 146k, showing low cross-design variance and a stable ratio between the two agents. 9 1234 56 7 8910 -32 -29 -26 -25 -10 -5 0 LLM cold start Iteration WNS (ps) ethernet linkruncca sha3 wb2axip Fig. 7 Optimization trajectory of SynAct. C. Optimization Trajectory Analysis Recall that SynAct incrementally optimizes a design over at most n iter LLM-guided iterations, where n iter is the tunable maximum number of iterations. We use n iter = 5 in the main experiments in TABLE I to balance optimization quality and runtime cost. Fig. 7 evaluates the sensitivity to n iter by plotting optimization trajectories from n iter = 1 onward. For readability, we show four representative benchmarks: ethernet, linkruncca, sha3, and wb2axip. Their clear WNS improvements and well-separated curves provide a concise view of SynAct’s overall optimization trend without the visual clutter of plotting all benchmarks. The first iteration, labeled “LLM cold start,” refers to SynAct’s initial attempt to generate optimization commands that rely almost solely on RAG-retrieved documents without historical experience, often leading to suboptimal results. As iterations proceed, SynAct refines its strategy using updated analyses and synthesis feedback, improving WNS over time. Most trajectories trend upward, while minor fluctuations in linkruncca and sha3 reflect the exploratory nature of LLM- guided optimization. Although additional iterations can further improve WNS when runtime is less constrained, n iter = 5 provides a practical balance between optimization quality and runtime cost, supporting our default setting. Overall, these results demonstrate the effectiveness of iterative adaptation driven by cumulative synthesis feedback. D. Generalizability Across LLMs To evaluate whether SynAct generalizes across different LLMs, we rerun the complete 14-design experiment using GPT-5.2 for both the Analysis and Optimization Agents under the same setup as TABLE I. As reported in TABLE VI, this configuration reduces the WNS and TNS Ratio Avg. to 20.37% and 13.69%, respectively, while keeping area and power within 1% of the bootstrap results. The default DeepSeek V3.1 configuration already achieves a WNS Ratio Avg. of 27.03% and substantially outperforms the baselines, confirming that SynAct’s closed-loop diagnosis, retrieval, and experience refinement remain effective with different LLMs. GPT-5.2 further enhances report interpretation, diagnosis, and command generation within this pipeline, yielding additional timing gains. These results show that SynAct provides the adaptive optimization mechanism, while a stronger LLM can exploit it more effectively and raise the performance ceiling. TABLE VI Five-run average PPA results of SynAct with GPT- 5.2 under the same setup as TABLE I. BenchmarksWNS(ps)TNS(ps)Area (μm 2 )DP (mW) 1 SP (μW) 2 uart16550-1.43-1.53401.391.5840.395 picorv320.040.001131.683.5421.303 yacc-3.28-59.291156.954.1331.300 aescore-2.90-158.801207.753.7471.345 wb2axip-6.46-3352.071329.515.1631.175 wbconmax-0.59-9.601685.974.3631.460 arm9-4.42-47.122034.101.8172.077 sha3-2.54-246.832839.0017.2202.765 spimaster0.020.005387.8211.2406.103 ethernet-2.94-17.156377.9623.5307.330 ecg0.010.005846.3822.6905.722 linkruncca0.000.009815.9327.54011.440 xgemac-4.36-25.6312683.967.54014.020 fft256-6.49-151.6026612.2872.65031.560 Ratio Avg.20.37%13.69%99.36%99.65%99.41% 1 Dynamic Power. 2 Static Power. TABLE VII Diagnostics of GrammarVAE latent locality and BO-seed utility over 14 benchmarks. CategoryDiagnosticResult Latent locality Mean ∆r, near pairs0.188 Mean ∆r, far pairs0.238 BO seed utility BO-seeded mean reward0.297 RAG-grounded mean reward0.289 Iterations where BO has highest mean65.3% Iterations where best is BO-seeded47.2% E. Validation of Latent-Space BO Guidance To validate BO-guided experience refinement, we test two properties required by its design. First, if GrammarVAE pro- vides a useful local search prior, commands that are close in latent space should produce more similar synthesis rewards than distant commands. Using r(C) from Equation (2), we measure this similarity by ∆r(C i ,C j ) = |r(C i ) − r(C j )|, where a smaller value indicates more consistent optimization outcomes. As shown in TABLE VII, near command pairs have a mean ∆r of 0.188 versus 0.238 for far pairs, a 21.0% reduction. Second, the BO guidance should remain useful after the LLM converts a decoded seed into tool-valid candidates. BO-seeded candidates achieve a mean reward of 0.297 versus 0.289 for RAG-grounded candidates and obtain the highest mean reward in 65.3% of benchmark iterations. These results support the two design properties: locally consistent latent neighborhoods and BO guidance that remains effective after tool-aware LLM refinement. F. Ablation Study on BO and Retrieval Modules Fig. 8 presents the ablation results using the full SynAct configuration (“BO+GraphRAG”) as the reference. In this configuration, candidate generation combines report diagnosis, documentation retrieved by GraphRAG, and GrammarVAE seeds guided by BO. All variants generate ten candidates per iteration, evaluate them through synthesis, and select the best safe command, thereby isolating the effects of BO and retrieval. The “w/o BO” variant removes BO guidance and the reuse of historical commands, while “vanilla RAG” uses 10 uart16550 picorv32 yacc aes_core wb2axip wb_conmax arm9 sha3 spimaster ethernet ecg linkruncca xge_mac fft256 −10 −8 −6 −4 −2 0 −1.18 0.06 −4.38 −3.41 −6.78 0.01 −3.7 −3.82 −3.04 −2.85 −2.23 −6.19 −4.36 −7.9 −2.05 −0.31 −7.64 −4.67 −7.16 −1.45 −4.92 −7.38 −6.73 −4.05 −3.26 −7.41 −4.26 −8.65 0.04 0.01 −6.52 −3.59 −9.39 −3.87 −3.98 −1.55 −4.78 0.01 −2.93 −7.41 −4.36 −7.28 −1.18 −2.69 −7.6 −3.38 −10.47 −4.37 −3.76 −3.82 −7.18 −5.85 −2.43 −10.88 −4.35 −8.35 WNS (ps) SynAct (BO+GraphRAG)BO Ablation (w/o BO)Retrieval Ablation (vanilla RAG)Retrieval Ablation (w/o RAG) Fig. 8 Ablation of SynAct components on WNS. The full configuration (BO + GraphRAG) achieves the best timing improvement. flat retrieval and “w/o RAG” provides the full documentation directly. Without BO, timing performance clearly degrades, with the WNS Ratio Avg. rising from 27.0% to 37.5%, indicat- ing less effective WNS improvement. The full configuration outperforms this variant on 13 of 14 benchmarks, with WNS improving from -7.16 ps to -6.78 ps on wb2axip and from - 8.65 ps to -7.90 ps on fft256. These results show that BO- guided experience reuse steers exploration of the command space toward better optimization outcomes. The “vanilla RAG” variant raises the WNS Ratio Avg. from 27.0% to 28.6%, while the “w/o RAG” variant further increases it to 38.3%. WNS degradations exceeding 2 ps on yacc and linkruncca suggest that GraphRAG’s structured representation captures richer contextual dependencies than flat retrieval or direct use of the full documentation. Over- all, SynAct achieves the most effective timing improvement among all variants, with BO supporting effective exploration and GraphRAG providing structured contextual knowledge for optimization. VII. CONCLUSION In summary, SynAct is an adaptive closed-loop LLM frame- work for iterative PPA optimization in commercial synthesis, addressing the limitations of fixed-action search and one- shot script generation. By combining synthesis feedback, prior experience, and retrieved tool knowledge, SynAct enables state-aware decisions with explicit rationales while improving timing and maintaining balanced area and power. Although evaluated only on AltiSyn ® and open-source designs, SynAct is designed for portability to other logic synthesis tools with scripting interfaces, command documentation, and struc- tured PPA and timing reports by replacing its tool-specific adapters and knowledge base. Future work will validate cross- tool portability and industrial-scale performance and reduce candidate-evaluation overhead. ACKNOWLEDGMENT The authors thank ZeniSyn Design Systems for providing access to AltiSyn ® and related technical support. Regarding the use of generative AI, DeepSeek V3.1 and GPT-5.2 were used in SynAct to analyze synthesis reports and generate candidate commands, while OpenAI Codex was used solely for language editing and grammar checking. All technical content, ideas, and results are original work by the authors. REFERENCES [1] C. Yu, H. Xiao, and G. De Micheli, “Developing synthesis flows with- out human knowledge,” in ACM/IEEE Design Automation Conference (DAC). IEEE, 2018, p. 1–6. [2] A. B. Kahng, “New directions for learning-based IC design tools and methodologies,” in 2018 23rd Asia and South pacific design automation conference (ASP-DAC). IEEE, 2018, p. 405–410. [3] R. Brayton and A. Mishchenko, “ABC: An academic industrial-strength verification tool,” in International Conference on Computer-Aided Ver- ification (CAV). Springer, 2010, p. 24–40. [4] A. Hosny, S. Hashemi, M. Shalan, and S. Reda, “DRiLLS: Deep reinforcement learning for logic synthesis,” in IEEE/ACM Asia and South Pacific Design Automation Conference (ASPDAC). IEEE, 2020, p. 581–586. [5] A. Grosnit, C. Malherbe, R. Tutunov, X. Wan, J. Wang, and H. B. Am- mar, “BOiLS: Bayesian optimisation for logic synthesis,” in IEEE/ACM Design, Automation and Test in Europe (DATE).IEEE, 2022, p. 1193–1196. [6] Z. Pei, F. Liu, Z. He, G. Chen, H. Zheng, K. Zhu, and B. Yu, “AlphaSyn: Logic synthesis optimization with efficient Monte Carlo Tree Search,” in IEEE/ACM International Conference on Computer-Aided Design (ICCAD). IEEE, 2023, p. 1–9. [7] C. Yu, “FlowTune: Practical multi-armed bandits in boolean opti- mization,” in IEEE/ACM International Conference on Computer-Aided Design (ICCAD). IEEE, 2020, p. 1–9. [8] F. Liu, Z. Pei, Z. Yu, H. Zheng, Z. He, T. Chen, and B. Yu, “CBTune: Contextual bandit tuning for logic synthesis,” in IEEE/ACM Design, Automation and Test in Europe (DATE). IEEE, 2024, p. 1–6. [9] 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 (TCAD), vol. 43, no. 10, p. 3184–3197, 2024. [10] M. Liu, T.-D. Ene, R. Kirby, C. Cheng, N. Pinckney, R. Liang, J. Alben, H. Anand, S. Banerjee, I. Bayraktaroglu et al., “ChipNemo: Domain-adapted LLMs for chip design,” 2023. [Online]. Available: https://arxiv.org/abs/2311.00176 [11] H. Zheng, H. Wu, and Z. He, “ChatLS: Multimodal retrieval-augmented generation and chain-of-thought for logic synthesis script customiza- tion,” in ACM/IEEE Design Automation Conference (DAC).IEEE, 2025, p. 1–7. [12] Y. Pu, Z. He, T. Qiu, H. Wu, and B. Yu, “Customized retrieval aug- mented generation and benchmarking for EDA tool documentation QA,” in IEEE/ACM International Conference on Computer-Aided Design (ICCAD). IEEE, 2024, p. 1–9. [13] S. Yao, J. Zhao, D. Yu, N. Du, I. Shafran, K. R. Narasimhan, and Y. Cao, “ReAct: Synergizing reasoning and acting in language models,” in International Conference on Learning Representations (ICLR), 2022. 11 [14] Q. Wu, G. Bansal, J. Zhang, Y. Wu, B. Li, E. Zhu, L. Jiang, X. Zhang, S. Zhang, J. Liu et al., “AutoGen: Enabling next-gen LLM applications via multi-agent conversations,” in First Conference on Language Mod- eling (CoLM), 2024. [15] Synopsys, Design Compiler User Guide, Mountain View, CA, USA, 2022, available via Synopsys SolvNet. [16] P. Lewis, E. Perez, A. Piktus, F. Petroni, V. Karpukhin, N. Goyal, H. K ̈ uttler, M. Lewis, W.-t. Yih, T. Rockt ̈ aschel et al., “Retrieval- augmented generation for knowledge-intensive NLP tasks,” Advances in neural information processing systems, vol. 33, p. 9459–9474, 2020. [17] S. Huang, J. Li, Z. Yu, J. Ye, J. Xu, N. Xu, and G. Dai, “LLSM: LLM-enhanced logic synthesis model with EDA-guided CoT prompting, hybrid embedding and AIG-tailored acceleration,” in IEEE/ACM Asia and South Pacific Design Automation Conference (ASPDAC).IEEE, 2025, p. 974–980. [18] D. Edge, H. Trinh, N. Cheng, J. Bradley, A. Chao, A. Mody, S. Truitt, D. Metropolitansky, R. O. Ness, and J. Larson, “From local to global: A graph RAG approach to query-focused summarization,” arXiv preprint arXiv:2404.16130, 2024. [19] J. Wu, J. Zhu, Y. Qi, J. Chen, M. Xu, F. Menolascina, Y. Jin, and V. Grau, “Medical graph RAG: Evidence-based medical large language model via graph retrieval-augmented generation,” in Annual Meeting of the Association for Computational Linguistics (ACL), 2025, p. 28 443– 28 467. [20] M. J. Kusner, B. Paige, and J. M. Hern ́ andez-Lobato, “Grammar varia- tional autoencoder,” in International Conference on Machine Learning (ICML). PMLR, 2017, p. 1945–1954. [21] D. Lynch, J. McDermott, and M. O’Neill, “Program synthesis in a continuous space using grammars and variational autoencoders,” in International Conference on Parallel Problem Solving from Nature. Springer, 2020, p. 33–47. [22] H. Dai, Y. Tian, B. Dai, S. Skiena, and L. Song, “Syntax-directed varia- tional autoencoder for molecule generation,” in International Conference on Learning Representations (ICLR), 2018. [23] H.-M. Gutmann, “A radial basis function method for global optimiza- tion,” Journal of global optimization, vol. 19, no. 3, p. 201–227, 2001. [24] N. Srinivas, A. Krause, S. Kakade, and M. Seeger, “Gaussian process optimization in the bandit setting: No regret and experimental design,” in International Conference on Machine Learning (ICML).PMLR, 2010, p. 1015–1022. [25] “ZeniSyn Design Systems,” https://w.zenisyn.com. [26] L. T. Clark, V. Vashishtha, L. Shifren, A. Gujja, S. Sinha, B. Cline, C. Ramamurthy, and G. Yeric, “ASAP7: A 7-nm FinFET predictive process design kit,” Microelectronics Journal (MEJ), vol. 53, p. 105– 115, 2016. [27] “OpenCores,” https://opencores.org. Fangzhou Liu received her B.Eng. degree from the School of Electronic Science and Engineering, Nan- jing University, in 2023. She is currently pursuing the Ph.D. degree at the Chinese University of Hong Kong under the supervision of Prof. Bei Yu since Fall 2023. Her research focuses on applying machine learning techniques to EDA and logic synthesis optimization. Peiyi Han received the B.E. degree in automation from Tsinghua University in 2022 and the M.S. degree from the Institute of Computing Technology, University of Chinese Academy of Sciences, in 2025, under the supervision of Prof. Yunji Chen. He is currently pursuing the Ph.D. degree with the De- partment of Computer Science and Engineering, The Chinese University of Hong Kong, under the super- vision of Prof. Bei Yu. His research interests include large language models and machine learning, with applications in electronic design automation (EDA). Jiawei Liu received his B.Eng. and Ph.D. degrees from Beijing University of Posts and Telecommu- nications in 2020 and 2025, respectively. He is currently a Postdoctoral Fellow with the Department of Computer Science and Engineering, The Chinese University of Hong Kong, under the supervision of Prof. Bei Yu. His research focuses on electronic design automation and artificial intelligence. Yuan Pu received the B.S. degree in computer science from The Chinese University of Hong Kong, Hong Kong, in 2022. He is now a third-year Ph.D. Student at the Department of Computer Science and Engineering, the Chinese University of Hong Kong (CUHK), supervised by Prof. Bei YU since 2023 Fall. His research interest includes Combinatorial Algorithms/AI in EDA. Zhuolun He received the B.S. degree in computer science and engineering from Peking University, Beijing, China, in 2017, and the Ph.D. degree from the Chinese University of Hong Kong, Hong Kong, in 2023. He is an incoming assistant professor with Tsinghua University, Beijing, China. Rongliang Fu received his Ph.D. in Computer Science and Engineering from The Chinese Uni- versity of Hong Kong in January 2026, following an M.S. from the University of Chinese Academy of Sciences in June 2021 and a B.S. in Software Engineering from Northwestern Polytechnical Uni- versity in June 2018. He has authored over 30 papers across major journals (IEEE TC and IEEE TCAD) and conferences(DAC, DATE, ICCAD, etc.). His research spans electronic design automation and EDA for superconducting electronics. Tsung-Yi Ho (F’24) is a Professor in the Depart- ment of Computer Science and Engineering, The Chinese University of Hong Kong (CUHK). He received his Ph.D. in Electrical Engineering from National Taiwan University in 2005. His research interests include several areas of computing and emerging technologies, especially in the design au- tomation of microfluidic biochips. He was a recip- ient of the Best Paper Award at the IEEE Trans- actions on Computer-Aided Design of Integrated Circuits and Systems in 2015. Currently, he serves as the VP Conferences of IEEE CEDA, and the Executive Committee of ASP- DAC and ICCAD. He is a Distinguished Member of ACM and a Fellow of IEEE. Bei Yu (M’15-SM’22) received the Ph.D. degree from The University of Texas at Austin in 2014. He is currently a Professor in the Department of Computer Science and Engineering, The Chinese University of Hong Kong. He has served as TPC Chair of ACM/IEEE Workshop on Machine Learn- ing for CAD, and in many journal editorial boards and conference committees. He received eleven Best Paper Awards from ICCAD 2024 & 2021 & 2013, IEEE TSM 2022, DATE 2022, ASPDAC 2021 & 2012, ICTAI 2019, Integration, the VLSI Journal in 2018, ISPD 2017, SPIE Advanced Lithography Conference 2016, six ICCAD/ISPD contest awards, IEEE CEDA Ernest S. Kuh Early Career Award in 2021, DAC Under-40 Innovator Award in 2024, and Hong Kong RGC Research Fellowship Scheme (RFS) Award in 2024. 12