Loading Gawtham's portfolio
All writing

agentic chip verification and its future

Working in ASIC Design Verification (DV) at Qualcomm for over half a year now, I've quickly come to realize how much of the work can be automated in the age of artificial intelligence. I wanted this blog to give an idea of how this can be done, the current limitations, and why it's so necessary in the first place.

Why We Need Design Verification

Verification is one of the key bottlenecks in today's chip design industry. As chips become more powerful and complex, the verification infrastructure needed to ensure their correctness must grow alongside them. Adding a new feature to a chip doesn't just mean adding tests to verify that the feature works. We also need to ensure that it doesn't unintentionally break any of the existing functionality.

Design verification is not a trivial task. When these chips are deployed in real-world applications, they'll inevitably encounter corner cases that the designer may not have anticipated.

For example, imagine we needed to design a simple FIFO (First-In, First-Out) buffer. The edge cases might be relatively easy for an experienced RTL designer to think about. We need to consider what happens when the FIFO is full, empty, or receives simultaneous read and write requests.

Animated explainer 01
01

Even a FIFO has corner cases. Write A, B, C; read A, B, C. A write alone cannot add an item to a full buffer, and a read cannot remove an item from an empty one.

Animation description

A three-entry FIFO fills with A, then B, then C. A write of D is blocked because the buffer is full and no read is occurring. Reading removes A first, then B, then C, preserving their arrival order. A further read is blocked because the FIFO is empty. The lesson is to check ordering and full/empty boundaries against the specification.

But now imagine having to think about all the possible situations that can occur in a full-blown CPU. Suddenly, we have thousands of interacting components, complex state machines, multiple clock domains, and countless combinations of events that could expose bugs.

That's why we need entire teams of DV engineers to stress-test designs and ensure that they satisfy their specifications.

Think about what happens if a critical bug escapes verification. The chip goes to tapeout, silicon comes back, and we discover a serious functional issue. Depending on the severity, the company could face a costly silicon respin, delays, and potentially millions of dollars in losses.

This is why getting verification right is so important. And as RTL becomes increasingly complex, the amount of work required to verify it continues to grow.

The Need to Make It Agentic

Coming in as an intern, I realized that a lot of the tasks I was being given could be automated.

For example, I was tasked with manually triaging regression test logs to figure out the most common error signatures and which regression areas they were coming from. I realized that with AI and some automation, I could make this process much easier and create a dashboard so that engineers across the team could quickly identify the problems that needed attention.

Another task involved reproducing errors discovered during regression runs so that engineers could debug them. Initially, I was doing this manually, but I quickly learned how much of the process could be automated, from identifying the failing test and random seed to recreating the conditions that originally caused the failure.

Through experiences like these, I started thinking about what would happen if we took this automation a step further.

Instead of just automating individual tasks, what if we built a system that could decide what to test, identify failures, investigate their causes, propose fixes, and independently verify those fixes?

This is where I think the future of chip design verification is headed: agentic verification.

The Agentic Verification Loop

With my ASIC DV experience at Qualcomm, I've started thinking about how an agentic verification system could be structured.

I think it needs a few key processes, each handled by a specialized agent.

Firstly, the inputs to this loop would be the actual RTL, the specifications describing what the RTL is supposed to do, the existing verification environment, and any additional design constraints.

We then need an orchestrator, which manages the individual agents, keeps track of the workflow state, enforces iteration limits, and decides which action to take next based on the results.

Now, the actual agents.

Animated explainer 02
02

Five steps, one verified repair. Plan what correctness means, test the design, investigate a failure, propose a repair, and independently check it. The orchestrator chooses the next action.

Animation description

Five boxes run from left to right: Plan, Test, Triage, Repair, and Verify. One box is highlighted at a time. Planning defines correct behavior; testing exercises the requirements; triage reproduces and locates a failure; repair proposes a small RTL change; independent verification reruns the failing test and checks existing behavior. The orchestrator chooses what happens next. This is a simplified walkthrough of the proposed architecture.

Agent 01

Specification and Verification Planning

The first agent would be responsible for understanding the design specifications and determining what correct behavior looks like.

For example, imagine we're verifying a FIFO. This agent would identify requirements such as preserving the order of data, handling full and empty conditions correctly, and ensuring that writes aren't accepted when the FIFO is full, assuming the design doesn't support simultaneous read/write acceptance in that state.

The important part is that this agent understands the intended functionality before any tests are created.

