betaFeedback

WorksComputer Science

GRODE-RTL: Source-Mapped Dependency Views for LLM-Based RTL Repair

Abstract

Large Language Models show great potential for automated Register-Transfer Level repair, yet they struggle with non-local faults where root causes and failing outputs reside far apart in source code. Treating RTL as a flat token sequence obscures hardware dataflows, whereas exposing complete synthesized graphs overwhelms the model with fine-grained metadata. To resolve this representation dilemma, we propose GRODE-RTL, an anchor-centric representation that extracts the single-clock-stage fan-in cone of a suspect register from the netlist, maps netlist nodes back to editable source lines, and organizes them into a compact hop-partitioned dependency view. By prioritizing direct drivers and folding distant hops, GRODE-RTL guides standard tool-using agents without exposing ground-truth hints or oracle feedback. We evaluate GRODE-RTL across 30 formally validated non-local faults using three LLMs (DeepSeek-V4-Flash, GLM-5.2, and MiniMax-M3) alongside a controlled six-configuration ablation study. GRODE-RTL improves pass@1 over source-level exploration by 16.7% on DeepSeek, by 26.7% on GLM-5.2, and by 20.0% on MiniMax-M3, with consistent gains on the hard-to-retrieve far-distance and indirect-anchor subsets of all three models. Our controls isolate structural relevance from generic context expansion, proving that selective dependency organization rather than full graph exposure is key to effective RTL repair.

Introduction

LLM-based agents debug software with human-level competence, yet this success only partially transfers to Register-Transfer Level (RTL) designs due to non-local faults. In RTL, a divergent output and its offending statement often lie hundreds of lines apart, separated across module boundaries, deeply nested conditional chains, or long dependency paths. While local bugs confined to narrow code windows are easily resolved by LLMs, hardware concurrency and pipelining mean the vast majority of real-world RTL bugs are inherently non-local. Resolving this dominant fault class is thus essential for viable automated hardware repair.

Repairing a non-local RTL fault requires bridging a long causal gap from an observable failure to the source statement that must be edited. This process involves three distinct stages: localizing a suspicious signal from the failing behavior (Sep idband et al., 2026a;b), reconstructing the static dependencies from that signal to its potential source-level causes, and generating and validating a patch. Existing repair methods primarily strengthen the two ends of this process. Feedback-driven approaches use compiler, simulation, or sequential-behavior feedback to generate and refine candidate patches (Santiesteban et al., [10]; Du et al., [3]; Thakur et al., 2024), while trace-based approaches use execution behavior to narrow failures to suspicious signals or registers (Wang et al., 2026).

However, neither line of work explicitly constructs the intermediate repair context required by non-local faults. Sequential feedback reveals whether and when candidate behavior diverges, but does not expose which distant source statements statically influence the suspicious signal. Signal-level localization identifies an anchor, but still leaves the agent to search across modules, conditional chains, and dependency paths for an editable root cause. The agent must therefore bridge behavioral evidence and source-level repair locations using either flat RTL text or a raw netlist, leading to a representation dilemma (Figure 1): (1) Layout–Behavior Mismatch in Flat Source. RTL text is organized by layout rather than dataflow. Expanding contiguous source windows to capture distant drivers introduces irrelevant code, exacerbating needle-in-a-haystack localization problems. (2) The Graph Representation Dilemma. Exposing full netlists captures dependencies but inflates context with low-level metadata, obscuring editable source mappings and repair locations.

The representation dilemma for LLM-based non-local RTL repair

Figure 1. The representation dilemma for LLM-based non-local RTL repair. Left: Flat source obscures multi-hop dataflow dependencies across physical lines. Right: Passing raw netlists burdens LLMs with metadata, whereas GRODE-RTL extracts, organizes, and compresses fan-in logic into a source-mapped, compact view.

To bridge this gap, we propose GRODE-RTL, an anchor-centric, repair-oriented representation constructed via three key operations: (1) Relevant code filtering extracts the single-clock-stage fan-in cone of a suspicious anchor and maps netlist nodes back to editable RTL statements; (2) Explicit dependency organization orders statements by reverse-dependency depth and tags DATA, CONTROL, and STATE relations; and (3) Selective graph compression caps per-hop nodes and folds distant layers into unfoldable summaries.

Our main contributions are:

  • We expose the representation dilemma in non-local RTL repair, where flat source code lacks distant context while complete graphs overload LLM attention.

  • We present GRODE-RTL, a representation pipeline that combines source-mapped cone extraction to eliminate design noise with compact graph reorganization to focus LLM reasoning.

  • We demonstrate Pass@1 gains of up to +26.7 pp across three LLMs (reaching a 63.3% success rate), with ablations confirming that cone extraction drives the primary performance leap while structural compression optimizes efficiency and edit precision.

Related Work

Automated Repair for Hardware Designs. Automated hardware description language (HDL) repair originated with heuristic Search-Based Program Repair techniques such as CirFix ([10]), which applies genetic programming over line-level coverage. With the emergence of Large Language Models, LLM-based RTL repair frameworks have advanced from single-prompt repair and conversation-driven refinement like AutoChip (Thakur et al., 2024) to autonomous, tool-augmented debugging agents such as VeriPilot (Wang et al., 2026) and SeqFeed ([3]). However, SeqFeed’s sequential feedback (SeQuery and SeGraph) and VeriPilot’s golden-guided control-data-flow tracing expose temporal simulation behavior rather than reorganizing the static dependencies of the current buggy design. GRODE-RTL instead introduces an anchor-centric structural representation between the SAT witness and the editing tools, transforming formal netlist dependencies into an interactive, source-mapped view for the agent.

Program and Graph Representations for LLMs. Graph, dataflow, and control-flow abstractions are widely used to enrich program context for machine learning models, often via learned GNN embeddings [6, 5] (Veličković et al. 2018; Zhang et al. 2020). While effective for general code understanding, generic program graphs fail to capture hardware-specific state boundaries and clock-stage constraints. GRODE-RTL leverages these hardware properties by partitioning netlist fan-in cones into reverse-dependency hops, providing a human-readable and model-editable text view. Furthermore, our controlled ablations explicitly separate structural cone selection from generic context expansion.

Hardware Diagnosis and Netlist Representation Learning. Cone-of-influence (COI) reduction is a standard structural pruning technique in formal verification to bound target logic [2, 7, 4] (Velev & Bryant 2001). Concurrently, circuit representation learning (CRI) methods such as DeepGate variants [8] (Shi et al. 2023; Zheng et al. 2025; Wang et al. 2025) embed netlist structures to predict testability or equivalence. However, classical COI operates strictly within formal solver engines, while neural netlist embeddings lack direct source-level mapping for code modification. GRODE-RTL bridges this gap by mapping netlist-level COI logic back to Verilog source statements, transforming formal structural reductions into an interactive context for LLM repair agents.

Method

Figure 2 outlines the architecture of GRODE-RTL. To address unstructured source-level debugging, GRODE-RTL extracts the anchor’s single-clock-stage fan-in cone from the synthesized netlist, organizes dependencies by reverse-depth, and compresses them into a compact, source-mapped structural view for the agent.

