Paper deep dive

ARES: Adaptive Reasoning-Effort Steering for PPA- and Cost-Aware RTL Optimization with LLM Agents

Stef Cuyckens, Mihaela Jivanescu, Jun Yin, Chao Fang, Marian Verhelst

Year: 2026Venue: arXiv preprintArea: cs.ARType: PreprintEmbeddings: 47

Intelligence

Status: succeeded | Model: Gemma-4-26B-A4B | Prompt: intel-v1 | Confidence: 91%

Last extracted: 8/1/2026, 2:30:16 AM

Summary

The paper introduces Ares, an LLM-agent framework for optimizing Register-Transfer-Level (RTL) designs that addresses power, performance, and area (PPA) while accounting for inference costs. Ares proposes three key innovations: a normalized dollar cost metric per LLM call for fair comparison, a finding that engineered long-term memory offers no significant advantage over simple experience concatenation, and an adaptive reasoning-effort policy that escalates to deeper reasoning only when progress stalls. This approach outperforms fixed-effort strategies and state-of-the-art agents like Dr. RTL.

Entities (10)

Ares · method · 98%LLM Agent · component · 95%Figure of Merit (FOM) · metric · 94%RTL · dataobject · 92%KU Leuven · organization · 90%Nokia Bell Labs · organization · 90%PPA · metric · 90%Dr. RTL · method · 88%Patience Counter · component · 87%Long-Term Memory · component · 85%

Relation Signals (8)

Stef Cuyckens → affiliatedwith → KU Leuven

confidence 95% · Stef Cuyckens ... KU Leuven

Mihaela Jivanescu → affiliatedwith → Nokia Bell Labs

confidence 95% · Mihaela Jivanescu ... Nokia Bell Labs

Ares → optimizes → RTL

confidence 95% · Ares optimizes designs by repeatedly editing its RTL

Ares → uses → LLM Agent

confidence 95% · Ares, an LLM-agent RTL optimizer

Ares → measures → Figure of Merit (FOM)

confidence 92% · We introduce a normalized dollar cost per LLM call reported alongside the figure of merit (FoM)

Ares → employs → Patience Counter

confidence 90% · via a patience counter fit on 21 training designs

Ares → outperforms → Dr. RTL

confidence 90% · reaches a 25% deeper FoM than state-of-the-art Dr. RTL

Ares → evaluates → Long-Term Memory

confidence 85% · we find the construction of the long-term memory matters little

Cypher Suggestions (0)

No Cypher suggestions yet.

Abstract

Abstract:Large language model (LLM) agents optimize the power, performance, and area (PPA) of register-transfer-level (RTL) designs by iterating over edits, synthesis, and PPA analysis, paying a dollar cost for every LLM call. Prior agents report the quality reached without its normalized cost, attribute that quality to an engineered cross-design memory, and hold the reasoning effort of every call fixed. We propose Ares with three corresponding innovations. (1) We introduce a normalized dollar cost per LLM call reported alongside the figure of merit (FoM), enabling fair comparison across effort levels and optimizers. (2) Using this accounting, we find the construction of the long-term memory matters little. An engineered memory brings no dependable gain over a plain concatenation of the same experience. (3) We instead adapt the per-call reasoning effort by escalating to deeper reasoning only once progress at a lower effort stalls, via a patience counter fit on 21 training designs, allocating reasoning where it pays rather than uniformly across all iterations. On three test designs unseen during training, the effort policy lowers the FoM by 23-27% where the best fixed effort reaches 16-23%, at equal normalized cost. Ares closes up to 83% of the gap from an LLM-drafted multiply-accumulate unit to its highly hand-optimized counterpart, and reaches a 25% deeper FoM than state-of-the-art Dr. RTL at 12% of its tokens.

PDF

Open source PDF →Open local PDF →

Trouble viewing inline? Open PDF directly →

Full Text

45,923 characters extracted from source content.

Expand or collapse full text

