🤖 AI

EstRTL: Functional Estimation Guided RTL Code Generation

This paper introduces EstRTL, a three-stage LLM-powered collaborative agent framework that enhances the functional correctness of generated RTL code through static functional score estimation, achieving a 3.2%–9.0% improvement over generic models.

Original authors: Qi Xiong, Renzhi Chen, Bowei Wang, Yuqing Xiong, Libo Huang, Lei Wang

Published 2026-06-10

📖 4 min read☕ Coffee break read

CC BY 4.0

Original authors: Qi Xiong, Renzhi Chen, Bowei Wang, Yuqing Xiong, Libo Huang, Lei Wang

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine you are trying to build a complex machine, like a high-performance car engine, but instead of using wrenches and blueprints, you are asking a very smart, well-read robot to write the instructions for you. In the world of computer chips, these instructions are called RTL code (Register Transfer Level).

The problem is that while these robots (called Large Language Models or LLMs) are great at writing sentences, they often make silly mistakes when writing these technical instructions. They might mix up a "stop" sign with a "go" sign, or put a gear in the wrong place. Usually, checking if the engine actually works requires building a massive, expensive test track (called a "testbench") to run the car, which takes a lot of time and money.

Enter EstRTL: The "Quality Control" Team

The paper introduces EstRTL, a new system that acts like a three-person quality control team working together to fix the robot's mistakes before the engine is ever built. Instead of just asking the robot to "do it again," this system uses a clever loop of Generation, Estimation, and Correction.

Here is how the team works, using a simple analogy:

1. The Generator (The Architect)

First, the Code Generation Agent is the architect. It listens to your request (e.g., "Build a counter that counts to 255") and draws up the initial blueprints (the RTL code).

The Check: Before anyone looks at the design, a grammar checker ensures the blueprints aren't nonsense (like missing brackets or typos). If the blueprints are grammatically wrong, the architect redraws them immediately.

2. The Estimator (The Intuitive Inspector)

This is the paper's biggest innovation. Usually, to know if a blueprint works, you have to build the whole engine and test it. That's slow.

The Trick: The Functional Estimation Agent is like a super-intuitive inspector who looks at the blueprint and says, "I haven't built this yet, but based on the design, it looks 85% likely to work."
How it works: It doesn't build the engine. Instead, it reads the blueprint and tries to write a description of what the machine should do. Then, it compares that description to your original request.
- Analogy: If you asked for a "red sports car," and the blueprint describes a "blue truck," the inspector knows immediately that something is wrong, even without seeing the car.
The Decision:
- If the score is low (the design looks terrible), the inspector sends it back to the Architect to start over completely.
- If the score is medium (the design is okay but has some flaws), it sends it to the Fixer.

3. The Corrector (The Mechanic)

The Code Correction Agent is the mechanic. It doesn't just guess; it uses a "Chain of Thought" process.

The Process: It first asks, "Where exactly is the problem? Why is it happening?" (e.g., "The gear is on the wrong axle because the robot confused 'left' with 'right'").
The Fix: Once it understands the why, it rewrites the specific part of the blueprint to fix the error. It then sends the fixed blueprint back to the Inspector to double-check.

Why is this a big deal?

The paper claims that by adding this "Inspector" and "Mechanic" team to the process, the system significantly improves the success rate of the robots.

The Results: When they tested this on a standard set of 156 hardware design tasks, the system improved the accuracy of the robots by 3.2% to 9%.
The Efficiency: The "Inspector" was able to tell the difference between a working design and a broken one with about 78% accuracy without needing to build the expensive test track.
The Fixer: The mechanic successfully fixed over 12% of the errors that the robots made on their own.

The Bottom Line

Think of EstRTL as a safety net. Instead of trusting a robot to get it perfect on the first try (which it rarely does), this system creates a loop where the robot writes, an AI inspector grades it, and an AI mechanic fixes the bad parts. This ensures that the final code is not just grammatically correct, but actually does what you asked it to do, saving engineers from having to manually debug thousands of lines of code.

The authors have made this "team" open-source, meaning anyone can use this three-stage process to help their own robots write better hardware code.

Technical Summary: EstRTL – Functional Estimation Guided RTL Code Generation

Problem Statement

Manual Register Transfer Level (RTL) design is a time-consuming and error-prone process, particularly for complex systems like modern processors. While Large Language Models (LLMs) have shown promise in generating syntactically correct code from natural language prompts, existing methods for RTL generation face significant limitations regarding functional correctness. Current approaches primarily focus on model fine-tuning, data augmentation (e.g., RAG), or syntax checking. However, they often lack mechanisms to ensure the generated code behaves as intended in real hardware implementations.

A critical bottleneck is the reliance on testbenches for verification. Manually creating testbenches is labor-intensive, while automatically generated testbenches often lack comprehensiveness. Consequently, many existing methods focus solely on syntactic correctness rather than functionality. Furthermore, code generation and code fixing are often studied separately, and existing fixing methods typically rely on binary pass/fail evaluations, offering no intermediate feedback for iterative optimization.

Methodology: The EstRTL Framework