Figure 2. Overview of GRODE-RTL. A) Subgraph Extraction Synthesize buggy RTL and run reverse BFS from the anchor to recover the fan-in cone. B) Dependency Organization Partition the cone into per-hop levels L0,L1,…L_0, L_1, \ldots by reverse-dependency depth. C) Graph Compression Select representative statements per hop and cap depth into a compact structural view.

Problem Formulation

We define the problem of repairing a buggy RTL design. The agent receives the buggy Verilog source PbP_b, a counterexample waveform x∈{0,1}L×D\mathbf{x} \in\{0,1\}^{L \times D} over LL clock cycles and DD-bit bus width where PbP_b diverges, and a suspicious anchor register α\alpha. The anchor α=fsim(Pb,x)\alpha= f_{\mathrm{sim}}(P_b,\mathbf{x}) is deterministically extracted as the first upstream divergent sequential register during counterexample simulation, providing the entry point for structural analysis. The counterexample and anchor serve as behavioral evidence, allowing the agent to observe where the divergence manifests without revealing the underlying root cause. Within a budget of TT turns, the agent modifies a range of at most 20 lines in PbP_b to generate candidate P^\hat{P} via patch(), submitting via done() or terminating via abstain(). The agent edits raw RTL source directly, never the netlist, and complete file rewrites are prohibited.

Anchor-Centric Fan-In Extraction

We synthesize PbP_b via Yosys Wolf et al. (2013) into a netlist N=(Γ,W,src)N = (\Gamma, W, \mathrm{src}) of cells Γ\Gamma, wires WW, and source locations src:Γ∪W→Locations⁡(Pb)\mathrm{src} : \Gamma\cup W \to\operatorname{Locations}(P_b). From NN, we extract the statement cone governing the anchor’s next-state update.

State Boundary. Let B⊆WB \subseteq W be the set of Q-outputs of all sequential cells in NN. To enforce a standard single-clock-stage abstraction, the fan-in cone is defined as the closure of aa under combinational reverse dependencies without crossing BB. By bounding extraction at BB, GRODE-RTL targets intra-stage combinational non-locality within a single clock cycle, deferring multi-cycle temporal unrolling to future work.

Cone Traversal. Defining one-step dependency u⇝v⟺∃c∈Γ,v∈fanin⁡(c),u∈fanout⁡(c)u \leadsto v \Longleftrightarrow\exists c \in\Gamma, v \in\operatorname{fanin}(c), u \in\operatorname{fanout}(c), the anchor’s fan-in cone C(a)C(a) is:

C(a)={w∈W∣a⇝∗w, no element of B on the path},(1)C(a) = \{w \in W \mid a \leadsto^{*} w,\ \text{no element of } B \text{ on the path}\}, \tag*{(1)}

where ⇝∗\leadsto^{*} denotes the reflexive transitive closure. We compute C(a)C(a) via a reverse BFS seeded at aa, terminating at reachable Q-outputs and primary inputs.

Source Mapping. Using Yosys src annotations, we project the netlist cone C(a)C(a) back to the unique RTL statements in PbP_b that generated it:

S(a)={src(w)∣w∈C(a)}⊆Lines⁡(Pb).(2)S(a) = \{\mathrm{src}(w) \mid w \in C(a)\} \subseteq\operatorname{Lines}(P_b). \tag*{(2)}

Deduplication handles the many-to-one mapping from netlist elements to source lines (Appendix § 6.§ 3).

Cone Partition by Reverse Hop

We partition C(a)C(a) by reverse-dependency depth to construct a layered view of the computation cone, represented as a typed dependency graph G=(V,E)G = (V, E) with V=VN∪VSV = V_N \cup V_S: VNV_N are the mapped source statements S(a)S(a), and VSV_S are the boundary signals where the reverse traversal terminates (sequential Q-outputs in BB and primary inputs).

Hop Partition. Let h(v)h(v) denote the shortest directed path length from aa to vv in the reverse dependency graph. We partition the cone into per-hop layers Lk={v∣h(v)=k}L_k = \{v \mid h(v) = k\} for k=0,1,2,…k = 0, 1, 2, \ldots, where L0={a}L_0 = \{a\}, L1L_1 contains immediate drivers of aa, L2L_2 drives L1L_1, and so forth. This unique partition is computed directly during the reverse BFS traversal.

Edge Typing. Edges in the dependency graph are assigned mutually exclusive labels τ∈{DATA,CONTROL,STATE}\tau\in\{\mathrm{DATA}, \mathrm{CONTROL}, \mathrm{STATE}\} based on their operational roles: DATA for arithmetic and logic operands, CONTROL for multiplexer and conditional branching conditions, and STATE for dependencies anchored at sequential register boundaries (BB). Appendix A.4 details the cell-to-graph translation algorithm.

Compact Graph View

The compact graph view, serialized from VV and EE, is submitted to the agent under four policies to bound token footprint while prioritizing structural attention (Figure 3). By default, per-hop node cap K=4K = 4 and visible depth cap H=4H = 4.

Figure 3. Anchor’s single-clock-stage fan-in cone of a far-distance const_tweak sample and the corresponding compact graph view. Left The cone recovered from Yosys. Right The compact graph view submitted to the agent.

Restructuring Policies. (1) Direct-driver priority L1L_1 is emitted in full as the primary search space. (2) Per-hop representative cap For 2≤k≤H2 \le k \le H, at most KK representative nodes are emitted from LkL_k in reverse-BFS order. (3) Hop cap and summary folding Layers beyond LHL_H are folded into summaries such as “L5: 8 omitted”, acting as cues for dynamic unfolding via read. (4) Path

retention L1L_1 retains at least one shortest path to the state boundary VSV_S. Formally, the view emits vertex set

Vcompact=L0∪L1∪⋃k=2Htop⁡K(Lk),(3)V^{\mathrm{compact}} = L_0 \cup L_1 \cup\bigcup_{k=2}^{H} \operatorname{top}_K(L_k), \tag*{(3)}

fold summaries

F={(h,∣Lh∣)∣h>H,Lh≠∅},(4)F = \{(h, |L_h|) \mid h > H, L_h \ne\varnothing\}, \tag*{(4)}

and induced typed edges EcompactE^{\mathrm{compact}}.

Textual Serialization. VcompactV^{\mathrm{compact}}, EcompactE^{\mathrm{compact}}, and FF are serialized into an anchor-centric hierarchical text block. Each statement is annotated with line numbers, dependency types (DATA, CONTROL, STATE), and hop distance hh, serving as a structured roadmap for precise edits.

Agent Interaction and Information Boundary

GRODE-RTL operates as an interactive representation layer enabling multi-turn, hop-aware localization and repair.

Tool-Augmented Repair Loop. The agent accesses standard tools (read, grep, patch, done, abstain) alongside GRODE-RTL’s get_graph_view(), which returns (VcompactV^{\mathrm{compact}}, EcompactE^{\mathrm{compact}}, FF) on demand. Patch modifications are restricted to incremental, line-bounded edits to enforce surgical repairs.

Information Boundary. To prevent shortcut learning, the agent observes only the buggy source PbP_b, counterexample xx, anchor aa, and structural graph views. Golden reference RTL, ground-truth fault locations, and internal oracle diagnostics are strictly concealed. Submissions are evaluated externally via sequential equivalence checking.

