AI²: Revolutionizing Hardware Verification with AI

 

Hardware verification has always been the quiet bottleneck in chip development. For those working in the industry, it’s a familiar reality: up to 70% of development is consumed by the verification processes in a design lifecycle. Having spent the past year exploring how artificial intelligence might transform this landscape, the results are fascinating. AI² represents a change in how engineers approach hardware verification – not through incremental improvements, but through a rethinking of the verification paradigm.

Traditionally engineers would manually read specs and translate the specification to verification equivalent code. AI² automates this end-to-end: it reads specifications, builds a structured knowledge base from them, and generates UVM testbenches grounded in the inferred design intent.

The Hardware Verification Challenge

Anyone who has spent time in chip development understands the demands of the verification paradox. The tedium of verification that follows the creativity of the design phase, almost always more time consuming than the design itself. Engineers often find themselves wondering: “Have I considered all edge cases? Am I sure a missing latch inference isn’t going to cost millions? Am I sure the chip isn’t going to cause a respin?”

The traditional verification approach has evolved incrementally over the decades, but its fundamental structure remains the same labor-intensive and cognitively demanding. Engineers typically need to:

• Navigate through numerous specification documents, spanning hundreds of pages
• Develop exhaustive test plans that attempt to anticipate the nearly infinite possible scenarios
• Write verification code to methodically check every aspect of the design be it via formal, or Constrained Random Verification (CRV)
• Engage in iterative debugging cycles as and when issues are discovered and discussed with the design team

This approach, while thorough, creates a bottleneck that scales poorly with increasing design complexity. As chips incorporate more functionality and constraints alike, the verification challenge grows exponentially rather than linearly. The result is not just a delayed time to market but also a heightened risk of human error at precisely the point where accuracy is paramount.

How AI² Changes the Game

AI² doesn’t just stand out for the immense time it saves from the verification cycle – it’s the way it rephrases verification. Instead of treating it purely as a testing problem, AI² approaches it as a knowledge problem. At its core, it’s a modular, logic-based system that blends ideas from classic logic programming (think Prolog) with modern techniques in knowledge representation and computational linguistics.

The system works through four interconnected processes:

1. Document Ingestion: AI² processes documentation in various formats – PDFs, Word Documents, and especially specialized formats for the industry like XRSL. Instead of blindly reading the text like most LLM based solutions, AI² extracts structures and relationships, so you can work with your existing documentation instead of having to reformat everything.
2. Knowledge Representation: Using NLP, the system builds both vector databases for semantic search and knowledge graphs to map out how components, requirements, and behaviors are connected. This mix lets AI² do both, contextual and structured reasoning.
3. Verification Code Generation: With a complete understanding of the specification, AI² generates UVM (Universal Verification Methodology) code tailored to the specific design requirements. The focus not just being the isolated check of functions but on verifying the interactions between components, signals and registers at various scales.
4. Workflow Integration: Rather than forcing teams to start anew, AI**2 integrates with existing Verification IPs (VIP) to maintain compatibility with pre-existing verification environments.

The Building Blocks of AI²

The underlying NLP engine relies on Agnisys‘ own proprietary methods, it lies in a novel hybrid approach of knowledge representation and verification. The technological foundation of AI² combines several complementary approaches to solving verification:

• Semantic Document Processing: While traditional parsing approaches that treat text as a linear stream, AI²  processes documents with an understanding of their “intent”. This “intent” fuels the engine to abstract the documentation to a unified knowledge bank that follows the mind of the verification engineer themselves.
• Knowledge Graph Construction: The system constructs a formalized representation that captures entities and their relationships at both a macro and micro level. All the way from registers and fields to the block and chip. This graph becomes a blueprint of the design’s intended behavior, allowing the system to reason about interactions that are implied by the combination of requirements.
• LLM-Powered Generation: The system leverages custom fine-tuned Large Language Models to bridge the gap between structured knowledge and verification code. Converting the queries on the knowledge base into verification code.

Beyond Traditional Approaches

The difference between AI² and traditional verification tools isn’t just technical – it’s philosophical. Conventional systems manage the process: they run simulations, track coverage, and help organize testbenches. But they operate without understanding what the design is supposed to do. Traditional approaches monitor execution, not meaning.

AI² shifts the status quo by building a knowledge base of the design – a representation that captures intent, not just implementation. Rooted in formal AI, it draws on non-monotonic logic, to reason about design behavior the way engineers do. This non-monotonicity in logic stems from time tested ontological methods which further empower AI² to trace the logic behind every single line of code it generates.

This enables AI² to:

• Handle contradictions and ambiguity contextually by highlighting such discrepancies in its knowledge base
• Integrate diverse, incomplete documentation into a coherent whole aided by the team

The result isn’t simple automation but understanding. AI² doesn’t blindly write UVM code; it models design behavior, draws conclusions, and adapts its verification strategy as it learns.

What makes AI² spiritually different is its focus on understanding. The system builds an internal representation of the project that captures design intent rather than just implementation details. It can recognize that register X controls function Y, that certain conditions trigger specific behaviors, and far, far beyond. Knowledge that often solely resides in the minds of the verification engineer.

The underlying mathematics are incredibly intellectually rich. AI²’s reasoning architecture draws on formal ontological structures and non-monotonic logic, a branch of reasoning itself. Treating verification as inference over structured knowledge, not mere code generation. This semantic understanding changes the verification equation fundamentally. Rather than relying solely on predefined test patterns or manually crafted assertions, verification can be driven by the system’s understanding of what the design is supposed to do. The verification becomes more comprehensive not just from the volume of tests, but by a model of the design’s intended behavior informing the code.

Looking Forward

As hardware designs get more intricate, keeping up with verification is becoming a real headache. With each new chip generation, there’s just too much to check manually, and it’s not only a matter of efficiency – this issue could seriously jeopardize hardware development.

Take AI², for instance. Instead of mechanically running tests, it actually figures out the best way to handle verification strategy. This means teams can manage the kind of complexity that would normally overwhelm them.

The cool part is, by automating the tedious parts, engineers can shift their focus to the creative side of design – solving new, tricky problems that really need a human touch. The outcome? Not only do we get verification done faster, but we also unlock the potential for more creative designs.

Looking ahead, it seems likely that verification will evolve alongside design rather than just follow it. Imagine receiving continuous, real-time feedback that actually influences your design decisions as you work – transforming a straightforward, linear workflow into something more flexible and iterative.

And yes, getting NLP right on dense technical documentation was super challenging. But thanks to tailored pipelines in AI², we’re now seeing performance that’s a far cry from what generic models could achieve – all by aligning language understanding directly with hardware needs.