Agentic AI Meets Formal Verification in the Era of Agentic Hardware Development

Wenji Fang, Yuchao Wu, Jing Wang, Zhiyao XiearXiv 2026 · arXiv

TL;DR

As AI agents increasingly take over the generation and optimization of hardware circuits, the risk of "hallucinated" or buggy hardware grows. This paper explores a powerful synergy: using agentic AI to automate the notoriously difficult field of formal verification, while simultaneously using those formal methods to provide a "ground truth" feedback loop that ensures AI-generated hardware is actually correct.

What Problem Does This Paper Address?

We are entering the era of agentic hardware development, where Large Language Models (LLMs) and AI agents generate Register Transfer Level (RTL) code from natural language descriptions. However, LLMs are prone to functional errors, and traditional verification (like simulation) is often too slow or incomplete to catch subtle bugs in complex designs.

Formal verification—mathematically proving that a design meets its specification—is the "gold standard" for correctness. Historically, it has been hampered by a high barrier to entry: it requires rare expertise to write formal properties (like SystemVerilog Assertions) and construct complex proofs. The authors address this bottleneck by showing how AI can lower the barriers to formal methods, creating a self-improving cycle for autonomous hardware design.

Figure 1: Advances in AI make hardware generation and opti- mization more accessible, increasing the demand for formal verification. Meanwhile, AI lowers the barriers to developing and applying formal methods, creating opportunities to inte- grate formal reasoning into agentic hardware development.

Methods

The paper organizes the intersection of AI and formal methods into two main perspectives:

1. Agentic AI for Hardware Formal Methods (Methodology)

This focuses on how AI makes verification easier across three levels:

  • Specification: AI agents translate natural language into formal properties (SVA) or executable reference models (in C or Lean).
  • Proof Construction: AI guides traditional tools by suggesting "hints," invariants, and lemmas that help model checkers and theorem provers find solutions faster.
  • Reasoning Engines: AI is used to "discover" and optimize the underlying algorithms (like SAT solvers) by evolving their code to be more efficient.
Figure 2: Overview of our taxonomy of hardware formal verification methodology and application.

2. Formal Methods for Agentic Hardware Development (Application)

This focuses on using formal tools to "guardrail" AI hardware generation:

  • Generation: Using formal feedback (e.g., "this assertion failed") to let an LLM iteratively fix its own code.
  • Debugging: Using formal counterexamples to perform root-cause analysis on bugs.
  • Optimization: Using formal equivalence checking to ensure that when an AI optimizes a circuit for power or speed, it doesn't accidentally change its behavior.

Datasets

The authors highlight several benchmarks used to evaluate these systems:

  • AssertLLM2: A new benchmark introduced by the authors containing 83 designs to evaluate the quality of AI-generated assertions based on syntax, provability, and "bug-kill" ratios.
  • ScaleBench: A 200-design benchmark used to test the CorrectRTL framework.
  • FVEval & AssertionBench: Existing benchmarks for evaluating assertion generation.

Key Insights and Ideas

  • The "Formal Gap": The authors found that while LLMs are great at generating syntactically correct assertions (93% success), they struggle with "proof coverage." Only about 23% of generated assertions actually provided effective verification coverage, highlighting the need for better intent alignment.
  • AI-Native Reasoning: We are moving beyond just using AI as a "chatbot" for engineers. Projects like SATLUTION and IC3-Evolve show that AI can autonomously evolve the source code of verification tools, discovering heuristics that outperform human-designed ones.
  • Completeness Matters: The paper emphasizes moving from individual properties to executable reference models. While individual assertions might pass even if the design is wrong, a reference model captures the full state-transition behavior, providing a much stronger guarantee of correctness.
Comparing property checking vs. executable reference models for completeness.

Key Results

  • CorrectRTL: By using SVA-based formal feedback for self-correction, the framework improved the "Pass@1" rate (the probability of the first generated design being correct) from 20.5% to 49.0% on the ScaleBench benchmark.
  • CircuitProver: This agentic theorem prover reduced the average number of proof rounds required from 9.2 to 4.6, demonstrating much more efficient proof planning.
  • Dr. RTL: An agentic optimization tool that achieved a 21.3% improvement in timing (worst negative slack) while maintaining an 86% success rate in formal equivalence checking.
  • SAT Competition: An AI-optimized SAT solver (AE-Kissat-MAB) won the main track of the 2025 SAT Competition, proving that AI-discovered algorithms can beat the state-of-the-art.
The CorrectRTL workflow for iterative self-correction.

Limitations and Future Work

Despite the progress, several challenges remain:

  • Inference Cost vs. Benefit: Interactive AI agents can be slow and expensive. Balancing the "thinking time" of an AI agent against the speed of traditional verification is a key hurdle for large-scale designs.
  • Intent Alignment: How do we ensure the AI-generated formal specification actually matches what the human designer intended? If the spec is wrong, the "proof" is meaningless.
  • Scalability: Most current results are on small-to-medium modules. Scaling these agentic workflows to multi-million gate SoCs remains an open research area.

The authors conclude by envisioning "proof-native" hardware development, where formal reasoning isn't a final check, but a continuous, integral part of the design process from the very first prompt.

Summary updated

Abstract

As AI agents become increasingly capable of generating and optimizing hardware circuits, ensuring the correctness of AI-generated designs becomes more important. Meanwhile, advances in AI lower the barriers to developing and applying formal methods, creating new opportunities to automate and improve hardware verification. This invited paper presents an overview of the methodologies and applications of hardware formal methods in the AI era. First, we examine how agentic AI advances hardware formal methods across three levels: specification, proof construction, and reasoning engines. Second, we discuss how formal methods support reliable AI-driven hardware development through RTL generation, debugging, and correctness-preserving optimization. We review representative research alongside our recent contributions, highlighting key technical advances and insights from experimental results. Finally, we discuss future research opportunities toward proof-native hardware development, where formal reasoning could become an integral part of autonomous hardware design.
BibTeX
@misc{fang2026agentic,
  author = {Wenji Fang and Yuchao Wu and Jing Wang and Zhiyao Xie},
  title = {{Agentic AI Meets Formal Verification in the Era of Agentic Hardware Development}},
  year = {2026},
  eprint = {2611.13705},
  archivePrefix = {arXiv},
  url = {https://arxiv.org/abs/2611.13705},
}
Figure