Experiments

Research Questions

We organize the evaluation around three research questions.

RQ1: Does GRODE-RTL improve LLM-based RTL repair? We evaluate whether the proposed structural augmentation improves repair effectiveness across different LLMs and remains useful for bugs that are difficult to retrieve through source-level exploration.

RQ2: Why does the compact dependency representation help? We isolate structural relevance, dependency organization, and compactness to determine whether the benefit comes from simply exposing more context or from selectively presenting useful dependency information.

RQ3: What are the behavioral, cost, and robustness trade-offs? We examine how structural guidance changes the agent’s editing behavior, what reasoning cost it introduces, and how timeout, statistical, and fault-pattern effects bound the strength and scope of the conclusions.

Experimental Setup

Benchmark. Our evaluation builds on 85 single-site faults across 55 DeepCircuitX [9] RTL designs, where each fault is verified non-equivalent under a 20-step zero-initialized SAT check [1] and lies within its anchor’s fan-in cone. We evaluate 30 medium- and long-distance faults (23 designs) with source distance dd (anchor declaration to fault site) ranging from 50 to 782 lines (median: 104.5): 18 mid-distance (50≤d≤15050 \le d \le150) and 12 far-distance (d>150d > 150). Designs range from 63 to 1,137 lines (median: 305). By anchor visibility, 16 are direct (anchor name on faulty line) and 14 are indirect (anchor name omitted). Fault types comprise 17 signal_swap, 8 const_tweak, and 5 op_swap.

Common Protocol. All configurations share identical task prompts, buggy files, and SAT reproduction inputs, revealing neither golden RTL nor fault sites. Episodes run with temperature 1.0, maximum output 8,192 tokens, master seed 0 (k=1k = 1), a 12-turn cap, 300 s episode timeout, and 600 s oracle timeout. Each episode permits up to 5 combined grep/read calls and 1 patch call (≤20\le20 lines; no full rewrites). An isolated budget mode ensures structural tools do not consume text-exploration quotas.

Evaluation Metrics & Oracle. Candidates are evaluated via Yosys 20-step bounded SAT equivalence checking against the golden RTL oracle. We report Pass@1 (percentage of single-submission successful repairs) and absolute differences in percentage points (pp).

Evaluation Scope & Controlled Anchor. To isolate repair-context quality from localization accuracy, we fix one anchor register aa for each case and provide the same anchor to every configuration. The anchor is defined offline as the first upstream divergent sequential register identified through counterexample simulation on the faulty design. Agents receive only the anchor identity; neither the golden RTL nor the fault location is revealed. The evaluation is therefore conditioned on a shared localization starting point and measures how effectively each representation connects that anchor to its editable source-level causes, rather than evaluating end-to-end fault localization.

ModelMethodPassNo editTokens
DeepSeek-V4-FlashExplorer141255,982
DeepSeek-V4-FlashSeqFeed159133,384
DeepSeek-V4-FlashGRODE-RTL191172,317
GLM-5.2Explorer101043,030
GLM-5.2SeqFeed141096,016
GLM-5.2GRODE-RTL18557,774
MiniMax-M3Explorer121063,054
MiniMax-M3SeqFeed167147,426
MiniMax-M3GRODE-RTL18778,706

Table 2.

RQ1: Does GRODE-RTL Improve LLM-based RTL Repair?

We evaluate three methods across 30 mid- and far-distance bugs (3×303 \times30 evaluations) under the common protocol: source-only exploration (Explorer), the sequential-behavior-feedback baseline SeqFeed [3], and GRODE-RTL.

Overall Effectiveness. GRODE-RTL consistently boosts repair success across all evaluated LLMs (Figure 4, Table 1). Across the three models, average pass@1 rises from 40.0% (Explorer) to 50.0% (SeqFeed), and reaches 61.1% with GRODE-RTL (+21.1 pp overall gain). The maximum improvement occurs on GLM-5.2 (33.3% → 60.0%, +26.7 pp), where GRODE-RTL nearly doubles the successfully repaired bugs (10 → 18). The consistent within-model gains validate that structural augmentation offers model-agnostic benefits to RTL repair workflows.

Figure 4. End-to-end pass@1 of Explorer, SeqFeed, and GRODE-RTL on the same 30 mid- and far-distance bugs for each model.

ModelMethodmid (18)far (12)direct (16)indirect (14)
DeepSeek-V4-FlashExplorer9/18, 50.0%5/12, 41.7%10/16, 62.5%4/14, 28.6%
DeepSeek-V4-FlashSeqFeed11/18, 61.1%4/12, 33.3%11/16, 68.8%4/14, 28.6%
DeepSeek-V4-FlashGRODE-RTL11/18, 61.1%8/12, 66.7%11/16, 68.8%8/14, 57.1%
GLM-5.2Explorer8/18, 44.4%2/12, 16.7%7/16, 43.8%3/14, 21.4%
GLM-5.2SeqFeed10/18, 55.6%4/12, 33.3%9/16, 56.2%5/14, 35.7%
GLM-5.2GRODE-RTL13/18, 72.2%5/12, 41.7%12/16, 75.0%6/14, 42.9%
MiniMax-M3Explorer8/18, 44.4%4/12, 33.3%9/16, 56.2%3/14, 21.4%
MiniMax-M3SeqFeed12/18, 66.7%4/12, 33.3%11/16, 68.8%5/14, 35.7%
MiniMax-M3GRODE-RTL12/18, 66.7%6/12, 50.0%12/16, 75.0%6/14, 42.9%

Table 1. Cross-model comparison of Explorer, SeqFeed, and GRODE-RTL on the 30 mid- and far-distance samples.

Dominance on Search-Hard Subsets. The advantage of GRODE-RTL is especially pronounced on hard-to-retrieve bugs. On far-distance bugs (d>150d > 150), average pass@1 jumps from 30.6% to 52.8% (+22.2 pp); on indirect-anchor bugs (where fault lines omit the anchor name), success increases from 23.8% to 47.6% (+23.8 pp). Notably, SeqFeed yields limited gains on these subsets (33.3% for both): sequential feedback exposes temporal propagation, yet source-level search over long static dependency chains remains the agent’s burden. In contrast, GRODE-RTL successfully bridges distant computation paths even when source-level text search yields no immediate matches.

RQ1 Takeaway. GRODE-RTL provides substantial, model-agnostic repair gains over both raw exploration and execution-feedback baselines, demonstrating unique strength in resolving spatially obscured and distant RTL faults.

RQ2: Why Does the Compact Dependency Representation Help?

To isolate the sources of improvement, we conduct a controlled representation ablation on DeepSeek-V4-Flash over the same 30 bugs (Table 2). The control configurations incrementally incorporate structural features (Figure 5, Table 3):