Ares: Adaptive Reasoning-Effort Steering for PPA- and Cost-Aware RTL Optimization with LLM Agents Stef Cuyckens stef.cuyckens@kuleuven.be KU LeuvenLeuvenBelgium , Mihaela Jivanescu mihaela.jivanescu@nokia-bell-labs.com Nokia Bell LabsAntwerpBelgium , Jun Yin jun.yin@kuleuven.be KU LeuvenLeuvenBelgium , Chao Fang† chao.fang@kuleuven.be KU LeuvenLeuvenBelgium and Marian Verhelst marian.verhelst@kuleuven.be KU LeuvenLeuvenBelgium (2027) Abstract. Large language model (LLM) agents optimize the power, performance, and area (PPA) of register-transfer-level (RTL) designs by iterating over edits, synthesis, and PPA analysis, paying a dollar cost for every LLM call. Prior agents report the quality reached without its normalized cost, attribute that quality to an engineered cross-design memory, and hold the reasoning effort of every call fixed. We propose Ares with three corresponding innovations. (1) We introduce a normalized dollar cost per LLM call reported alongside the figure of merit (FoM), enabling fair comparison across effort levels and optimizers. (2) Using this accounting, we find the construction of the long-term memory matters little. An engineered memory brings no dependable gain over a plain concatenation of the same experience. (3) We instead adapt the per-call reasoning effort by escalating to deeper reasoning only once progress at a lower effort stalls, via a patience counter fit on 21 training designs, allocating reasoning where it pays rather than uniformly across all iterations. On three test designs unseen during training, the effort policy lowers the FoM by 23–27% where the best fixed effort reaches 16–23%, at equal normalized cost. Ares closes up to 83% of the gap from an LLM-drafted multiply-accumulate unit to its highly hand-optimized counterpart, and reaches a 25% deeper FoM than state-of-the-art Dr. RTL at 12% of its tokens. RTL optimization, LLM agents, adaptive reasoning effort, PPA, inference cost, agent memory, electronic design automation †journalyear: 2027†copyright: acmcopyright†conference: Asia and South Pacific Design Automation Conference; January 2027; Tokyo, Japan†booktitle: Asia and South Pacific Design Automation Conference (ASPDAC ’27), January 2027, Tokyo, Japan†price: 15.00 unoptimized RTL v0v_0best design yetcurrent optimumtestbenchgenerated from v0v_0initializeInput design v v_0LLM agentedits the RTLshort-term memory(current run)Adaptive reasoning effort, set per callstalled and failed iterations charge a patience counter CCmediumdependable, cheaphighdeeper, higher costescalate: C≥pC\!≥\!pdischarge3long-term memorymarkdown2functional verifylong random TB + SEC vs v0v_0fail: discardsynthesizemax f (Synopsys DC)synthesize @ ffarea (Synopsys DC)gate-level verifynetlist + TBpowerPrimeTimeFigure of Meritf⋅f·area⋅·power (norm. v0v_0)synthesis & PPA measurement (commercial flow)passrandom vectorsif FoM beats best: keep as new best; else discard; then iteratefail: discardResultcost1best FoMunoptimized v0v_0fixed highstuck at mediummediumhigheffortlower FoM at lower costAfter optimizing, update long-term memory Figure 1. Overview of Ares. The LLM agent edits the running-best RTL; each candidate is verified against the input design v0v_0, synthesized on the commercial flow, and kept only if it lowers the FoM. Our contributions: 1 the per-call cost metric enabling proper comparison, 2 the finding that the construction of the cross-design long-term memory matters little, and 3 an adaptive reasoning-effort policy that escalates once progress stalls. On the right, our adaptive effort reaches a lower FoM than fixed effort at the same cost. 1. Introduction Meeting power, performance, and area (PPA) targets is a central challenge of digital hardware design, and improving the register-transfer-level (RTL) description that determines them has traditionally required scarce human expert effort (Lu et al., 2026; Liu et al., 2023a; Pan et al., 2025). Much RTL therefore ships functionally correct but unoptimized, whether drafted quickly by an engineer or generated by an LLM. Automating the optimization of such RTL with large-language-model (LLM) agents has recently drawn increased attention (Lu et al., 2026; Abdelatty et al., 2025; Pan et al., 2025). An LLM agent pairs an LLM with electronic design automation (EDA) tools. It takes an existing, unoptimized design as input, edits it, synthesizes the edit, reads back the resulting PPA, and repeats. If the new design has a lower figure of merit (FoM), for example a power-area-delay product defined against the original design, it is retained. The quality of these edits improves with the capability of the LLM. Capable agents therefore rely on large commercial models (Gandhi et al., 2024), whose rapidly growing token bills (Chen et al., 2026) already put a single agentic run at several dollars (Gao and Peng, 2026). The cost of an optimization run thus deserves as much attention as the FoM it reaches. Prior art falls short on both counts. Some agents that optimize existing RTL score only area and timing, leaving power out of the objective (Fang et al., 2026; Shi et al., 2026). On cost, every state-of-the-art optimizer falls short: at best it reports one aggregate dollar figure for a whole study, and none provides a unified metric that relates optimization quality to its dollar cost, allowing fair comparison across optimizers (Fang et al., 2026; Shi et al., 2026; Ping et al., 2026). This missing cost metric also leaves unevaluated where an optimizer’s quality actually comes from. Currently, the most capable RTL agents reach a lower FoM by giving the agent a long-term memory, a collection of optimization experience distilled across designs and reused on new ones (Fang et al., 2026; Wang et al., 2026). These agents attribute the quality of the optimizer to how that memory is constructed, and engineer its content and organization accordingly, from distilled markdown rule libraries to manager-curated entry pools (Fang et al., 2026; Wang et al., 2026; Zhang et al., 2026; Zhou et al., 2026). Using a cost-controlled comparison, we find this attribution does not hold at equal spend: an engineered memory brings no dependable gain over a plain concatenation of the same experience, though both beat running with no long-term memory. We instead turn to the reasoning effort the LLM is allowed to perform per call, a per-call setting, typically low, medium, or high, that determines how much hidden reasoning the LLM performs before it emits an edit, at a higher token cost for a higher level (Alomrani et al., 2025). Prior RTL agents nonetheless hold it at a single value (Fang et al., 2026; Wang et al., 2026; Min et al., 2026; Shi et al., 2026; Ping et al., 2026), while a fixed high effort overthinks the iterations a cheap edit would have solved and a fixed low effort underthinks the ones that genuinely need deeper reasoning (Alomrani et al., 2025). We find that adapting the effort during the run, raising it only on the iterations where cheaper reasoning has stalled, improves the average FoM reached at a given cost, as we show in Sec. 5.2. Motivated by these observations, we present Ares, an LLM-agent RTL optimizer that steers the reasoning effort adaptively across the iterations of a run, accounting for the dollar cost of every call, illustrated in Fig. 1. This work makes the following contributions. • 1 Normalized per-call cost enables fair optimizer comparison (Sec. 3.1). We propose a unified metric that relates each LLM call’s normalized dollar cost to the FoM it reaches, making optimization quality and spend jointly comparable across effort levels and optimizers. This metric reveals that Ares reaches a deeper FoM than the state-of-the-art (SotA) Dr. RTL (Fang et al., 2026) at 8.7×8.7× lower cost. • 2 Long-term-memory construction matters less than assumed (Sec. 3.2). We compare an engineered memory that applies the structuring, filtering, and abstraction operations of prior work (Fang et al., 2026; Wang et al., 2026; Zhang et al., 2026; Zhou et al., 2026) against a plain concatenation of the same experience and against no long-term memory. The engineered construction brings little benefit over the plain one, as we measure at equal spend. • 3 Adaptive per-call reasoning effort improves optimization quality (Sec. 3.3). To allocate the reasoning effort efficiently, we implement adaptive reasoning-effort steering in Ares via a patience counter, fit once on 21 training designs, that escalates to deeper reasoning only once progress at a lower effort stalls. On three held-out test designs, this policy lowers the FoM by 23–27% where the best fixed effort reaches 16–23%, at equal normalized cost. The central result is that where and when an LLM agent spends its reasoning budget, rather than how its memory is written, sets the FoM per dollar it reaches. The adaptive policy ends at a lower FoM than any fixed effort level on all three test designs (Sec. 5.2). Ares further closes up to 83% of the gap from an LLM-drafted microscaling (MX) multiply-accumulate unit to its hand-optimized counterpart (Cuyckens et al., 2025) while cutting the run-to-run variance by 58% (Sec. 5.3). On controller, Ares reaches a FoM of 0.694 where REvolution (Min et al., 2026) and Dr. RTL (Fang et al., 2026) reach 0.943 and 0.923, while spending 12% of Dr. RTL’s tokens for the same number of design iterations (Sec. 5.4). 2. Background and Motivation LLM agents entered RTL design one objective at a time: first checking a design, then generating it, and now optimizing it (Pan et al., 2025). Early agents drafted SystemVerilog assertions and testbenches from a specification (Fang et al., 2025; Pulavarthi et al., 2025; Zhang et al., 2025), and attention then moved to generating correct RTL, where modern LLMs now score so highly on the VerilogEval and RTLLM benchmarks that the task is considered close to solved (Liu et al., 2023b; Lu et al., 2024; Liu et al., 2024; Ho et al., 2025; Wang et al., 2026). Yet these designs are often inefficient: they pass their tests while wasting area and power (Abdelatty et al., 2025). The objective accordingly shifted to the quality of the hardware, and the RTL-OPT benchmark shows that a weak synthesizer can credit the agent for a rewrite that a commercial tool would make on its own (Lu et al., 2026). Iterating on measured feedback improves this hardware quality further (Ho et al., 2025; Tsai et al., 2024; Min et al., 2026), but the first agents that do so keep what they learn only for the duration of a run. REvolution and POET evolve a population of candidate designs scored on power, area, and timing (Min et al., 2026; Ping et al., 2026), and CktEvo keeps an archive of its best candidates (Shi et al., 2026). In all three the stored candidates are the memory itself: no guidance is distilled from them, the population or archive is discarded when the run ends, and every new design is optimized from scratch (Min et al., 2026; Ping et al., 2026; Shi et al., 2026). A second group of agents carries its experience across designs, as distilled guidance rather than stored candidates. VeriAgent, in the generation setting, keeps a pool of structured nodes, each a trigger condition paired with natural-language guidance, which a dedicated manager agent inserts, refines, or discards after every run (Wang et al., 2026). Dr. RTL distills a markdown library of optimization strategies, including negative “avoid” strategies, and reuses it on designs held out from its construction (Fang et al., 2026). The same deliberate construction appears in the general-agent literature, where skill libraries transfer best when aligned with the target domain (Zhang et al., 2026; Zhou et al., 2026). Table 1 compares the two groups to Ares by the form of their memory and how long it lives. Of the five systems, only REvolution and Dr. RTL release their code (Min et al., 2026; Fang et al., 2026), and they are therefore the two we compare against on our own flow. Table 1. Memory-carrying LLM agents for RTL optimization compared to Ares. Task Mem. Cross- Power Cost Effort Open form design in FoM axis adapt. source REvolution (Min et al., 2026) gen. pop. no yes no no yes POET (Ping et al., 2026) opt. pop. no yes no no no CktEvo (Shi et al., 2026) opt. archive no no no no no VeriAgent (Wang et al., 2026) gen. nodes yes yes no no no Dr. RTL (Fang et al., 2026) opt. markdown yes no no† no yes Ares (ours) opt. markdown yes yes yes yes yes* † Reports one aggregate dollar figure for the complete study (Fang et al., 2026). *Our code will be available upon peer-reviewed publication. No agent of either group reports what an LLM call costs or adapts how much reasoning it receives, as the two rightmost columns of Table 1 show. Outside RTL design this is a known inefficiency: a fixed inference-time budget wastes reasoning on simple problems and cuts it short on hard ones (Alomrani et al., 2025). Because the payoff of extra test-time compute varies with the difficulty of the prompt, compute-optimal scaling allocates that compute adaptively per prompt (Snell et al., 2025). Cost-aware methods apply the same idea across models and calls, escalating to a costlier model, routing a call, or pruning a reasoning step only when the expected value justifies the cost (Chen et al., 2024; Jin et al., 2025; Li et al., 2026). All of them adapt the budget of a single, isolated task, whereas an optimization run is a sequence of iterations where the difficulty of finding the next improvement changes as the design becomes more optimized. Ares therefore computes the normalized cost of every call and steers the reasoning effort across the iterations of one run, escalating on stalled progress through a counter fit once on the training designs. 3. The Ares Optimizer Ares optimizes designs by repeatedly editing its RTL, scoring candidates with the FoM, and keeping the best version, while adapting the reasoning effort it spends on each edit. As Fig. 1 shows, it tracks two quantities throughout a run, the quality reached and the normalized dollar cost of reaching it 1 (Sec. 3.1). Each iteration hands the running-best RTL, initialized to the unoptimized input design v0v_0, to the LLM agent together with the conversation of the run so far and the long-term markdown memory 2 (Sec. 3.2). The agent proposes an edit at the effort level set by the adaptive policy 3 (Sec. 3.3). The candidate must first prove functional equivalence to v0v_0, on a long random testbench and by sequential equivalence checking. It is then synthesized on the commercial flow, re-verified on the netlist, and its measured area, power, and delay combine into the FoM, reported next to the computed dollar cost of the call that produced it. A candidate that lowers the FoM becomes the new running best and the next iteration chains from it. One that fails to verify, to synthesize, or to improve is discarded, and either outcome updates the patience counter that sets the effort of the next call. An optimization run ends when its cumulative cost reaches a user-set budget, and returns the running best as the optimized design. 3.1. Price the PPA gain of each LLM call Ares takes two inputs, a functionally correct but unoptimized RTL design v0v_0, and a testbench that exercises it, generated by the optimizer itself when none is supplied. The FoM is the product of the three post-synthesis PPA components, each normalized to the unoptimized input v0v_0, (1) FoM=areaarea0⋅powerpower0⋅delaydelay0FoM\;=\; areaarea_0· powerpower_0· delaydelay_0 The normalization fixes FoM(v0)=1FoM(v_0)=1, and a lower FoM is better. Because all three components enter the product, an edit that trades one component for another is judged on its net effect. The FoM records how deep an optimizer reaches, not what reaching that depth costs, and that difference accumulates into cost because the effort levels of one model are priced differently and a run spans dozens of iterations. Call counts and token counts are the two natural measures of that spend, and neither suffices. A call count treats effort levels of unequal price as one equivalent iteration, erasing a real difference in cost. A token count does distinguish the calls, but input, cached-input, reasoning, and output tokens carry different unit prices, and commercial tools bill in dollars, leaving token counts an indirect quantity the user must still convert. Ares therefore computes the normalized dollar cost of every LLM call and reports it next to the FoM, rather than just an aggregate total. The call’s logged input (in), cache read (cr), cache write (cw), and output token (out) counts (tit_i) are weighted by their published per-token OpenRouter prices (p) (OpenRouter, 2026b; Lumer et al., 2026), and the weighted sum is the call’s dollar cost. Summing the calls of a run gives its cumulative cost. The internal reasoning is included in the output tokens (OpenRouter, 2026a). (2) Cost=∑i=1N(pinti,in+pcrti,cr+pcwti,cw+poutti,out)Cost\;=\; _i=1^N (p_in\,t_i,in+p_cr\,t_i,cr+p_cw\,t_i,cw+p_out\,t_i,out ) Every cost axis in this paper reports that cumulative cost in high-calls, the dollars spent divided by the design’s mean computed cost of one high-effort call. Referring the cost to the design’s own high-effort price keeps comparisons unaffected by pricing changes, because whatever the underlying model charges, one high-call is always the price of one high-effort iteration on that design. It is also why cumulative cost, rather than a cumulative call or token count, is the abscissa of every figure below. This per-call accounting goes beyond the single aggregate of prior work (Fang et al., 2026) and the turn-count proxy of general-agent studies (Gao and Peng, 2026). 3.2. Revisit the value of memory construction With this accounting, we test at equal spend the claim of prior work that cross-design long-term memory construction dictates the quality of the optimizer. That attribution, made from distilled rule libraries to manager-curated entry pools (Fang et al., 2026; Wang et al., 2026; Zhang et al., 2026; Zhou et al., 2026), rests on comparisons of the final FoM, and need not hold at equal spend. The agent draws on two memories. The short-term memory is the conversation of the current run. Every iteration resumes the same session and re-feeds its history to the LLM (Gao and Peng, 2026), and the record is discarded when the run ends. The long-term memory is the experience accumulated across designs, a markdown document distilled from training designs and injected into the agent’s prompt, so that a strategy learned on one design can be reused on another. To test if construction decides the outcome, we hold everything else fixed and vary only how the same experience is written down, across three memory-mode variants built from one identical pool of raw experience. 1 The memoryless agent lacks a long-term memory. It still learns within a design, but starts each new design from scratch. 2 The baseline memory distills each training run into a list of simple descriptions of the optimizations that worked on that design and concatenates those lists. 3 The engineered memory uses the same experience and creates a superset that incorporates all prior works’ techniques. In this rule superset, 1) each accepted edit is recorded as a structured (context, action, result) case (Guo et al., 2024; Zhou et al., 2025), 2) ineffective and harmful edits are kept as explicit anti-optimizations to avoid (Fang et al., 2026), and 3) duplicate entries are merged across designs and the remainder ranked by measured effectiveness (Wang et al., 2026; Zhou et al., 2026; Zhang et al., 2026). Unlike prior work’s annotations at the structural or skill level (Fang et al., 2026; Wang et al., 2026; Zhang et al., 2026; Zhou et al., 2026), Ares further anonymizes design-specific names, so that a rule matches on the structure of a problem rather than on its source. Starting from identical raw experience, both memory-carrying variants run a full agent optimization per training design and log each edit’s FoM effect. Consequently, any FoM difference between them stems solely from how this experience is recorded. As Fig. 2 shows (setups in Sec. 3.1 and 4), accumulated experience successfully lowers FoM, with both memory variants typically ending below the memoryless baseline. At equal cost, however, the engineered memory ( 3) brings no dependable gain over the plain concatenation. On all three held-out test designs the two curves descend together and end close, with neither ahead consistently. This means the structuring, deduplication, and abstraction that prior work invests add nothing on these designs beyond what the baseline concatenation already delivers. What decides the quality of an edit is thus not how much experience is fed to the LLM, which moves us to examine the optimization process from another angle. Figure 2. The three memory constructions of Sec. 3.2 on the three test designs, best FoM (normalized to v0v_0, lower is better) against cumulative cost in high-calls, the unit of Sec. 3.1. Each bold curve is the mean over three faint individual runs, all using medium reasoning effort. The engineered memory brings no dependable gain over the baseline concatenation. 3.3. Steer the per-call reasoning effort The other input condition that actually varies between iterations is how deeply a call is allowed to think. It bears directly on the cost view of Sec. 3.1. The price gap between the effort levels is what makes cost-aware accounting necessary in the first place, and that same gap means the reasoning effort is not only a spend to account for but a variable the optimizer can steer. We therefore investigate the per-call reasoning effort. Every iteration is one LLM call, and the effort, exposed at three levels, sets how much hidden reasoning that call performs and what it costs. At low effort the LLM reasons little before emitting its edit, at high effort it reasons at length, and medium sits between. Changing the level between iterations leaves the conversation, the long-term memory, and the prompt cache untouched (Lumer et al., 2026). Which level an iteration deserves is not known in advance. An opening iteration with obvious inefficiencies left to remove is well served by a cheap call, while a run stuck at the same best FoM for many iterations may need more thinking, and thus a higher reasoning effort, to improve further. MEDIUMHIGHcounter C≥pC≥ pdischargeimproveC→C(1−ΔFoM/κ)C\!→\!C(1- /κ)stall +1+1, fail +w+w Figure 3. The adaptive-effort policy, with constants (p=3p=3, w=2.8w=2.8, κ=0.05κ=0.05) fit once on the training designs. Ares therefore starts every design at medium effort, the dependable middle setting in the fixed-effort comparison of Sec. 5.1, and escalates to high effort only once medium has stalled. We call an iteration stalled when its candidate synthesizes and verifies but does not lower the FoM, and failed when it does not even produce a valid candidate, which could be because the edit does not compile, synthesize, or verify. A single stalled iteration is a noisy signal, because even a productive run rejects most of its candidates. Ares instead accumulates the evidence in a patience counter C, updated after every iteration as follows. • A stalled iteration adds one, C→C+1C→ C+1. • A failed iteration adds a weight w, C→C+wC→ C+w. • An accepted improvement discharges the counter proportionally to its relative FoM gain using a reset scale κ. Writing the relative gain of an accepted edit as ΔFoM=(FoMbest−FoMnew)/FoMbest =(FoM_best-FoM_new)/FoM_best, the discharge is C→C⋅max⁡(0, 1−ΔFoM/κ)C→ C· (0,\,1- /κ). A relative gain of at least κ clears the counter fully, while a marginal gain barely lowers it. A run that improves marginally therefore still escalates. When C reaches the patience threshold p, the next iteration runs at high effort and the counter resets, the two-state policy is shown in Fig. 3. We fit p, w, and κ jointly, once, on the medium-effort runs of the training designs. The policy should escalate exactly where staying at medium would no longer pay. On the recorded runs, an escalation is warranted at an iteration where medium produces no accepted improvement within the next three iterations, and wasted where it does. We grid-search the three constants to catch as many warranted points as possible while keeping at least 90% of fired escalations warranted. This returns p=3p=3, w=2.8w=2.8, and κ=0.05κ=0.05, catching 94% of the warranted points. That the fitted failure weight exceeds one is interesting, as the training runs treat one failed edit like almost three stalled ones. This can be understood by what each event reveals. A stalled iteration still produces a valid candidate, and its missing gain may reflect a near-miss of a sound strategy. A failed iteration produces no valid candidate, which could be evidence that the LLM needs more thinking to properly implement an optimization. 4. Experimental Setup Figure 4. The three fixed effort levels and the adaptive policy of Sec. 3.3 on the three test designs, with axes, unit, and curve styles as in Fig. 2. Dataset. We evaluate on 24 single, self-contained open-source RTL modules of a few hundred to a few thousand lines: 19 of the 20 designs of Dr. RTL (Fang et al., 2026) (its LSTM module is excluded for its inferred memories), an FFT butterfly and a Huffman decoder from the RTLRewriter benchmark (Yao et al., 2024), and a CORDIC, a pipelined FFT, and a JPEG DCT from OpenCores (OpenCores, 2026). Three designs spanning the range of optimizability are held out as the test set: tv80, the arithmetic-logic unit of a Z80 core; uart, a serial transceiver; and controller, the control unit of an AES core. The remaining 21 designs form the training set: one optimization run over each gathers its accepted optimizations into the long-term memory, and the same runs fit the escalation constants. Sec. 5.3 additionally optimizes an open-source design introduced there, an MX multiply-accumulate unit (Cuyckens et al., 2025). Because the two long-term memory constructions perform equally, we use the engineered memory in all experiments of Sec. 5, as we find its structured rules are easier to read for humans. Testbench and verification. Verification and power analysis use a generated testbench of 10410^4 random input vectors from a fixed seed. Every iteration compares the candidate’s outputs, at RTL and on the synthesized netlist, against those of the unoptimized input design (Ping et al., 2026). Because random vectors cannot exercise every structure, equivalence to the input design is additionally guaranteed by formal sequential equivalence checking at RTL (JasperGold (Cadence Design Systems, 2025)), while the synthesized netlist is still verified with the testbench. Synthesis flow. PPA is measured with the commercial Synopsys Design Compiler and PrimeTime on the open-source Nangate 45 nm library (Nangate Inc., 2011). We use a commercial synthesizer because a weaker open-source one would credit the agent for rewrites a commercial tool applies on its own (Lu et al., 2026), and an open-source library so that no foundry data reaches the LLM. For each design the synthesizer first finds the shortest achievable clock period, the delay term of the FoM. The design is then resynthesized at this frequency to obtain area, and PrimeTime reports power from the switching activity of the testbench vectors simulated on that netlist (Min et al., 2026; Wang et al., 2026). LLM. Ares runs as an agent on the Claude Code command-line assistant (Anthropic, 2025), the same assistant Dr. RTL uses (Fang et al., 2026), on Opus 4.6 throughout, with extended thinking and prompt caching. A call that specifies no effort level runs at the assistant’s default, which is identical to selecting high (Anthropic, 2025). An effort schedule across iterations must therefore come from the optimizer. Because the LLM cannot be sampled with a fixed seed, each configuration is repeated multiple times. 5. Experiments 5.1. No fixed effort level fits the whole run The first experiment varies the fixed per-call reasoning effort of Sec. 3.3 on the three test designs, and Fig. 4 shows that the reasoning effort changes both what a run costs and how deep it optimizes. To ensure a fair comparison, we let every effort level run until it reaches a similar total cost. Only the low-effort runs stop below that cost, because the LLM reports it is out of optimization ideas. Low effort is also the weakest setting: it ends above medium on every design, and it is the least dependable: on controller it ends at a mean FoM of 0.82 where medium can reach 0.77, and on tv80 none of its runs ends below 0.84 where the best medium run reaches 0.71. High effort needs more cost than medium to reach the same FoM early in a run: its first successful optimizations land only after a cost of 4.6–7.1 high-calls, where medium cuts its first 5% of FoM within a cost of 0.9–3.9. The extra reasoning pays off only near the end of a run: fixed high ends considerably deeper than medium on tv80 (0.79 against 0.84), but on uart and controller, there is only a difference of 0.004 and 0.016. Medium sits in between: it makes progress earliest and ends deeper than low on every design, but it stalls on a plateau that more spending at medium does not escape, exactly the stall the adaptive policy exploits. 5.2. Adaptive effort beats fixed effort We next run the adaptive policy of Sec. 3.3, with the escalation constants p, w, and κ fixed once on the training designs rather than tuned per design. The policy starts every design at medium and is just as cheap early in a run: it cuts its first 5% of FoM within a cost of 0.9–3.0 high-calls, like fixed medium, where fixed high has not yet improved anything. As Fig. 4 shows, it then overtakes every fixed arm: it reaches the final FoM of fixed high sooner than fixed high itself on all three designs, on uart at 0.89× the cost, and descends beyond it to end deepest everywhere, at mean FoMs of 0.76, 0.77, and 0.73 against fixed high’s 0.79, 0.84, and 0.79. Across the three designs the adaptive policy lowers the input design’s FoM by 23–27% where the best fixed arm reaches 16–23%. The gain comes from targeting extra effort effectively. Once the fixed medium stalls, spending more on it fails to lower the FoM further, whereas the same cost under the adaptive policy succeeds. 5.3. Close the gap to hand-optimized design To test Ares where the optimization potential is known to be large, we select an open-source MX multiply-accumulate (MAC) unit whose published implementation is hand-optimized (MX_fp32) (Cuyckens et al., 2025). From its specification and testbench, Claude Opus 4.6 drafted MX_LLM, a functionally equivalent MAC, and Ares optimizes that draft toward the hand-optimized design on the unnormalized FoM, the absolute area-power-delay product, where the gap between the two is the improvement to recover. As Fig. 5 shows, Ares lowers MX_LLM’s FoM from 68.8 to a mean of 33.6 over six runs (deepest 27.5), closing up to 83% of the gap to MX_fp32’s published FoM of 18.9. The same optimizer improves the already hand-optimized MX_fp32 by only 16%, and more experience in the long-term memory, which here holds only the 21 training designs, would likely push the optimized draft deeper still. The same six runs measure the adaptive policy’s benefit over fixed medium run by run: each run is branched at its stall point into two continuations, one staying at medium and one following the adaptive policy, drawn dashed in the left panel of Fig. 5. The escalated continuation reaches a lower FoM for the same number of iterations in five of the six runs, and the sixth ends within 2% of its fixed-medium branch. The escalated iterations are more expensive, yet at the same cumulative cost the adaptive arm still typically sits at a lower FoM, lowering the mean from 42.1 to 33.6, as the right panel of Fig. 5 shows. The six runs also expose the run-to-run variance of such optimizers: from the same v0v_0, each fixed-medium run settles onto a plateau of its own, with endpoints scattered from 29.8 to 52.4 (std 8.9). The escalation helps the runs that lag behind most, dropping the three highest plateaus by 7.3 to 20.0 FoM points while the run that already reached 29.8 gains nothing. Because a designer pays per run, a dependable result from fixed medium requires several runs, exactly what the sampling and population strategies of prior optimizers do (Min et al., 2026; Ping et al., 2026). The adaptive policy achieves this dependability within a single run, cutting the run-to-run variance by 58% (std 8.9 to 5.8) and the endpoint band from 22.6 to 17.6 FoM points for a mean of 7.3 extra high-calls. A likely explanation is that the escalation lands exactly where a run is stuck, giving the lagging runs the deeper reasoning to leave their local minima. Figure 5. An LLM-created MX MAC optimized toward a human-optimized one (black). Left: six fixed-medium runs, each branching to a switch-to-high continuation (dashed) at its first stall point, the amber band marking the high-effort iterations. Right: the same runs averaged (mean± 1 std bands) for the fixed-medium and escalated arms. 5.4. Comparison with SotA optimizers Figure 6. Ares with adaptive effort, REvolution, and Dr. RTL optimizing controller from the same v0v_0 on the same flow, 25 candidates each, dots marking the verified ones. Dr. RTL’s timing-focused selection returns the annotated 0.923 and discards its ringed best candidate at 0.909. On a shared commercial tool flow and the FoM of Eq. 1, we compare Ares against REvolution (Min et al., 2026), the strongest evolutionary LLM-RTL framework that releases its code, adapted as an optimizer on our flow, and against the skill-library optimizer Dr. RTL (Fang et al., 2026) with its own memory file. All three optimize controller from the same v0v_0. As Fig. 6 shows, Ares reaches a FoM of 0.694 at a cost of about 15 high-calls. REvolution runs its population of five RTL candidates per iteration for five iterations, as many total designs as Ares’s 25 iterations, and stops at 0.943 at an equivalent cost of 10 high-effort calls on controller. We attribute this difference to REvolution lacking both mechanisms of Ares: its population stores candidates rather than distilled cross-design experience, and every call uses the same effort. Dr. RTL optimizes timing and area without power, and under the power-aware FoM the power its rewrites add cancels much of their timing gain: its selection returns 0.923, discarding its best candidate under that FoM, 0.909. It spends 8.7× Ares’s total over the same 25 iterations, computed from its transcripts. We attribute the high cost to its multi-agent pipeline: every iteration runs a critical-path analysis agent, several parallel rewrite agents, and an evaluation agent (Fang et al., 2026) per proposed design. 6. Conclusion We present Ares, an LLM-agent RTL optimizer that adapts its per-call reasoning effort with a patience counter and computes the normalized dollar cost of every LLM call alongside the FoM it reaches. Its central finding is that the quality and cost of such an optimizer are set not by how its long-term memory is written but by where its reasoning is spent. Escalating effort only where medium effort stalls lowers the input design’s FoM by 23–27% where the best fixed effort reaches 16–23%. The same optimizer closes up to 83% of the gap from an LLM draft to a hand-optimized multiply-accumulate unit and reaches a lower FoM than prior optimizers with 12% of the tokens of the strongest. References (1) Abdelatty et al. (2025) Manar Abdelatty, Maryam Nouh, Jacob K. Rosenstein, and Sherief Reda. 2025. Pluto: A Benchmark for Evaluating Efficiency of LLM-generated Hardware Code. arXiv preprint arXiv:2510.14756 (2025). Alomrani et al. (2025) Mohammad Ali Alomrani, Yingxue Zhang, Derek Li, Qianyi Sun, Soumyasundar Pal, Zhanguang Zhang, Yaochen Hu, Rohan Deepak Ajwani, Antonios Valkanas, Raika Karimi, Peng Cheng, Yunzhou Wang, Pengyi Liao, Hanrui Huang, Bin Wang, Jianye Hao, and Mark Coates. 2025. Reasoning on a Budget: A Survey of Adaptive and Controllable Test-Time Compute in LLMs. arXiv preprint arXiv:2507.02076 (2025). Anthropic (2025) Anthropic. 2025. Claude Code. https://code.claude.com/docs/en/overview. Cadence Design Systems (2025) Cadence Design Systems. 2025. JasperGold Formal Verification Platform. https://w.cadence.com/en_US/home/tools/system-design-and-verification/formal-and-static-verification/jasper-verification-platform.html. Chen et al. (2024) Lingjiao Chen, Matei Zaharia, and James Zou. 2024. FrugalGPT: How to Use Large Language Models While Reducing Cost and Improving Performance. Transactions on Machine Learning Research (TMLR) (2024). Chen et al. (2026) Yuxi Chen, Junming Chen, Chenyu He, Yiwei Li, Yicheng Ji, Yifan Wu, Dingyu Yang, Lansong Diao, Lidan Shou, Hongliang Zhang, Huan Li, and Gang Chen. 2026. Token Economics for LLM Agents: A Dual-View Study from Computing and Economics. arXiv preprint arXiv:2605.09104 (2026). Cuyckens et al. (2025) Stef Cuyckens, Xiaoling Yi, Nitish Satya Murthy, Chao Fang, and Marian Verhelst. 2025. Efficient Precision-Scalable Hardware for Microscaling (MX) Processing in Robotics Learning. In Proceedings of the IEEE/ACM International Symposium on Low Power Electronics and Design (ISLPED). Fang et al. (2025) Wenji Fang, Mengming Li, Min Li, Zhiyuan Yan, Shang Liu, Hongce Zhang, and Zhiyao Xie. 2025. AssertLLM: Generating and Evaluating Hardware Verification Assertions from Design Specifications via Multi-LLMs. In Proceedings of the Asia and South Pacific Design Automation Conference (ASP-DAC). Fang et al. (2026) Wenji Fang, Yao Lu, Shang Liu, Jing Wang, Ziyan Guo, Junxian He, Fengbin Tu, and Zhiyao Xie. 2026. Dr. RTL: Autonomous Agentic RTL Optimization through Tool-Grounded Self-Improvement. arXiv preprint arXiv:2604.14989 (2026). Gandhi et al. (2024) Shubham Gandhi, Manasi Patwardhan, Lovekesh Vig, and Gautam Shroff. 2024. BudgetMLAgent: A Cost-Effective LLM Multi-Agent System for Automating Machine Learning Tasks. In Proceedings of the 4th International Conference on AI-ML Systems (AIMLSystems). Gao and Peng (2026) Pengfei Gao and Chao Peng. 2026. More with Less: An Empirical Study of Turn-Control Strategies for Efficient Coding Agents. In Proceedings of the IEEE/ACM International Conference on Software Engineering (ICSE). Guo et al. (2024) Siyuan Guo, Cheng Deng, Ying Wen, Hechang Chen, Yi Chang, and Jun Wang. 2024. DS-Agent: Automated Data Science by Empowering Large Language Models with Case-Based Reasoning. In Proceedings of the International Conference on Machine Learning (ICML). Ho et al. (2025) Chia-Tung Ho, Haoxing Ren, and Brucek Khailany. 2025. VerilogCoder: Autonomous Verilog Coding Agents with Graph-based Planning and Abstract Syntax Tree (AST)-based Waveform Tracing Tool. In Proceedings of the AAAI Conference on Artificial Intelligence (AAAI). Jin et al. (2025) Bowen Jin, TJ Collins, Donghan Yu, Mert Cemri, Shenao Zhang, Mengyu Li, Jay Tang, Tian Qin, Zhiyang Xu, Jiarui Lu, Guoli Yin, Jiawei Han, and Zirui Wang. 2025. Controlling Performance and Budget of a Centralized Multi-agent LLM System with Reinforcement Learning. arXiv preprint arXiv:2511.02755 (2025). Li et al. (2026) Yushu Li, Wenlong Deng, Jiajin Li, and Xiaoxiao Li. 2026. Spend Less, Reason Better: Budget-Aware Value Tree Search for LLM Agents. arXiv preprint arXiv:2603.12634 (2026). Liu et al. (2023a) Mingjie Liu, Teodor-Dumitru Ene, Robert Kirby, Chris Cheng, Nathaniel Pinckney, Rongjian Liang, Jonah Alben, Himyanshu Anand, Sanmitra Banerjee, Ismet Bayraktaroglu, Bonita Bhaskaran, Bryan Catanzaro, Arjun Chaudhuri, Sharon Clay, Bill Dally, Laura Dang, Parikshit Deshpande, Siddhanth Dhodhi, Sameer Halepete, Eric Hill, Jiashang Hu, Sumit Jain, Ankit Jindal, Brucek Khailany, George Kokai, Kishor Kunal, Xiaowei Li, Charley Lind, Hao Liu, Stuart Oberman, Sujeet Omar, Ghasem Pasandi, Sreedhar Pratty, Jonathan Raiman, Ambar Sarkar, Zhengjiang Shao, Hanfei Sun, Pratik P Suthar, Varun Tej, Walker Turner, Kaizhe Xu, and Haoxing Ren. 2023a. ChipNeMo: Domain-Adapted LLMs for Chip Design. arXiv preprint arXiv:2311.00176 (2023). Liu et al. (2023b) Mingjie Liu, Nathaniel Pinckney, Brucek Khailany, and Haoxing Ren. 2023b. VerilogEval: Evaluating Large Language Models for Verilog Code Generation. In Proceedings of the IEEE/ACM International Conference on Computer-Aided Design (ICCAD). Liu et al. (2024) Shang Liu, Wenji Fang, Yao Lu, Qijun Zhang, Hongce Zhang, and Zhiyao Xie. 2024. RTLCoder: Outperforming GPT-3.5 in Design RTL Generation with Our Open-Source Dataset and Lightweight Solution. In 2024 IEEE LLM Aided Design Workshop (LAD). 1–5. Lu et al. (2024) Yao Lu, Shang Liu, Qijun Zhang, and Zhiyao Xie. 2024. RTLLM: An Open-Source Benchmark for Design RTL Generation with Large Language Model. In Proceedings of the Asia and South Pacific Design Automation Conference (ASP-DAC). Lu et al. (2026) Yao Lu, Shang Liu, Hangan Zhou, Wenji Fang, Qijun Zhang, and Zhiyao Xie. 2026. A New Benchmark for the Appropriate Evaluation of RTL Code Optimization. arXiv preprint arXiv:2601.01765 (2026). Lumer et al. (2026) Elias Lumer, Faheem Nizar, Akshaya Jangiti, Kevin Frank, Anmol Gulati, Mandar Phadate, and Vamse Kumar Subbiah. 2026. Don’t Break the Cache: An Evaluation of Prompt Caching for Long-Horizon Agentic Tasks. arXiv preprint arXiv:2601.06007 (2026). Min et al. (2026) Kyungjun Min, Kyumin Cho, Junhwan Jang, and Seokhyeong Kang. 2026. REvolution: An Evolutionary Framework for RTL Generation Driven by Large Language Models. In Proceedings of the Asia and South Pacific Design Automation Conference (ASP-DAC). Nangate Inc. (2011) Nangate Inc. 2011. NanGate FreePDK45 Open Cell Library. https://si2.org/open-cell-library/. OpenCores (2026) OpenCores. 2026. OpenCores: Open Source IP Cores. https://opencores.org. OpenRouter (2026a) OpenRouter. 2026a. OpenRouter Documentation: Reasoning Tokens. https://openrouter.ai/docs/use-cases/reasoning-tokens. OpenRouter (2026b) OpenRouter. 2026b. OpenRouter Models: Model and Pricing Index. https://openrouter.ai/models. Pan et al. (2025) Jingyu Pan, Guanglei Zhou, Chen-Chia Chang, Isaac Jacobson, Jiang Hu, and Yiran Chen. 2025. A Survey of Research in Large Language Models for Electronic Design Automation. ACM Transactions on Design Automation of Electronic Systems (TODAES) 30, 3 (2025). Ping et al. (2026) Heng Ping, Peiyu Zhang, Zhenkun Wang, Shixuan Li, Anzhe Cheng, Wei Yang, Paul Bogdan, and Shahin Nazarian. 2026. POET: Power-Oriented Evolutionary Tuning for LLM-Based RTL PPA Optimization. arXiv preprint arXiv:2603.19333 (2026). Pulavarthi et al. (2025) Vaishnavi Pulavarthi, Deeksha Nandal, Soham Dan, and Debjit Pal. 2025. AssertionBench: A Benchmark to Evaluate Large-Language Models for Assertion Generation. In Findings of the Association for Computational Linguistics: NAACL 2025. 8073–8080. Shi et al. (2026) Zhengyuan Shi, Jingxin Wang, Tairan Cheng, Changran Xu, Weikang Qian, and Qiang Xu. 2026. CktEvo: Repository-Level RTL Code Benchmark for Design Evolution. arXiv preprint arXiv:2603.08718 (2026). Snell et al. (2025) Charlie Victor Snell, Jaehoon Lee, Kelvin Xu, and Aviral Kumar. 2025. Scaling LLM Test-Time Compute Optimally Can be More Effective than Scaling Parameters for Reasoning. In The Thirteenth International Conference on Learning Representations (ICLR). Tsai et al. (2024) Yun-Da Tsai, Mingjie Liu, and Haoxing Ren. 2024. RTLFixer: Automatically Fixing RTL Syntax Errors with Large Language Models. In Proceedings of the ACM/IEEE Design Automation Conference (DAC). Wang et al. (2026) Yaoxiang Wang, Qi Shi, ShangZhan Li, Qingguo Hu, Xinyu Yin, Bo Guo, Xu Han, Maosong Sun, and Jinsong Su. 2026. VeriAgent: A Tool-Integrated Multi-Agent System with Evolving Memory for PPA-Aware RTL Code Generation. arXiv preprint arXiv:2603.17613 (2026). Yao et al. (2024) Xufeng Yao, Yiwen Wang, Xing Li, Yingzhao Lian, Ran Chen, Mingxuan Yuan, Hong Xu, and Bei Yu. 2024. RTLRewriter: Methodologies for Large Models aided RTL Code Optimization. In Proceedings of the IEEE/ACM International Conference on Computer-Aided Design (ICCAD). Zhang et al. (2026) Haozhen Zhang, Quanyu Long, Jianzhu Bao, Tao Feng, Weizhi Zhang, Haodong Yue, and Wenya Wang. 2026. MemSkill: Learning and Evolving Memory Skills for Self-Evolving Agents. arXiv preprint arXiv:2602.02474 (2026). Zhang et al. (2025) Zixi Zhang, Balint Szekely, Pedro Gimenes, Greg Chadwick, Hugo McNally, Jianyi Cheng, Robert Mullins, and Yiren Zhao. 2025. LLM4DV: Using Large Language Models for Hardware Test Stimuli Generation. In 2025 IEEE 33rd Annual International Symposium on Field-Programmable Custom Computing Machines (FCCM). 133–137. Zhou et al. (2025) Huichi Zhou, Yihang Chen, Siyuan Guo, Xue Yan, Kin Hei Lee, Zihan Wang, Ka Yiu Lee, Guchun Zhang, Kun Shao, Linyi Yang, and Jun Wang. 2025. Memento: Fine-tuning LLM Agents without Fine-tuning LLMs. arXiv preprint arXiv:2508.16153 (2025). Zhou et al. (2026) Huichi Zhou, Siyuan Guo, Anjie Liu, Zhongwei Yu, Ziqin Gong, Bowen Zhao, Zhixun Chen, Menglong Zhang, Yihang Chen, Jinsong Li, Runyu Yang, Qiangbin Liu, Xinlei Yu, Jianmin Zhou, Na Wang, Chunyang Sun, and Jun Wang. 2026. Memento-Skills: Let Agents Design Agents. arXiv preprint arXiv:2603.18743 (2026).

Instant research discovery