acceptodds
Under review as a conference paper at ICLR 2027

VeriGraphi: A Multi-Agent Framework of Hierarchical RTL Generation for Large Hardware Designs

Abstract

Generating synthesizable Verilog for large, hierarchical hardware designs remains a significant challenge for large language models (LLMs), which struggle to replicate the structured reasoning that human experts employ when translating complex specifications into RTL. When tasked with producing hierarchical Verilog, LLMs frequently lose context across modules, hallucinate interfaces, fabricate inter-module wiring, and fail to maintain structural coherence—failures that intensify as design complexity grows and specifications involve informal prose, figures, and tables that resist direct operationalization. To address these challenges, we present VeriGraphi, a framework that introduces a spec-anchored Knowledge Graph as the central architectural substrate driving the RTL generation pipeline. VeriGraphi constructs a Hierarchical Design Architecture (HDA), a structured knowledge graph that explicitly encodes module hierarchy, port-level interfaces, wiring semantics, and inter-module dependencies as first-class graph entities and relations. Built through iterative multi-agent analysis of the original specification, this Knowledge Graph provides a deterministic, machine-checkable structural scaffold before code generation. Guided by the KG, a progressive coding module incrementally generates pseudo-code and synthesizable RTL while enforcing interface consistency and dependency correctness at each submodule stage. We evaluate VeriGraphi on a benchmark comprising three representative specification documents published by the National Institute of Standards and Technology (NIST) and their corresponding implementations, and we present a RISC-V 32I processor as a detailed case study to illustrate the full pipeline. The results demonstrate that VeriGraphi enables reliable hierarchical RTL generation with minimal human intervention for RISC-V, marking a meaningful progress for LLM-generated hardware design while maintaining strong functional correctness.

Primary area:
infrastructure, software libraries, hardware, systems, etc.
Keywords:
LLM, Hierarchical Hardware Designs, Verilog Code Generation, Hierarchy, Automation, Knowledge Graph (KG)

Reviews

Among:
Shape:
1234this paper, Bottom 1%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 1.00 over 3 reviews, above 0% of the others.
Reviewer_MkMuOpenReview ↗
Rating
1
Confidence
2
Informativeness
1
Presentation
3
Soundness
1
Read review
Paper summary

This paper proposes a knowledge-based agentic framework to solve the hierarchical verilog generation task. It uses a progressive coding module to incrementally generate pseudo-code and guide by KG.

Critical strengths

None

Critical weaknesses

a. Weak baseline: It only selects one baseline work to do comparison. the author should select other state-of-the-art work, e.g., ACE-RTL. b. The work uses GPT-4o as the base model. However, SOTA LLM has improved a lot compared to GPT-4o. The author should select SOTA model like Opus5.5 or GPT-6 Astra to evaluate the performance. In this way, it can prove that the proposed framework is still valuable under SOTA LLM. c. For Synthesizability Validation, it would be better to include the comparison with baseline. Due to lots of papers are only discussing functional correctness, it is important to show that this framework can produce better PPA compared to others.

Questions for authors

Please address the critical weaknesses described above.

Reviewer_5dRdOpenReview ↗
Rating
1
Confidence
3
Informativeness
2
Presentation
2
Soundness
1
Read review
Paper summary

VeriGraphi is a multi-agent pipeline for generating hierarchical RTL from hardware specification documents. It first produces a structured implementation plan through specification summarization, decomposition, and auditing. A Hierarchical Design Architecture (HDA) knowledge graph then represents modules, interfaces, dependencies, and wiring. The pipeline uses this representation to guide pseudocode generation, RTL generation, compilation-based refinement, and top-level assembly. A separate verification stage generates specification-based testbenches and performs synthesis and physical implementation checks.

The evaluation covers RV32I, AES, DSS, and HMAC. The paper reports 183 passing tests for RV32I, fewer average coding iterations than Spec2RTL-Agent on the three cryptographic tasks, and synthesis/physical metrics for all four designs. The central claimed contribution is the use of an explicit graph representation to improve structural consistency and hierarchical integration. However, the evaluation does not adequately establish the graph's contribution, the completeness of functional correctness, or the generality of the claimed benefits.

Critical strengths
  1. The paper addresses a relevant practical problem with a plausible architectural idea. Making interfaces and wiring explicit before RTL generation could reduce integration ambiguity and improve traceability. The use of an intermediate representation is a reasonable direction for specification-driven hardware generation.

  2. The authors attempt validation beyond compilation. The reported RV32I tests and Yosys/OpenLane results provide preliminary evidence that the workflow can produce implementable artifacts. These are useful feasibility results, although they do not establish comprehensive functional correctness or superiority over existing methods.