ConfigurationPassΔ\Deltamid (18)far (12)direct (16)indirect (14)
subgraph15/30, 50.0%−13.3%-13.3\%11/18, 61.1%4/12, 33.3%11/16, 68.8%4/14, 28.6%
matched_random16/30, 53.3%−10.0%-10.0\%11/18, 61.1%5/12, 41.7%9/16, 56.2%7/14, 50.0%
GRODE-RTL(cone only)18/30, 60.0%−3.3%-3.3\%11/18, 61.1%7/12, 58.3%11/16, 68.8%7/14, 50.0%
GRODE-RTL(w/o. compact)16/30, 53.3%−10.0%-10.0\%12/18, 66.7%4/12, 33.3%11/16, 68.8%5/14, 35.7%
GRODE-RTL19/30, 63.3%—11/18, 61.1%8/12, 66.7%11/16, 68.8%8/14, 57.1%
ConfigurationPatchesNo editTool callsTokensView nodesView chars
subgraph2095.7363,235——
matched_random1986.4064,98726.21,326
GRODE-RTL(cone only)2196.5765,98724.71,761
GRODE-RTL(w/o. compact)17126.0370,11226.24,524
GRODE-RTL19116.4372,3179.82,398

Table 3. Five ablation configurations on DeepSeek-V4-Flash.

Figure 5. Pass@1 under different dependency representations on the same 30 mid- and far-distance bugs.

  • subgraph: Localized AST/dependency subgraph without source line context.

  • matched_random: Size-matched random subgraph to test functional relevance versus raw context volume.

  • GRODE-RTL(cone only): Unorganized fan-in cone mapped to source statements without dependency hierarchy.

  • GRODE-RTL(w/o. compact): Unpruned netlist dependency graph without selective cone partitioning.

Here, view nodes refers to the number of AST/dependency statement nodes serialized into the structural context, and view chars denotes its raw string length.

ConfigurationAnchor SignalSource LinesSubgraph ExtractDep. Org.Graph Comp.
subgraph✓✗✗✗✗
matched_random✓✓✗✗✗
GRODE-RTL(cone only)✓✓✓✗✗
GRODE-RTL(w/o. compact)✓✓✓✓✗
GRODE-RTL✓✓✓✓✓

Table 2 (PDF p. 8). Structural features captured by representation variants in the ablation.

Structural Relevance Over Raw Context. Exposing only the coarse SAT mismatch signal (tool-call get_subgraph()) yields 50.0% pass@1, just 3.3 pp above source-only exploration. Providing line-count-matched random lines (matched_random) reaches 53.3%, whereas supplying the actual fan-in cone (tool-call get_cone()) raises pass@1 to 60.0%. This confirms that structural relevance to the faulty computation—rather than coarse localization or generic context expansion—drives the performance gain.

Over-exposure Degrades Reasoning. Adding unpruned graph detail does not yield monotonic gains. While full_graph introduces explicit hop partitions and typed edges, it drops overall Pass@1 to 53.3% (−6.7 pp), with severe drops on far-distance (58.3% → 33.3%) and indirect-anchor (50.0% → 35.7%) subsets. Excessive structural noise burdens LLM attention, counteracting the benefits of graph context.

Compactness and Typing Enable Targeted Exploration. Combinational fan-in slicing (GRODE-RTL(cone only)) accounts for the primary recovery over baseline exploration (+13.3 pp), matching GRODE-RTL on simple direct-anchor (68.8%) and mid-distance (61.1%) subsets under a lower footprint. However, unorganized linear listings stall on complex far-distance and indirect-anchor faults. GRODE-RTL’s typed hop-partitioning resolves this bottleneck, delivering vital incremental gains (+3.3 pp overall) that reach peak performance on far-distance (66.7%) and indirect (57.1%) cases. Furthermore, compared to GRODE-RTL(w/o. compact), GRODE-RTL prunes node count by 62.6% (9.8 vs. 26.2) and view size by 47.0% (2,398 vs. 4,524 chars), proving that selective, typed partitioning outperforms both unorganized linear slicing and unpruned context expansion.

RQ2 Takeaway. The ablation demonstrates a clear progression: localization offers minimal gain, raw dependency context helps, unpruned graph structures degrade reasoning, and GRODE-RTL optimizes the trade-off through compact dependency organization.

RQ3: Behavioral, Cost, and Robustness Trade-offs

RQ3 examines how structural guidance alters agent execution, its associated costs, and the bounds of our findings.

Selective Guidance Drives Precise Edits. As shown in Table 1, GRODE-RTL consistently suppresses no-edit fallbacks across models (DeepSeek: 12→11; GLM-5.2: 10→5; MiniMax-M3:

10→\to7) while increasing repair yield. Conditioned on edited episodes, conditional success rates surge: 77.8%→\to100.0% (DeepSeek), 50.0%→\to72.0% (GLM-5.2), and 60.0%→\to78.3% (MiniMax-M3). This proves the representation enhances repair quality rather than mere edit propensity.

Reasoning Cost vs. Selective Exposure. Although GRODE-RTL increases per-episode token consumption compared to the baseline explorer (e.g., 72,317 vs. 55,982 on DeepSeek-V4-Flash), it achieves substantial token savings compared to SeqFeed (72,317 vs. 133,384 tokens, a 45.8% reduction; and a 39.8%–46.6% reduction across all backbones, e.g., 57,774 vs. 96,016 on GLM-5.2 and 78,705 vs. 147,426 on MiniMax-M3). This demonstrates that compact view synthesis successfully avoids context overload, enabling selective exposure to channel the token budget into targeted follow-up reads and deeper sequential reasoning.

Fault Observability and Evaluation Bounds. The structural gain varies by fault pattern: GRODE-RTL substantially lifts fully observable const_tweak bugs (2/8→\to6/8 on DeepSeek) but provides marginal gains on signal_swap (12/17→\to13/17) and fails on unobservable op_swap faults (0/5), which demand semantic rather than structural reasoning. Additionally, while relay timeouts introduce operational noise, the qualitative case (Appendix A.2) confirms that compact views avoid the 27k-char view clutter that causes full_graph to forfeit edits.

RQ3 Takeaway. GRODE-RTL converts idling into high-precision edits by channeling tokens into deep sequential reasoning rather than raw context display. Its strength centers on structural observability, establishing selective dependency organization as a robust principle within explicit operational boundaries.

Repeated-run evaluation

We repeat the evaluation on DeepSeek-V4-Flash, GLM-5.2, and MiniMax-M3 using seeds 101, 102, and 103. Each run covers the same 30 faults from 23 source designs and compares Explorer, GRODE-RTL(cone only), and GRODE-RTL, yielding 810 episodes in total. We use temperature 1.0 with a budget of 12 model calls per episode and 8,192 output tokens per response. Thinking is enabled for DeepSeek-V4-Flash. Table 4 summarizes the successful repairs for each seed and reports mean pass@1 with the sample standard deviation across the three runs.

Table 4: Repeated-run repair results on the same 30 cases. Each seed column reports the number of successful repairs. Mean ±\pm SD reports pass@1 in percent and its sample standard deviation across the three seeds. Best results within each model and column are bold.