Otherwise, how would we know whether the RTL is actually wrong?

Agent 02

Test Generation and Verification

The second agent would take the requirements from Agent 1 and determine how to verify them.

Going back to the FIFO example, it might create a test that attempts to write data when the FIFO is full, then checks whether the RTL handles that request according to the specification.

It would also determine which SystemVerilog Assertions (SVA) are necessary, what functional coverage needs to be collected, and which corner cases are worth testing.

Ideally, this agent would work with directed tests, constrained-random verification, assertions, and potentially formal verification.

Rather than just generating random inputs, we'd want the agent to make intelligent decisions about what to test based on which parts of the specification remain unverified.

Of course, the generated tests and assertions also need to be validated. An incorrect assertion can make a perfectly functional RTL design appear broken.

Agent 03

Failure Triage and Root-Cause Analysis

The third agent would be responsible for triaging failures and performing an initial root-cause analysis.

Suppose we run a thousand regression tests and a hundred of them fail.

Rather than investigating all hundred independently, the agent could group failures by common error signatures, failing assertions, and affected signals.

It could then prioritize failures based on their frequency, severity, and reproducibility.

One useful approach would be to identify the shortest reproducible failing test. Debugging a failure that occurs after 50 clock cycles is generally much easier than investigating one that appears after 50,000 cycles.

This is especially important with constrained-random verification, where reproducing a particular failure may require preserving the exact seed, test configuration, and simulation environment.

Once a failure is reproduced, the agent could examine the relevant waveform, identify where the first incorrect behavior occurred, and trace backward through the RTL to find potential root causes.

One interesting concept here is the cone of influence, which lets us narrow our attention to the signals and logic that could have affected the failing output.

Rather than feeding an AI agent an entire waveform containing thousands of signals, we could provide a smaller, more relevant set of signals and RTL logic.

The goal of this agent isn't necessarily to fix the bug. It's to give the next agent enough context to understand what went wrong.

Agent 04

RTL Repair

The fourth agent would be responsible for proposing a fix to the RTL.

It would receive the failure report, relevant waveforms, suspected root cause, and the original specifications.

Based on that information, it would attempt to make a minimal change to the RTL that resolves the problem.

Ideally, we'd want to isolate these changes so that each proposed fix can be tested independently without modifying the original working version of the design.

At this point, you might think the job is done.

The agent found a bug, proposed a fix, and the original test now passes.

But I think the most important part of this entire architecture is what comes next.

Agent 05

Independent Fix Verification

The fifth agent would be responsible for verifying the RTL repair agent's proposed fix.

It's crucial that this agent acts independently from the repair agent.

First, it needs to verify that the fix actually works and passes the test that originally failed.

Second, it needs to ensure that the modification doesn't break any other existing functionality. This means running relevant regressions, assertions, and potentially formal checks.

Lastly, and most importantly, it needs to ensure that the proposed fix still satisfies the original specifications.

AI agents can make substantial changes to RTL just to ensure that a previously failing test passes. But passing one test doesn't necessarily mean the design is correct.

As a simple example, imagine a piece of RTL that is supposed to output signal A when enable is high and signal B when enable is low.

Suppose the original RTL has a bug where it always outputs A.

We create a test with enable = 0, expecting B, but the RTL produces A. The test fails.

Now imagine the repair agent changes the RTL to always output B.

Our previously failing test passes!

But we've clearly introduced another bug, because the design no longer outputs A when enable is high.

This is exactly the type of mistake that an independent verification agent should catch.

And I think this is one of the biggest challenges with autonomous RTL design: how do we ensure an AI-generated fix actually preserves the intended functionality, rather than simply making an error disappear?

The verification agent shouldn't just rely on another LLM to decide whether the patch looks correct. Its conclusions should be backed by trusted tests, reference models, assertions, and formal verification results wherever possible.

A Simple Example of the Entire Loop

Let's put all five agents together using that same example of a simple 2-to-1 multiplexer.

Our specification is straightforward: if enable = 1, the output should be A. Otherwise, it should be B.

Animated explainer 03
03

A passing test is only the beginning. Changing an always-A mux to always-B moves the bug. Checking both input selections exposes the bad repair; the conditional assignment satisfies both cases.

Animation description