To address these challenges, the authors propose EstRTL, an LLM-powered collaborative agent framework based on static functional score estimation. EstRTL operates on a three-stage paradigm: Generation, Estimation, and Correction.

1. Generation (Code Generation Agent)

The process begins with a Code Generation Agent that produces RTL code based on natural language specifications.

Syntax Verification: The generated code undergoes a syntax check using Icarus Verilog. If errors are found, the agent receives error messages and regenerates the code. This loop is limited to three iterations to prevent infinite loops.
Error Reminders: The system incorporates "error reminders" summarizing common fixed errors (e.g., preferring assign over always blocks for simple combinational logic) to guide the agent during regeneration.

2. Estimation (Functional Estimation Agent)

Once the code passes syntax checks, it is routed to the Functional Estimation Agent, which acts as the central decision-making hub. This agent performs static functional score estimation without executing testbenches.

Reverse Requirement Generation: The agent uses an LLM to reverse-engineer the generated RTL code back into natural language requirements.
Scoring Mechanism: The agent calculates a VFCS (Functional Correctness) score based on three components:
1. Semantic Similarity: Calculated using pre-trained models (e.g., all-MiniLM-L6-v2, roberta-large) to measure the similarity between the original specifications and the reversed requirements at both token and sentence levels.
2. Completeness Score: A penalty-based metric ( $C$ ) that evaluates missing or extra keywords (nouns/verbs) between the original and reversed requirements.
3. LLM Comprehension Score ( $L_{LLM}$ ): An LLM-based evaluation of the code's functional correctness given the scores above.
Decision Logic:
- Unacceptably Low Score: The code is returned to the Generation Agent for complete regeneration.
- Failing but Improvable: The code is forwarded to the Correction Agent.
- High Score: The code is accepted as functionally correct.

3. Correction (Code Correction Agent)

For code deemed "failing but improvable," a Code Correction Agent based on Chain of Thought (CoT) reasoning is employed.

Reasoning Stage: The LLM analyzes the code against specifications to identify specific output signals with errors, the input conditions triggering these errors, and the underlying logical causes.
Correcting Stage: Based on the reasoning, the agent modifies the RTL code, incorporating safeguards to prevent the recurrence of known issues and ensuring consistent coding style.
Iterative Loop: The corrected code is re-evaluated by the Functional Estimation Agent. This loop continues until the code passes the functional check.

Key Contributions

LLM-Agent Framework: Developed a collaborative framework that increases the success rate of generic LLMs on the VerilogEval dataset by 3.2% to 9.0%.
Testbench-Free Functional Estimation: Introduced a method to estimate RTL functionality without testbenches by leveraging reverse requirement generation and semantic similarity, achieving an average precision of 84.2% in distinguishing correct from incorrect code.
Integrated Feedback Loop: Created a seamless integration of generation, estimation, and correction, where the estimation agent provides quantitative scores and fine-grained guidance, successfully fixing over 12% of erroneous RTL code.
Open-Source Framework: The EstRTL framework is open-sourced and designed to be model-agnostic, applicable to various LLMs (both generic and domain-specific) to enhance code correctness.

Experimental Results

The framework was evaluated on the VerilogEval-v1-Human and VerilogEval-v2 datasets using four state-of-the-art LLMs (Qwen-Plus, Qwen3-32B, DeepSeek-Chat, GPT-4o) and compared against baselines including RTLFixer, VeriAssistant, and specialized models like OriGen and CodeV.

Generation Accuracy: EstRTL improved the Pass@1 accuracy of generic LLMs by 3.2% to 9.0%. For instance, DeepSeek-Chat improved from 73.1% to 76.3% on VerilogEval-v1-Human.
Estimation Performance: The Functional Estimation Agent demonstrated high precision (up to 88.9% for DeepSeek-Chat) and accuracy (up to 78.2% for Qwen3-32B) in classifying functional correctness.
Correction Capability: The Code Correction Agent achieved a net correction rate of 12% to 17%, successfully fixing a significant portion of errors while introducing minimal new regressions.
Extensibility: The framework successfully integrated with specialized RTL models (OriGen, RTLCoder, CodeV-QC), yielding consistent performance improvements (e.g., CodeV-QC improved by 11.5% on VerilogEval-v2) without requiring retraining or parameter tuning.
Robustness: The system showed robustness to the decision threshold used for classification, maintaining stable performance across a range of threshold values (0.38 to 0.54), suggesting that a fixed threshold can be used across different models.

Significance and Claims

The paper claims that EstRTL addresses the critical gap between syntactic correctness and functional correctness in AI-assisted hardware design. By replacing labor-intensive testbench creation with static functional score estimation, the framework bridges the gap between code generation and correction.

The authors emphasize that their approach provides quantitative scores and human-readable requirements comparisons, thereby improving the transparency of AI-assisted RTL generation. They assert that the framework is not merely a competing model but a plug-and-play enhancement that can be applied to various existing LLMs to significantly boost their reliability in hardware design tasks. The work is presented as a foundational step toward more robust and automated hardware design workflows, shifting the focus from mere code generation to verified, functional hardware descriptions.