ModelMethodSeed 101Seed 102Seed 103Mean ±\pm SD (%)
DeepSeek-V4-FlashExplorer19142058.9 ±\pm 10.7
DeepSeek-V4-FlashGRODE-RTL(cone only)21222272.2 ±\pm 1.9
DeepSeek-V4-FlashGRODE-RTL21212372.2 ±\pm 3.8
GLM-5.2Explorer10111540.0 ±\pm 8.8
GLM-5.2GRODE-RTL(cone only)17191961.1 ±\pm 3.8
GLM-5.2GRODE-RTL19181760.0 ±\pm 3.3
MiniMax-M3Explorer1023.3 ±\pm 3.3
MiniMax-M3GRODE-RTL(cone only)86925.6 ±\pm 5.1
MiniMax-M3GRODE-RTL119932.2 ±\pm 3.8

Table 4.

Repeated repair performance. Across all three evaluation backbones, GRODE-RTL consistently outperforms Explorer across all three random seeds. On DeepSeek-V4-Flash, our method achieves a mean pass@1 of 72.2% ±\pm 3.8%, compared to 58.9% ±\pm 10.7% for Explorer. On GLM-5.2, the corresponding success rates are 60.0% ±\pm 3.3% and 40.0% ±\pm 8.8%, representing average improvements of 13.3 and 20.0 percentage points, respectively. The cone-only ablation performs exceptionally close to full GRODE-RTL on both models, matching its mean on DeepSeek-V4-Flash and solving just one additional case across 90 total attempts on GLM-5.2.

On MiniMax-M3, GRODE-RTL achieves a mean pass@1 of 32.2% ±\pm 3.8%, outperforming GRODE-RTL(cone only) at 25.6% ±\pm 5.1% and Explorer at 3.3% ±\pm 3.3%. Full GRODE-RTL exceeds cone-only in two seeds and ties in the third, yielding six additional successful repairs across 90 attempts. This performance gain is especially pronounced on far-distance faults, where GRODE-RTL succeeds in 15 out of 36 attempts versus 11 out of 36 for GRODE-RTL(cone only) (an 11.1 percentage-point increase), compared to 14 out of 54 versus 12 out of 54 on mid-distance faults (a 3.7 percentage-point increase).

The lower absolute success rates on MiniMax-M3 stem primarily from frequent output truncations when long reasoning traces hit the 8,192-token limit. Whenever a truncated model response omitted a valid tool call, the evaluation harness triggered a finalization-only step, prematurely terminating the episode regardless of any unused interaction budget.

Core representation and compact organization. The repeated results highlight the contribution of the structural context shared by GRODE-RTL(cone only) and GRODE-RTL. GRODE-RTL(cone only) retains the central cone-extraction and cone-mapping components, which connect circuit dependencies to editable source statements. GRODE-RTL further organizes this context by prioritizing direct drivers and grouping upstream dependencies. The two configurations achieve similar repair rates on DeepSeek and GLM, while the MiniMax results show an additional gain from the complete configuration under the evaluated settings, particularly on far-distance faults.

Conclusion

We presented GRODE-RTL, an anchor-centric representation framework that bridges netlist dependencies with editable RTL source for non-local hardware repair. Across three LLMs, GRODE-RTL yields average Pass@1 gains of +21.1 pp over exploration baselines and +11.1 pp over strong sequential baselines (reaching 63.3% peak), demonstrating that selective cone partitioning outperforms exhaustive graph serialization. The compact representation enables deeper structural reasoning across extended debugging turns. Future work will extend GRODE-RTL to autonomous upstream localization and operator-level diagnosis.

Reproducibility Statement

The benchmark construction, structural extraction, agent evaluation, and formal-equivalence pipeline are described in § 3 and § 4. Further implementation details, full prompts, and per-case logs are provided in Appendix § 6. All evaluation code, raw datasets, and reproduction scripts are included in the supplementary material.

AI Use Statement

Generative AI tools were employed for manuscript drafting and language refinement. All experimental data, tables, and reported pass@1 metrics were cross-referenced with raw execution logs, which are preserved in the supplementary material for reproducibility. The authors take full responsibility for the final publication.

Supplementary Material

This appendix first reports the per-case outcomes across all evaluated models and repair methods. It then, makes the information boundary between configurations explicit by listing the full prompt and tool descriptions, and shows one representative episode under both the compact and full-view configurations. We refer to the case-study sample as Sample S throughout; only its filename is anonymized to <design>.v.

Per-case outcomes across models

Table 5 lists all 30 evaluation cases using the original circuit name and injected fault type. For each model, it compares explorer, SeqFeed, and GRODE-RTL (explorer_graph_view_compact). PASS denotes a correct repair. For failures, NE, TO, ECF, and ENE denote no_edit, timeout, equivalence_check_failed, and edited_not_equivalent.

#CircuitFault typeDeepSeek-V4-FlashGLM-5.2MiniMax-M3
ExplorerSeqFeedGRODEExplorerSeqFeedGRODEExplorerSeqFeedGRODE
0114520_2signal_swapNENENENENENETONENE
0214520_2op_swapNENENENETOTOENEENENE
031542const_tweakENEENEPASSNENENEENENEPASS
0416017signal_swapPASSPASSPASSPASSPASSPASSPASSPASSPASS
0516331_3signal_swapNEPASSPASSNENEPASSNEPASSPASS
0616331_3const_tweakENENEPASSNEPASSPASSNEPASSPASS
071762_14const_tweakNENENETOTOTONEPASSPASS
0821502const_tweakPASSPASSPASSTONEPASSPASSPASSPASS
0924583_12const_tweakPASSPASSPASSTOPASSPASSNEPASSPASS
1024583_12signal_swapPASSPASSPASSPASSPASSNENEPASSPASS
1124940_10signal_swapPASSPASSPASSNENEPASSPASSECFPASS
1224940_10signal_swapPASSENEPASSTONENEPASSNEPASS
1325631signal_swapPASSTOPASSPASSNEPASSPASSPASSPASS
1425631signal_swapPASSPASSNEPASSPASSPASSPASSPASSECF
1529019_6signal_swapENEENENETONETOENEENEECF
16300_2signal_swapNEPASSPASSNEPASSPASSECFPASSNE
1730095_15signal_swapPASSPASSPASSPASSPASSPASSPASSPASSPASS
1830895signal_swapPASSNEPASSTOPASSPASSECFENETO
193125_6signal_swapPASSPASSPASSTOPASSPASSPASSNEECF
2033437_14signal_swapENEPASSPASSPASSPASSTOPASSNEENE
2133437_14signal_swapPASSPASSPASSPASSPASSPASSTOECFPASS
2233831_8signal_swapPASSPASSPASSPASSPASSPASSNEECFPASS
2335009op_swapNENENETOTOTOPASSPASSPASS
243629_1const_tweakNEENENEPASSNEPASSPASSPASSPASS
253629_1op_swapNENENENETOPASSNENETO
266109_13const_tweakNEPASSPASSTOPASSPASSENEPASSPASS
276716_2op_swapNENENENETOTOECFNETO
286726_6const_tweakNEPASSPASSTOPASSPASSNEPASSPASS
296777_6signal_swapPASSNENEPASSNETOPASSPASSNE
308610op_swapNEENENENEENENEENEENENE
PASS total14/3015/3019/3010/3014/3018/3012/3016/3018/30

Table 5. Per-case outcomes across models and repair methods. All methods are evaluated on the same 30 cases for each model.

Case study: a far-distance const_tweak under five configurations