A two-row table checks a multiplexer: enable zero should select B, and enable one should select A. Three assignments are tried in sequence. Always outputting A fails the first row. Always outputting B makes the first row pass but breaks the second. The conditional assignment, out = enable ? A : B, passes both rows. Each row is revealed separately so the new failure is visible. The example uses distinct symbolic inputs A and B; it illustrates the specification rather than claiming complete verification for arbitrary RTL.

Agent 1 reads this specification and identifies the two behaviors we need to verify. It understands that both possible values of enable must produce the correct output.

Agent 2 creates tests for both conditions. It might also generate a simple assertion that checks whether the output always matches the selected input.

Agent 3 receives the results of our initial regression. It notices that the test with enable = 0 fails because the output is A instead of B. After examining the relevant RTL, it suspects that the selection logic is incorrect and passes this information to the repair agent.

Agent 4 attempts to fix the issue. In its first attempt, it changes the RTL so that the output always equals B.

The original failing test now passes.

But Agent 5 runs the broader verification suite and notices that the test with enable = 1 now fails. The repair hasn't actually fixed the design; it has just moved the problem somewhere else.

The orchestrator rejects this patch and sends the new failure information back into the loop.

On the next iteration, Agent 4 proposes the correct selection logic:

SystemVerilog
assign out = enable ? A : B;

Agent 5 reruns the verification checks, confirms that both input selections behave correctly, and checks that the relevant assertions and regression requirements are satisfied.

The orchestrator can now accept the fix based on the evidence collected.

This is obviously a very simple example, but the same general architecture can be applied to much more complex RTL, where the number of possible states and interactions becomes far too large to reason about manually.

The key idea is that the system isn't simply trying to make tests pass. It's using verification feedback to guide its next decision.

Two Loops, Not One

With these agents, I think a fully agentic chip verification system would benefit from having two separate feedback loops.

The first would be the Verification Discovery Loop, involving the specification agent, test-generation agent, and failure-triage agent.

Its job would be to continuously improve our understanding of the design, identify missing verification scenarios, generate new tests, and discover bugs.

For example, if our regression passes but functional coverage shows that we've never exercised a particular FIFO condition, the system could generate a targeted test to explore that scenario.

The second would be the RTL Repair Loop, involving the repair agent and independent fix verifier.

This loop would attempt to fix identified bugs, run verification on the proposed changes, and use any new failures to improve the next repair attempt.

Animated explainer 04
04

Two loops, two different jobs. Discovery asks what to test next. Repair asks whether a proposed fix preserves the intended behavior. The orchestrator decides which loop runs next.

Animation description

The discovery panel appears first: Test leads to Inspect, and the results help choose the next test. Its question is: what should we test next? A failure then leads to the repair panel: Patch leads to Check, and a rejected patch returns for another attempt. Its question is: does this fix preserve behavior? The repair checks are independent. The two panels remain visible for comparison, with the orchestrator deciding which loop runs next.

The important distinction is that the first loop is focused on finding problems, while the second is focused on fixing them without introducing new ones.

Both loops would communicate through the orchestrator, which would decide whether to generate more tests, investigate a failure, attempt another repair, or stop.

The Current Limitations

Of course, there are still some major challenges before a system like this could be trusted to operate fully autonomously.

The first is specification quality. If the original specifications are incomplete or ambiguous, how can we expect an AI to know what correct behavior looks like?

The second is verification quality. An agent might generate hundreds of tests or assertions, but that doesn't necessarily mean it's checking the right things. We need a way to evaluate the verification environment itself.

The third is scalability. Running large regressions and formal verification repeatedly can be computationally expensive, especially for complex designs. Formal tools can also struggle to prove certain properties within practical resource limits.

And finally, there's the question of trust. Even if every test passes, that doesn't guarantee the design is free of bugs. We need clear verification criteria, reproducible results, and a way to distinguish between a proven property, a passing simulation, and an inconclusive result.

These are problems that traditional DV engineers already deal with. Making the process agentic doesn't remove them; it makes solving them even more important.

The Future of Agentic Verification

As AI becomes better at generating and modifying RTL, I think the demand for reliable verification will only increase. There's little value in generating RTL faster if we can't establish confidence that it works correctly.

I don't think the future of DV is simply replacing engineers with AI agents. I think it's about allowing engineers to spend less time on repetitive debugging tasks and more time defining what correctness means, building better verification methodologies, and investigating the problems that actually require engineering judgment.

The future isn't just AI that can write RTL. It's AI that can help us prove, with trustworthy evidence, that the RTL does what we intended.