Most LLM-for-hardware work skips waveform debugging
The paper frames its contribution around an imbalance in existing research. Roughly 74.6% of LLM-for-hardware studies concentrate on front-end RTL code generation and synthesis, while post-simulation waveform debugging and dynamic verification remain largely underexplored. Verification itself consumes over 70% of the development cycle, so this is not a marginal omission.
The authors argue the reason is infrastructural rather than a lack of model capability. When a dynamic simulation fails, engineers scrub through terabytes of temporal dumps in graphical waveform viewers, tracing illegal transitions back to their origin in the HDL hierarchy. Raw ASCII waveform dumps exceed model context windows by orders of magnitude, carry no structured semantic index, and expose no native low-latency query interface an autonomous agent could invoke. The paper calls this barrier Infrastructural Impedance.
Waveforms become a two-table relational database
BTTF's offline preprocessing pipeline extracts target hierarchies from proprietary binary waveforms (.fsdb) or ASCII Value Change Dump (.vcd) files and normalizes them into a SQLite database called waves.db. For SoC-scale blocks, a raw VCD text file routinely exceeds 10 GB, so direct context embedding is not an option.
The schema has two primary tables. signal_metadata captures static signal declarations such as RTL signal name and variable type, each with an id. signal_changes records temporal behavior as timestamped (time, value) transitions with a foreign key back to metadata. Separating who a signal is from what it does lets agents reason over structure and time independently, joining the two only when a query demands it.
Because a naive translation of every value change would just move the scalability problem from the filesystem into the database, the pipeline applies coverage-aware pruning during on-the-fly generation. Clock pruning skips high-frequency clock toggles at insertion time, since every row in signal_changes is timestamped and temporal anchoring is preserved. Inactive-signal pruning uses a hash map (vcd_id_to_db_id) and a per-signal transition counter to drop statically silent zero-toggle wires (ZERO) or additionally drop nets whose toggle rate falls below the design-wide average (AVG). Batched insertion via SQL EXECUTEMANY avoids row-by-row transaction overhead.
Aggressive pruning buys speed but loses toggle coverage
The preprocessing trade-off is measured directly. A fully unpruned database occupies 1,420 MB, answers queries in 410.5 ms, and retains 100.00% coverage. Removing clock insertion alone shrinks the footprint by 66.20% to 480 MB and cuts query latency by 3.28× to 125.2 ms while preserving 98.51% of functional toggle coverage.
Pruning untoggled signals pushes the reduction to 72.18% (395 MB, 94.8 ms) while retaining full coverage over active nets. The most aggressive below-average pruning compresses furthest, to 185 MB and 41.6 ms, but sacrifices 35.77% of coverage, which the authors mark as the boundary of safe reduction. On the ingestion side, batched insertion accelerates database generation by up to 2.89× over single-row insertion, removing the I/O bottleneck for multi-terabyte waveforms.
The practical reading is that clock removal and zero-toggle pruning are the safe operating points, while below-average pruning is where coverage loss becomes large enough to matter.
Four agents split planning, querying, checking, and auditing
On top of waves.db, BTTF runs a collaborative multi-agent architecture. The main Orchestration Agent decomposes a natural-language query into sub-goals, routes them to specialized agents with their own toolsets, and audits the merged answer.
The Analysis Agent composes SQLite queries over the two tables for scope discovery, event inspection, and toggle counting, and uses an iterative function-calling loop for multi-turn tasks such as power hotspot detection. The Verification Agent ties waveform anomalies back to version-controlled source by evaluating SVA rules (ASSERT, ASSERT_STATIC, ASSERT_NEVER, ASSERT_KNOWN, COVER) through regular expression assignment. The Evaluation Agent audits candidate queries against five criteria before any root-cause analysis is returned: correctness of filtering, aggregation, and join fidelity; completeness of required columns and time conditions; efficiency of indexing and join avoidance; strict conformance to the two-table schema; and correct inference of implicit simulation timescales and hierarchy scopes.
Agents communicate solely through a dynamic session context maintained across turns, and a self-correction loop handles failed queries. When an assertion rule is violated even after self-correction, the agent isolates the exact violation timestamp and pinpoints the problematic sub-signals responsible for the failure.
Accuracy is near-perfect on primitives and lower on verification
The benchmark spans multiple SoC design hierarchies of varying complexity, drawn from 4.2 GB of VCD and 18,450 nets, with simulation windows ranging from narrow 50 ns high-resolution glitch-debug windows to 800 ns full-transaction dumps. All agents are served through the Gemini API with Gemini-2.5-Pro as the default model. The 150 natural-language verification queries are each paired with an expert-annotated golden answer.
Accuracy varies by task type. Scope/net discovery, value change count, and event timing check each reach 100.00%. Value inspection reaches 95.00%, toggle coverage 91.67%, power hotspot 91.67%, and dynamic SVA check 90.91%. RTL attribution is lowest at 87.50%, and static SVA check reaches 84.62%. The overall figure of 95.33% aggregates these categories, so the headline number should not be read as uniform performance across verification tasks.
Specialization raises quality 17.3% at 1.96× latency
The paper compares its collaborative architecture against a monolithic single-agent design, with an autorater judging outputs on the Evaluation Agent's five criteria. The monolithic agent achieves faster raw response times but frequently suffers from context clutter, schema hallucination, and degraded causal tracing on multi-hop verification tasks, scoring only 3.35/5.00 on the evaluation audit.
BTTF decouples schema-aware SQL generation from RTL source inspection and evaluation, achieving a 17.3% higher reasoning quality score and near-perfect execution accuracy. This specialized delegation incurs an average 1.96× latency overhead, which the authors describe as a practical and necessary trade-off to ensure robust, hallucination-free verification in production EDA workflows.
The comparison matters because it separates two different measures: raw response speed favors the single agent, while audited reasoning quality favors the multi-agent design. A reader optimizing for latency and a reader optimizing for grounded root-cause analysis would draw different conclusions from the same experiment.
The bottleneck is data infrastructure, not model scale
The authors' thesis is that the binding constraint on agentic waveform debugging is data infrastructure rather than model capability. Recasting terabyte-scale waveforms into a compact, vendor-agnostic relational schema turns an intractable context problem into a routine text-to-SQL problem, and the orchestration engine converts that access into grounded, audited root-cause analysis.
The scope conditions are explicit. The benchmark covers multiple SoC design hierarchies but simulation windows of 50 ns to 800 ns, not full-chip runs. The authors name streaming ingestion, standardized scope-path normalization, and a waveform-to-RTL symbol index as the natural next steps for scaling across larger full-chip designs, and evaluating larger frontier reasoning models for multi-hop causal tracing remains future work. The recipe is also presented as extensible beyond waveforms to regression logs, coverage databases, and power traces, but that extension is proposed rather than demonstrated.
The most decision-relevant distinction in this paper is between preprocessing strategies, not between models. Clock removal and zero-toggle pruning preserve 98.51% and 100.00% coverage respectively while cutting footprint by 66.20% and 72.18%, whereas below-average pruning loses 35.77% of coverage for the largest compression. For anyone deciding how to make waveform data agent-ready, that coverage threshold, not the 95.33% headline, is the number that determines whether the resulting database still supports the debugging questions being asked.
Sources used in this answer
Back to the Future: Rethinking EDA Infrastructure for Agentic Systems in Chip Design Verification
BTTF converts unstructured simulation dumps into a normalized relational SQLite database and pairs it with a collaborative multi-agent engine, reaching 95.33% execution accuracy across a 150-query benchmark and scoring 17.3% higher than a monolithic single-agent baseline on a five-criteria quality audit.