Design. Sample S is a small synchronous Verilog module glyph_addr that maps a 6-bit character input glyph together with a 4-bit vertical counter vcnt to a 10-bit output address. The body of the module is a single synchronous always block containing a 24-branch case (glyph) statement; each case branch holds an if / else if chain over vcnt that updates the internal cur_add register by a constant base expression indexed by vcnt. The cur_add register is then assigned to the address output combinationally on the next line. The full source is 784 lines; much of the body consists of near-identical else if branches differing only in their vcnt literal and, in the buggy version, in one constant term.

Anchor. The anchor is the 10-bit output register address, declared in the module port list near the top of the file. It is an indirect anchor in our taxonomy. The anchor name address does not appear on any cur_add update line, so a naive grep("address") only returns the port declaration and the combinational assignment, neither of which is the bug site. The get_suspect_subgraph tool’s coarse-localizer signal (simulation mismatch at step 20 on the address register, identifying the first upstream divergent sequential register) is the only reason the agent has to focus on this register.

Fault. The fault on Sample S is a single-literal const_tweak on the else if (vcnt == 'd10) branch within one case (glyph) branch: the constant 10’d151 should read 10’d150, the same base used by every other else if branch and by the rst initialization. The fault line lies d=620d = 620 source lines below the anchor declaration, putting Sample S in the far bucket of the benchmark (distance measured from the anchor declaration to the fault site). The right edit is therefore a one-character change in a 24-branch switch where every other branch is correct, and where the same constant appears many times across the file.

Configuration outcomes on this sample. The five available configuration outcomes on this sample are listed in Table 6. Failure labels are no_edit (the agent exhausts its turn budget without calling patch) and edited_not_equivalent (the agent emits a patch whose post-edit design is not functionally equivalent to the golden RTL).

ConfigurationOutcomeFailure type
matched_randomPASSNone
subgraphFAILedited_not_equivalent
conePASSNone
full_graphFAILno_edit
GRODE-RTLPASSNone

Table 6. Per-configuration outcome on Sample S under each of the five structural configurations.

The full-graph configuration fails by giving up: it consumes its exploration budget on reads and greps without ever calling patch. The compact configuration patches line 629 with a one-character change and is graded PASS. Matched random context also passes on this sample, but the contrast of interest for the representational claim is full →\to compact: the two configurations see the same cone source set serialized in two ways, and only the compact view converts the structure into an edit. The full graph view is 27,871 characters of node/edge metadata; the compact view is 2,968 characters of which roughly 1,300 are the navigation header and fold summary, leaving about 1,700 characters of structured source. On this sample, more graph is worse.

The compact view the agent saw. The following is the exact get_graph_view("address") response delivered to the agent when it called the tool:

GRODE-RTL Compact Graph View for anchor [address]
(784 total source lines in P_b; showing 11 representative statements):
Primary structural search space: inspect L1 direct-driver cards first;
expand beyond the view only if they cannot explain the failure.
Compact graph guide: showing 11/161 mapped source statements.
This is navigation, not a complete cone (bounded by K=4, H=4).
Folded statements by hop (F):
  L5: 15 omitted; L6: 6 omitted; L7: 10 omitted; ... L18: 9 omitted.
Use read() around a listed source location when full branch syntax is needed.

GRODE-RTL dependency view (current RTL only; no fault-line scores)
Top module: glyph_addr
How to use: inspect [L1 Direct driver statements] first; then read
a local range around a listed line if more syntax is needed.
Do not grep the anchor unless no mapped source node is shown.

[L0 Anchor]
A0 | address

[L1 Direct-driver statements: inspect and compare first]
N1 | <design>.v:9 | assign address = cur_add;
N2 | <design>.v:13 | if (rst) cur_add <= 10'd150;
    inputs: CONTROL(S2); DATA(N3)
    retained path: S2 --[CONTROL]--> N2 --[DATA]--> A0

[L2 Upstream statements (capped at K=4)]
N3 | <design>.v:16 | inputs: CONTROL(S1); CONTROL(N5); CONTROL(N7); DATA(N4)
                         case (glyph)

[L3 Upstream statements (capped at K=4)]
N4 | <design>.v:19 | inputs: CONTROL(S3); DATA(S1); DATA(S3); DATA(N8)
                         if (vcnt == 'd0) cur_add <= (10'd150+{glyph,4'b0000})+...
N5 | <design>.v:36 | inputs: CONTROL(S2)                  end
N6 | <design>.v:39 | inputs: CONTROL(S3); DATA(S1); DATA(S3); DATA(N9)
                         if (vcnt == 'd0) cur_add <= (10'd150+{glyph,4'b0000})+...
N7 | <design>.v:56 | inputs: CONTROL(S1)                  end

[L4 Upstream statements (capped at K=4)]
N8 | <design>.v:20 | inputs: CONTROL(S3); DATA(S1); DATA(S3)
                         else if (vcnt == 'd1) cur_add <= (10'd150+{glyph,4'b0000})+...
N9 | <design>.v:40 | inputs: CONTROL(S3); DATA(S1)
                         else if (vcnt == 'd1) cur_add <= (10'd150+...)
N10 | <design>.v:60 | inputs: CONTROL(S3); DATA(S1)
                         else if (vcnt == 'd1) cur_add <= (10'd150+...)

N11 | <design>.v:80 | inputs: CONTROL(S3); DATA(S1)
                         else if (vcnt == 'd1) cur_add <= (10'd150+...)

[State/Input boundary V_S]
S1 | glyph  S2 | rst  S3 | vcnt

The compact graph view makes three structural properties visible that flat source code buries: (1) the anchor aa has a clear direct driver in L1L_1 (N2 = <design>.v:13); (2) intermediate hops L2L_2–L4L_4 are strictly capped at K=4K = 4 representative nodes, while the remaining 150 upstream statements across hops L5L_5–L18L_{18} are cleanly folded into F={(5,15),(6,6),…}F = \{(5, 15), (6, 6), \ldots\} summaries; (3) the sequential state boundary VSV_S isolates glyph, rst, vcnt as the sole clock-stage inputs.

The full view the agent saw, in contrast. The same anchor serialized in the full_graph configuration contains 161 mapped source nodes and 612 typed edges, organized by reverse hop from L1 to L18. The first 2,000 characters and the last 2,000 characters of that view are:

Graph view for address [full graph view]
(784 source lines; showing 161):
... [legend and L0 anchor as in the compact view] ...

[Direct driver statements: inspect and compare first]
N1 | <design>.v:9   assign address = cur_add;
N2 | <design>.v:13  if (rst) cur_add <= 10'd150;
                     inputs: CONTROL(S2); DATA(N3)
                     path: S2 -[CONTROL]-> N2 ; N2 -[DATA]-> A0

[L2 Remaining upstream source statements]
N3 | <design>.v:16 | inputs: CONTROL(S1); CONTROL(N11);
                       CONTROL(N13); CONTROL(N15); +16 more
                       case (glyph)

[L3 Remaining upstream source statements]
N4 | <design>.v:19 | ... if (vcnt == 'd0) cur_add <= (10'd150+...) ...
N5 | <design>.v:36 | end
N6 | <design>.v:39 | ... if (vcnt == 'd0) cur_add <= (10'd150+...) ...
...
[continues through L18 with 9-10 near-identical statements per hop]

[L18 Remaining upstream source statements]
N153 | <design>.v:34  | ... else if (vcnt == 'd15) cur_add <= (10'd150+...) ...
N154 | <design>.v:54  | ... else if (vcnt == 'd15) cur_add <= (10'd150+...) ...
...
N161 | <design>.v:194 | ... else if (vcnt == 'd15) cur_add <= (10'd150+...) ...

[State/input boundary signals]
S1 | glyph  S2 | rst  S3 | vcnt

The full view faithfully lists every hop, every node, every edge label. On this sample the result is a 27,871-character payload with 161 nodes, 612 typed edges, and 18 reverse-dependency hops whose per-hop bodies are near-identical else if lines differentiated only by vcnt literals. The agent that received it performed four more exploration calls (three greps and a targeted read of lines 760–784) without ever producing a patch, and exhausted its 5-call exploration budget.

Recovering src-less statements

The src-mapping step in Section 3 is many-to-one after deduplication, but a small number of source statements are not reachable through any Yosys cell annotation at all. We recover them by walking the cone and the anchor’s declaration sites directly:

  • Anchor bare assignments. An assign aa = expr; in the RTL is folded into the netlist as a direct connection and produces no per-cell src; we recover it by scanning PbP_b for assignments whose LHS is the anchor and adding them as hop-1 nodes tagged DIRECT.

  • Direct signal assignments. Initial-value assignments of aa (synchronous reset defaults inside the always block, module-port defaults) carry the same src-less status; we recover them by collecting every statement whose target is the anchor.

  • Boundary declarations. The anchor’s declaration site in the module port or the always-block local list is not part of any cell’s src and is recovered by parsing PbP_b’s port list and always headers.

All three classes are added as hop-1 nodes tagged DIRECT so that the compact view’s direct-driver priority (§ 4.4) treats them on equal footing with cells that do carry src. The extractor operates only on PbP_b and never admits a statement on the basis of a difference against the golden code; this boundary is what keeps the compact view’s representational gain attributable to organization rather than to oracle leakage.

Recovering the dependency graph

The typed dependency graph of § 3 is recovered cell-by-cell from the Yosys netlist and then lifted to source-statement and signal nodes.

Vertex construction. The vertex set is V=VN∪VSV = V_N \cup V_S with VN=S(a)∖{anchor declaration}V_N = S(a) \setminus\{\text{anchor declaration}\} representing the mapped source statements and VSV_S representing the upstream signal alphabet reached by the reverse BFS that does not cross the sequential boundary B⊆WB \subseteq W. The anchor itself sits as a singleton in L0L_0. Every other vertex carries the deduplicated src annotation of the cells that produced it.

Edge construction. Edges point from a statement to the statements it depends on, matching the u⇝vu \rightsquigarrow v convention of § 3 and the reverse-BFS hop levels; for readability, the serialized view prints retained paths in dataflow direction (e.g. S2 -[CONTROL]-> N2 -[DATA]-> a). For each combinational cell cc that survives the cone closure, we record an edge from the statement node of v=fanout⁡(c)v = \operatorname{fanout}(c) to the statement node of each u∈fanin⁡(c)u \in\operatorname{fanin}(c), then label the edge according to cc’s cell type:

  • DATA: data operand of a logic or arithmetic cell (e.g. $and, $add).

  • CONTROL: selector input of a multiplexor or branch condition of a $mux/$bmux; these drive which operand is observed rather than carrying data.

  • STATE: an edge whose source is a Q-output wire in BB, i.e. the only carrier of state across clock stages.

A single Yosys cell may therefore contribute one or more edges to EE, each with its own label. The labels are mutually exclusive and exhaustive: every edge in EE receives exactly one of the three types, and the union of the three covers EE. This is the implementation of the edge-type claim in § 3.

System prompt and tool descriptions

You are fixing a bug in an RTL (Verilog) design. The design currently
fails a functional-equivalence check against its correct reference.
There is no source location or preselected suspect signal. You must
locate the root cause yourself.

Tools
- grep(pattern) regex-search the CURRENT design source; returns
  "file:line: text".
- read(file, start, end) return a numbered range of the current source.
- patch(file, start, end, content) replace a small 1-based inclusive
  line range in the CURRENT file. Use this instead of rewriting the
  complete file.
- done() submit the current files for grading.
- abstain(reason) explicitly stop when you cannot produce a defensible
  fix.

Method
Use the available evidence to inspect suspicious local operators,
constants, and signal sources before proposing broader redesigns. Trace
back from a divergent signal through the logic that drives it, patch only
``

the smallest line range justified by the evidence, then submit it. A fix that changes the suspected logic but breaks other outputs will fail. Never resend or reconstruct a complete source file. You MUST finish by calling either done() or abstain(reason); never stop with an ordinary text response.

When the configuration registers a structural tool, we appends a short tool-specific block only for the tools that configuration has. The conditional append for the compact-graph configuration is:

Additional tools available in this episode:
- get_suspect_subgraph(): coarsely locate a suspect dependency subgraph
and return its root signal together with SAT reproduction evidence.
- get_graph_view(anchor): inspect an anchor-centric CURRENT-RTL
dependency view grouped by reverse hop with DATA, CONTROL, and STATE
edges.
Tool-specific method:
Call get_suspect_subgraph() early, then use its root signal with the
structural tool available in this episode.
Inspect get_graph_view() direct-driver cards first, then read a small
local range only when syntax context is needed; do not reflexively grep
the anchor.

The same template, with get_graph_view replaced by get_cone(anchor): map the anchor’s single-stage fan-in cone back to CURRENT RTL source lines, is used for the cone configuration. The subgraph configuration receives a reduced append containing only get_suspect_subgraph (no view tool is registered). The matched_random configuration receives the cone block unchanged. The matched-random condition is realized inside the tool implementation, which returns ; the agent’s prompt and tool specification are byte-identical to the source-order cone configuration. Two configurations with identical tool sets therefore produce byte-identical system prompts; this is verified by the test suite.

The per-tool description that the model sees as a JSON-Schema tool spec is also fixed. For get_graph_view, the description string is:

Return an anchor-centric reverse-dependency view of the current RTL.
Call it early. It lists direct driver statements of the anchor first,
with their immediate DATA, CONTROL, and STATE inputs and one
deterministic shortest upstream path. It then lists the remaining
same source statements by reverse hop: L1 directly drives the anchor
and larger L values are farther upstream. A0 denotes the anchor, N#
a source-statement node, and S# an upstream state/input boundary.
Node numbers are stable identifiers, not suspiciousness rankings.
Use read() around a listed line for more local syntax; avoid
grep(anchor) unless this view has no mapped source nodes. Treat the
displayed direct drivers as the primary structural search space before
broad global search. The view uses only current RTL and never uses
golden RTL, the fault location, or a suspiciousness score.

This is the literal information boundary: no golden code, no fault line, no fault pattern, no suspiciousness score, no patch hint appears anywhere in the prompt, the tool spec, or the tool output.

One sample, two configurations

We follow Sample S under the compact-graph configuration (PASS) and the full-graph configuration (FAIL with no_edit). Both configurations consume the same per-episode budget: at most 5 grep/read calls, at most 1 patch, and at most 1 call to each structural tool.

Compact-graph configuration (PASS).

  1. turn 0 get_suspect_subgraph() → anchor = address, mismatch at step 20.

  2. turn 0 read(<design>.v, 1, 80) (5,649 chars).

  1. turn 1 read(<design>.v, 81, 260) (15,211 chars).

  1. turn 2 read(<design>.v, 261, 560) (25,394 chars). Three reads cover lines 1–560 of the 784-line file.

  1. turn 3 grep("10’d[0-9]+\+|glyph,4’b[01]+|4’b[01]+,vcnt") → 8,530 chars of repeated cur_add lines.

  1. turn 3 grep("d15|d16|...|d6[0-3]") → 8,470 chars. The 5-call exploration budget is now full.

  1. turn 4 get_graph_view("address") → 2,968 chars (the compact view in Section A.2, fold summary + 11 nodes).

  1. turn 4 `grep("10’d1[0-9][0-9]|glyph,4’b3|4’b3,vcnt")` → budget exhausted message.

9.

  1. turn 12 patch(<design>.v, 629, 629, "else if (vcnt == ’d10) cur_add <= (10’d150+{glyph,4’b0000})+{4’b0000,vcnt};") → patched line 629, replacing 10’d151 with 10’d150.

11.

Full-graph configuration (FAIL, no_edit).

  1. turn 0 get_suspect_subgraph() → anchor = address.

  1. turn 0 grep("module|always|assign|glyph|vcnt") → 8,130 chars of mixed hits.

  1. turn 1 get_graph_view("address") → 27,871 chars (the full view).

  1. turn 1 read(<design>.v, 1, 60) (3,977 chars).

  1. turn 2 grep("10’d|’d6[0-9]|default|endcase|endmodule") → 8,470 chars.

  1. turn 2 read(<design>.v, 760, 784) (2,192 chars). The agent is now reading the tail of the file, far from the folded L3 block that contains the fault.

  1. turn 3 grep("^ +’d[0-9]+:") → 1,732 chars listing all 24 case branch headers.

  1. turn 3 grep("vcnt") → budget exhausted message.

  1. The agent never calls patch; the episode terminates with no edit. Oracle returns FAIL with no_edit.

Edit-status and timeout accounting

ModelMethodBefore patchAfter patchTotal
GLM-5.2Explorer9110
GLM-5.2GRODE-RTL707
MiniMax-M3Explorer202
MiniMax-M3GRODE-RTL303

Table 7. Patch status at model-service timeout in the original Explorer/GRODE comparison. Counts are episodes, not tool calls.

Candidate correctness and submission status. Repair success is determined by the final candidate source. The agent’s termination status, including done(), abstention, or an unresolved ending, is recorded separately. Conditional success in the main text is calculated as successful repairs divided by 30 minus the No edit count in Table 1. Timeout episodes remain in this denominator unless they are included in that table’s No edit count.

Final-source changes. We also inspect whether the final source differs from the buggy input, regardless of how the episode ends. The numbers of unchanged candidates for Explorer, SeqFeed, and GRODE-RTL are 12/10/11 on DeepSeek, 19/15/12 on GLM, and 10/7/8 on MiniMax, respectively. This source-based count differs from the terminal NE label because an episode can end in a timeout without changing the source.

For example, MiniMax GRODE-RTL has five NE episodes and three timeouts, all with unchanged final source. Two timeouts involve no patch attempt. The third follows a rejected patch that leaves the source unchanged. This explains the distinction between the five terminal NE labels, the seven No edit entries in Table 1, and the eight unchanged final candidates.

Timeouts in the original GLM runs. The original GLM experiments record 10 API timeouts for Explorer and seven for GRODE-RTL. Of the 11 cases repaired by GRODE-RTL but not Explorer, six involve an Explorer timeout. Service failures therefore contribute to the observed gap.

Nine Explorer timeouts occur before a successful patch-tool call and one occurs after a patch. All seven GRODE-RTL timeouts occur before a successful patch-tool call. None of these 17 episodes reaches a successful done() submission.

References

  1. [1]Edmund Clarke, Armin Biere, Richard Raimi, and Yunshan Zhu. Bounded model checking using satisfiability solving. In International Conference on Formal Methods in Computer-Aided Design (FMCAD), 2001.
  2. [2]Edmund M. Clarke, Thomas A. Henzinger, Helmut Veith, and Roderick Bloem (eds.). Handbook of Model Checking. Springer, 2018. ISBN 978-3-319-10574-1.
  3. [3]Yuxin Du, Juxin Niu, Tao Hu, Xi Wang, Zhe Jiang, and Nan Guan. SeqFeed: Improving agentic RTL code generation with sequential behavior feedback, 2026. URL https://arxiv.org/abs/2608.16934.
  4. [4]Evguenii I Goldberg, Mukul R Prasad, and Robert K Brayton. Using sat for combinational equivalence checking. In Proceedings Design, Automation and Test in Europe. Conference and Exhibition 2001, pp. 114–121. IEEE, 2001.DOI
  5. [5]William L. Hamilton, Rex Ying, and Jure Leskovec. Inductive representation learning on large graphs. In Advances in Neural Information Processing Systems (NeurIPS), 2017.arxiv.org/abs/1706.02216
  6. [6]Thomas N. Kipf and Max Welling. Semi-supervised classification with graph convolutional networks. In International Conference on Learning Representations (ICLR), 2017.arxiv.org/abs/1609.02907
  7. [7]Wolfgang Küchlin and Carsten Sinz. Proving consistency assertions for automotive product data management. Journal of Automated Reasoning, 24(1-2):145–163, 2000.
  8. [8]Min Li, Sadaf Khan, Zhengyuan Shi, Naixing Wang, Huang Yu, and Qiang Xu. Deepgate: Learning neural representations of logic gates. In Proceedings of the 59th ACM/IEEE Design Automation Conference, pp. 667–672, 2022.
  9. [9]Zeju Li, Changran Xu, Zhengyuan Shi, Zedong Peng, Yi Liu, Yunhao Zhou, Lingfeng Zhou, Chengyu Ma, Jianyuan Zhong, Xi Wang, Jieru Zhao, Zhufei Chu, Xiaoyan Yang, and Qiang Xu. DeepCir-cuitX: A comprehensive repository-level dataset for RTL code understanding, generation, and PPA analysis, 2025. URL https://arxiv.org/abs/2502.18297.
  10. [10]Priscila Santiesteban, Yu Huang, Westley Weimer, and Hammad Ahmad. Cirfix: Automated hardware repair and its real-world applications. IEEE Transactions on Software Engineering, 49(7):3736–3752, 2023. doi: 10.1109/TSE.2023.3269899.

Paper details

vlnc:W_wb5pkhvt
Version
v1 · latest
Published
Fresh — added to the Hub within the last 30 days
Added
License
CC BY 4.0
Usage

views · 4

downloads · 0

A view counts once per browser per day, a download each time the PDF is requested.

  • Computer Science

Generative AI tools

View statement
Looking for related papers…
Contents