Critical weaknesses
  1. The experimental evaluation is substantially too limited to support the paper's broad claims. There are only four design tasks, with one comparison method and no reported repeated-run variability, graph ablations, or systematic scaling analysis. The issue is not simply the number of tasks: the experiments also lack the depth needed to determine whether HDA is responsible for the reported improvements. There is no comparison against an otherwise identical pipeline using a structured textual plan, no removal of explicit connectivity edges, and no measurement of interface or wiring errors before and after introducing the graph. Consequently, the central claim that the graph improves hierarchical generation remains largely untested.

    Functional correctness is also insufficiently substantiated. The paper reports 183 passing RV32I tests without a detailed breakdown of architectural coverage, while corresponding functional test counts and pass rates for AES, DSS, and HMAC are not reported (pp. 8–9). The appendix's integration examples emphasize non-X checks, and the expected value in Table 3 is left blank (pp. 13–14). These excerpts do not prove that all tests are weak, but they provide little auditable support for comprehensive correctness. Generating tests from the specification using another model does not by itself establish an independent, validated ground truth. Likewise, mapping each specification clause to at least one test does not establish the claimed superiority over code-path coverage (§3.5). Synthesis and physical implementation results cannot fill this functional validation gap.

    The comparison metrics further weaken the conclusions. Table 1 reports more human interventions for AES than the baseline (8 versus 4), the same number for DSS (6 versus 6), and fewer for HMAC (0 versus 3). The reported maximum number of fixes over modules does not measure total human effort. Average coding iterations per submodule depend on decomposition granularity and do not establish lower overall cost. The paper does not adequately document matched models, budgets, module decompositions, and success criteria for the comparison. The approximately $0.74 RV32I cost breakdown does not separately account for verification and human repair. Taken together, these results are preliminary case studies rather than convincing evidence of a reliable, efficient framework for large hardware designs.

  2. The core technical mechanism is underspecified, and its claimed guarantees are not established. The HDA is repeatedly described as a deterministic, machine-checkable structural scaffold. However, Listing 8 represents instance_of as a list of module IDs, whereas Algorithm 1 uses it as a set of parent–child edges (pp. 14 and 16). The shown schema does not explain how parent relationships or repeated instances are represented unambiguously. Algorithm 1 explicitly assembles only tier-0 wrappers, leaving the integration of intermediate parent modules unclear for deeper hierarchies.

    Listing 12 instructs an LLM to obey graph connectivity, but the paper does not describe an explicit check that the generated RTL conforms to the intended graph. Compilation is not sufficient to establish that the intended connections, dependencies, and required instances have been preserved. Thus, it is unclear whether the contribution is an enforced structural mechanism or primarily additional structured context supplied to an LLM. The limited visual explanation compounds this issue: neither the overview diagram nor the appendix graph demonstrates an actual constraint violation, its detection, and the resulting correction. This missing technical and empirical substantiation makes the contribution difficult to assess relative to existing hierarchical agent pipelines.

Questions for authors
  1. What evidence isolates the contribution of HDA? Can the authors provide controlled results against an otherwise identical pipeline with a structured textual plan, and with explicit connectivity edges removed? Please report end-to-end functional success, interface/wiring errors, total generation cost, and variation across repeated runs under matched budgets.

  2. What functionality was implemented and independently validated for each design? Please specify the RV32I implementation scope, the DSS algorithm and parameters, and the HMAC hash function. Provide the functional test counts, reference-output sources, and results for all four designs, distinguishing module tests, non-X checks, and end-to-end behavioral tests. How are the expected failures mentioned in §3.5 handled in the final pass/fail statistics?

  3. How are graph constraints enforced in the implementation? Please reconcile the instance_of schema with Algorithm 1, explain intermediate-level assembly and repeated module instances, and identify any programmatic checks for graph validity and RTL–graph consistency. A concrete example of a detected and corrected wiring violation would help establish what the method actually guarantees.

  4. Are the baseline and intervention measurements comparable? Were the Spec2RTL-Agent numbers reproduced or taken from the cited paper? Please specify the models, budgets, module counts, total human fixes, and the nature of those fixes. Do the reported functional and physical results correspond to RTL before or after manual repair? Why does taking the per-module maximum align the intervention metric with the baseline?

Reviewer_zFgbOpenReview ↗
Rating
1
Confidence
4
Informativeness
1
Presentation
3
Soundness
3
Read review
Paper summary

This paper proposes a hierarchical agentic framework to generate complex RTL (in other words, hardware designs). The solution is built on top of a knowledge graph and multiple agents specialized for different roles, including agentic evaluation and rewriting of generated modules .

Critical strengths

Overall the paper does present some data representing the ability of hierarchical agentic workflows to generate a functionally working and synthesizable design.

Critical weaknesses

The crucial weakness of this paper is novelty. Agentic workflows for hierarchical hardware design have existed for the last several years, and although the agents themselves have become much more powerful, I did not see a reflection of the power of modern agents on improving substantially beyond the solutions already proposed in prior work, for example, Nakab et al. The bar for demonstrating the value of agentic solutions for hardware design should now be much higher, including full IP-scale solutions with optimized performance and functional guarantees of correctness.

Questions for authors

How are you confident about the quality and/or functional of correctness of your solutions -- For instance there might be subtle bugs that are not caught by test case simulation approaches.

From OpenReview, CC BY 4.0. Authors as signed there; shown unedited.

Related papers

Loading the map…

Discussion (0)

Sign in to comment.