A chip's power grid is a mesh of thin wires that carries current to billions of transistors. When many of those transistors switch in the same clock cycle and the same region of the die, the local supply voltage sags. Logic slows down, and timing can fail. Engineers call this dynamic IR drop. How bad it gets depends on the exact sequence of inputs the chip receives. Today that sequence is rarely chosen on purpose. Fast neural estimators of IR drop are fed either random input vectors or "vectorless" statistical activity assumptions, and both are known to miss the true worst case or to raise false alarms. Meanwhile, the AI systems that write hardware tests optimize only for logical coverage: did every line, branch, and toggle get exercised. Nobody asks whether a test makes the power grid collapse.
We propose to treat worst-case supply noise as a verification target. The core object is a legal power virus: an input sequence that obeys the design's interface protocol, so the chip could actually see it in the field, and that maximizes peak local voltage drop. A small team of language-model agents will find these sequences. One agent reads the RTL (the register-transfer-level source code that describes the circuit) together with a coarse floorplan and proposes which units should fire together, and in which cycle. A second agent writes a parameterized stimulus program from that plan. An ordinary numerical optimizer then tunes the program's knobs against a fast learned IR-drop model. A protocol checker rejects illegal sequences, and an auditor decides when to spend a costly ground-truth power-grid simulation. The bet is specific. On designs whose high-activity states take many cycles of protocol-respecting setup to reach, this split between language models that supply structure and numerical search that supplies fine tuning will find larger verified, legal voltage drops than black-box search or a single monolithic model, within the same simulation budget.
Core Claim
We frame the problem as constrained maximization over input sequences. Let $s$ be a multi-cycle input sequence, $\mathcal{L}$ the set of sequences the interface protocol permits, and $V_{t,c}(s)$ the voltage drop at grid tile $t$ in cycle $c$ when the design runs $s$. We seek
$$s^\star = \arg\max_{s \in \mathcal{L}} \; \max_{t,c} V_{t,c}(s),$$
with ground-truth evaluation of $V$ costing hours per call, and a learned surrogate $\hat V$ costing milliseconds.
The claim has two parts, and either could fail. First, the legality constraint is what makes the problem hard and interesting. Unconstrained search will happily find bit patterns that no real system issues, and those inflate the apparent worst case. Second, good solutions inside $\mathcal{L}$ often require coordinated multi-cycle setup: filling a FIFO, aligning two pipelines, or issuing back-to-back bursts so that physically adjacent units switch in the same cycle. That kind of structure is easier to propose in code than to discover by mutating bits. If the second part is false, black-box search with a legality filter should match our system, and we will report that.
Where This Sits
The gap is well documented on both sides. On the power side, three generations of surrogates evaluate a given current profile. PowerNet runs a max-pooling CNN over time-sliced power maps. Worst-case dynamic PDN noise prediction compresses current vectors and reaches sub-millivolt mean error on 500 randomly generated vector groups per design. PDNNet pairs a graph network over the grid topology with a 3D CNN over switching currents and runs 545× faster than the Voltus sign-off solver. All three take the excitation as given, so they motivate our work: they show the evaluator is cheap, while the excitation is still random or vectorless. They also constrain it. The worst-case paper reports high relative error on low-switching tiles, which warns us that an optimizer may exploit surrogate error rather than real physics.
On the verification side, LLM4Cov, TB or Not TB (CD-DPO), and CHORUS train compact models to write high-coverage stimulus, using execution-guided fine-tuning, coverage-weighted preference learning, and multi-teacher distillation respectively. We reuse their execution-in-the-loop discipline but replace the coverage objective with a physical one. They never measure electrical consequences.
On the agent side, DRC-Coder splits layout-rule checking into a vision-language Planner and a Programmer that are checked against a commercial engine. ReChisel adds a reviewer and an escape mechanism for non-progress loops. CorrectBench validates testbenches with a jury of generated designs. These papers supply the decomposition pattern, and none of them touches the power grid. ArchAgent contributes a cautionary result: agents coupled to a simulator found loopholes in it. We expect the same against a learned surrogate and design the auditor around that.
The closest cross-stage work is CircuitNet 3.0. It links RTL, netlist, and layout for passive prediction of timing and total power, but carries no cycle-level switching or dynamic IR traces. We use it as a source of RTL-to-layout-traceable designs, not as a competitor.
Research Program
The system has five roles, and only some of them are language models.
The Planner is given the RTL, the module-to-region map from placement, and distance-to-power-bump features of the kind used in the worst-case paper. It writes stress hypotheses in plain text, for example: "fire the multiplier array and the adjacent register file write port in the same cycle, after the input FIFO is full."
The Writer turns a hypothesis into an executable stimulus program. The program respects the protocol by construction and exposes numeric knobs such as data patterns, burst lengths, inter-unit phase offsets, and idle-then-burst timing that drives a sharp current step.
The Tuner is not a language model. It runs a standard evolutionary or Bayesian search over the knobs, using a PDNNet-style surrogate as the fitness function.
The Legality Critic runs each candidate through protocol monitors and assertions, and rejects any candidate that violates them.
The Auditor chooses which candidates earn a ground-truth sign-off solve. It favors high surrogate score combined with high disagreement across a surrogate ensemble. Sign-off results are fed back to the Planner, and periodically used to fine-tune the surrogate on the distribution the search actually visits.
We will retrain or fine-tune the surrogate on vector-driven traces from our own designs. Dynamic traces with matched RTL do not exist in the public datasets in the file, so building and releasing them is a contribution in its own right.
Two design questions are tested rather than assumed. The first is memory. LLM4Cov found conversational history distracting in testbench repair, while ReChisel needs history to escape loops. Our Planner keeps only a compact table of tested hypotheses and their verified scores, and we ablate this against full-transcript and memoryless variants. The second is where the language model's contribution actually lives. Our hypothesis is that it lies in the structure of the program, not in the specific knob values the Tuner later sets, and the ablations below isolate this.
Baselines
The naive reference reproduces the protocol of Worst-case dynamic PDN noise prediction: 500 random vector groups per design, here filtered for legality. We also run each design's existing functional testbench. Both report the maximum drop found. This is the industry status quo, and beating it is necessary but not impressive.
The vectorless reference uses PowerNet in vectorless mode. It gives a pessimistic upper estimate with no sequence attached. We will report how many of its hotspots any legal sequence actually reaches; that count is a direct measure of vectorless false alarms.
The coverage reference asks whether existing verification stimulus already finds the worst case. We generate high-coverage testbenches with an LLM4Cov- or CHORUS-style model and measure their peak drop. CHORUS reports 88.0% Pass@1 on CVDP-ECov, and LLM4Cov reports a 69.2% pass rate with 90.4% average coverage. Those are coverage numbers, not noise numbers. We found no reported result on Lacuna for the peak dynamic IR drop elicited by generated stimulus on any benchmark.
The strongest competitor is legality-filtered black-box search: a genetic algorithm that mutates input bits per cycle, rejects illegal sequences with the same Critic, and scores candidates with the same surrogate. A variant also lets it mutate the knobs of a hand-written generic stimulus template. It is the strongest competitor because it already has everything our system has except the language models: the same fitness function, the same legality filter, and a well-understood ability to exploit a cheap evaluator.
The single-agent baseline is one frontier model with a long context that sees the RTL, the floorplan, and surrogate feedback, and iterates. This tests decomposition against capability.
Fairness is enforced by identical budgets. Every method receives the same surrogate-query budget (planned at a few thousand per design), the same number of ground-truth sign-off solves (planned at about twenty per design), the same legality checker, and equal hyperparameter tuning effort on a separate set of development designs. Our system beats the genetic search if, on held-out designs, its best sign-off-verified, legal drop is higher by more than the across-seed spread. A larger drop alone does not count as a win; the drop must also come at equal or better legality rate.
The ablations isolate the key ingredient. We remove the floorplan input to the Planner. We freeze the Writer's knobs, so there is no Tuner. We let the Tuner search a generic template, so there is no Writer. We remove the Auditor's disagreement term. The no-Writer ablation is the crucial one: if it matches the full system, the language models add nothing beyond template design.
Why not just…?
Why not just run a genetic algorithm or fuzzer against the fast surrogate? This is the real threat. It could plausibly win on shallow or combinational designs, where high activity is one input pattern away. We do not argue around it; it is our main baseline, and it shares our legality filter. We predict it loses on sequential designs, where reaching a peak-coincidence state takes many cycles of legal setup that random mutation rarely assembles. The comparison is stratified by the setup depth required, measured by the cycles from reset to the worst state found by any method. A tie at depth one together with a gap at depth ten or more would support the claim. A tie everywhere would refute it.
Why not just use SAT, SMT, or ATPG to maximize toggling? Toggle count is a proxy that ignores where the switching happens relative to the grid and power bumps, and the IR-drop literature exists precisely because spatial and temporal locality matter. Formal sequential search also runs into state explosion on deep designs, as noted in Learning Semantic Representations to Verify Hardware Designs and Neural Model Checking. On the smaller designs in our set we will still include a bounded-model-checking toggle maximizer as a further reference. Our expectation is that it reaches maximal toggle counts without reaching maximal localized drop.
Why not just prompt one strong model with everything? Prior hardware-agent results favor decomposition. DRC-Coder reports F1 rising from 0.631 under zero-shot prompting to 1.000 with Planner and Programmer, and ReChisel reports Pass@1 rising from 33.33% to 84.98% with reflection agents. Those results come from different tasks, though, so our single-agent baseline with an equal budget decides the question here.
Why not just reuse existing high-coverage testbenches? Coverage is satisfied once each toggle happens at least once. Peak noise needs many toggles at once, in one place. The coverage baseline measures directly how far apart those two objectives are.
Proposed Experiments
Designs come from CVDP-ECov repositories, which have human-written testbenches from which protocol monitors can be derived, and from CircuitNet 3.0 base designs, which have RTL-to-layout traceability at 45nm. We restrict to designs with clear interface protocols, accept the manual cost of writing monitors where none exist, and split designs into development and held-out sets. Each design is placed with its power grid, and a reference sign-off dynamic IR solve, of the kind PDNNet benchmarks against, provides ground truth.
The primary metric is the best sign-off-verified peak drop in millivolts among legal sequences. Secondary metrics are the number of distinct hotspot tiles exceeding a margin, the legality rate of candidates, the gap between surrogate-predicted and verified drop for each method's chosen candidates, and wall-clock and token cost.
Three checks decide the outcome. First, the full system against legality-filtered genetic search, stratified by setup depth, at equal budgets. Second, the no-Writer ablation, to show the language models contribute structure rather than search. Third, the surrogate-exploitation check. For every method, we verify the top surrogate candidates with sign-off and report the inflation between predicted and verified drop. A method that wins on the surrogate but loses after sign-off has learned the surrogate's blind spots, much like ArchAgent's simulator loopholes, and not the chip's.
References
- PowerNet: Transferable Dynamic IR Drop Estimation via Maximum Convolutional Neural Network
- Worst-case dynamic power distribution network noise prediction using convolutional neural network
- PDNNet: PDN-Aware GNN-CNN Heterogeneous Network for Dynamic IR Drop Prediction
- LLM4Cov: Execution-Aware Agentic Learning for High-coverage Testbench Generation
- TB or Not TB: Coverage-Driven Direct Preference Optimization for Verilog Stimulus Generation
- CHORUS: Complementary Experts for High-Coverage Testbench Stimulus Generation
- DRC-Coder: Automated DRC Checker Code Generation Using LLM Autonomous Agent
- ReChisel: Effective Automatic Chisel Code Generation by LLM with Reflection
- CorrectBench: Automatic Testbench Generation with Functional Self-Correction using LLMs for HDL Design
- ArchAgent: Agentic AI-driven Computer Architecture Discovery
- CircuitNet 3.0: A Multi-Modal Dataset with Task-Oriented Augmentation for AI-Driven Circuit Design
- Learning Semantic Representations to Verify Hardware Designs
- Neural Model Checking