Paper deep dive
RefEvo: Agentic Design with Co-Evolutionary Verification for Agile Reference Model Generation
Yifan Zhang, Jianmin Ye, Jiahao Yang, Xi Wang
Intelligence
Status: succeeded | Model: Gemma-4-26B-A4B | Prompt: intel-v1 | Confidence: 100%
Last extracted: 6/21/2026, 8:12:42 AM
Summary
RefEvo is a dynamic multi-agent framework designed to automate the generation of high-fidelity SystemC reference models for System-on-Chip (SoC) designs. It addresses three key challenges in LLM-based hardware modeling: workflow rigidity, context window overflow (catastrophic forgetting), and 'Coupled Validation Failure' (where the model and testbench share the same hallucinations). The framework utilizes three core innovations: a Dynamic Design Planner for autonomous task decomposition, a Co-Evolutionary Verification Mechanism featuring a Dialectical Arbiter to simultaneously refine the model and the testbench, and a Spec Anchoring Strategy for lossless context compression. Experimental results show RefEvo achieves a 95% pass rate on a 20-module benchmark and reduces token consumption by an average of 71.04%.
Entities (8)
Relation Signals (6)
RefEvo → addresses → Coupled Validation Failure
confidence 100% · To address these limitations, we introduce RefEvo... (2) A Co-Evolutionary Verification Mechanism... effectively mitigating false positives [from Coupled Validation Failure].
RefEvo → addresses → Catastrophic Forgetting
confidence 100% · To solve catastrophic forgetting, we implement an Optimization component [Spec Anchoring Strategy].
RefEvo → hascomponent → Dynamic Design Planner
confidence 100% · RefEvo features three key innovations: (1) A Dynamic Design Planner...
RefEvo → hascomponent → Co-Evolutionary Verification Mechanism
confidence 100% · RefEvo features... (2) A Co-Evolutionary Verification Mechanism...
RefEvo → hascomponent → Spec Anchoring Strategy
confidence 100% · RefEvo features... (3) A Spec Anchoring Strategy...
Co-Evolutionary Verification Mechanism → usesagent → Dialectical Arbiter
confidence 100% · a Co-Evolutionary Verification Mechanism, which employs a Dialectical Arbiter
Cypher Suggestions (0)
No Cypher suggestions yet.
Abstract
Abstract:As the complexity of System-on-Chip (SoC) designs grows, the shift-left paradigm necessitates the rapid development of high-fidelity reference models (typically written in SystemC) for early architecture exploration and verification. While Large Language Models (LLMs) show promise in code generation, their application to hardware modeling faces unique challenges: (1) Rigid, static workflows fail to adapt to varying design complexity, causing inefficiency; (2) Context window overflow in multi-turn interactions leads to catastrophic forgetting of critical specifications; and (3) the Coupled Validation Failure problem--where generated Testbenches (TBs) incorrectly validate flawed models due to correlated hallucinations--severely undermines reliability. To address these limitations, we introduce RefEvo, a dynamic multi-agent framework designed for agile and reliable reference modeling. RefEvo features three key innovations: (1) A Dynamic Design Planner that autonomously decomposes design specifications and constructs tailored execution workflows based on semantic complexity; (2) A Co-Evolutionary Verification Mechanism, which employs a Dialectical Arbiter to simultaneously rectify the model and verification logic against the specification (Spec) oracle, effectively mitigating false positives; and (3) A Spec Anchoring Strategy for lossless context compression. Evaluated on a diverse benchmark of 20 hardware modules, RefEvo achieves a 95% pass rate, outperforming static baselines by a large margin. Furthermore, our context optimization reduces token consumption by an average of 71.04%, achieving absolute savings of over 70,000 tokens per session for complex designs while maintaining 100% specification recall.
Tags
Links
- Source: https://arxiv.org/abs/2604.24218v1
- Canonical: https://arxiv.org/abs/2604.24218v1
Trouble viewing inline? Open PDF directly →
Full Text
28,048 characters extracted from source content.
Expand or collapse full text
RefEvo: Agentic Design with Co-Evolutionary Verification for Agile Reference Model Generation Yifan Zhang 1,2 , Jianmin Ye 1,2 , Jiahao Yang 2 , Xi Wang 1,2* 1 School of Integrated Circuits, Southeast University, China 2 National Center of Technology Innovation for EDA, China Email: yifan.zhang, jianmin y, xi.wang@seu.edu.cn, yangjiahao@nctieda.com * Corresponding author. Abstract—As the complexity of Systems-on-Chip (SoC) esca- lates, the “shift-left” strategy necessitates the rapid development of high-fidelity reference models (e.g., in SystemC) for early architecture exploration and verification. While Large Language Models show promise in code generation, applying them to hard- ware modeling faces distinct challenges: (1) rigid, static workflows fail to adapt to varying design complexities, causing inefficiency; (2) context overflow in long-turn interactions leads to the catas- trophic forgetting of critical specifications; and (3) the “Coupled Validation Failure” problem—where generated TBs falsely verify flawed models due to shared hallucinations—severely undermines reliability. To address these limitations, we introduce RefEvo, a dynamic multi-agent framework designed for agile and reliable modeling. RefEvo features three key innovations: (1) A Dynamic Design Planner that autonomously decomposes specifications and constructs tailored execution workflows based on semantic com- plexity; (2) A Co-Evolutionary Verification Mechanism, which employs a Dialectical Arbiter to simultaneously rectify the model and verification logic against the specification (Spec) oracle, effectively mitigating false positives; and (3) A Spec Anchoring Strategy for lossless context compression. Evaluated on a diverse benchmark of 20 hardware modules, RefEvo achieves a 95% pass rate, outperforming static baselines by a large margin. Further- more, our context optimization reduces token consumption by an average of 71.04%, achieving absolute savings of over 70,000 tokens per session for complex designs while maintaining 100% specification recall. Index Terms—LLM, LLM-aided Design, Function Verification, Reference Model, Agentic System I. INTRODUCTION In the modern Electronic Design Automation (EDA) land- scape, high-level reference models written in languages like SystemC or C++ have become critical assets [1]. These models serve as the “golden standard” for verifying Register Transfer Level (RTL) implementations and act as virtual prototypes for early software development [2]–[4]. Their importance is fur- ther amplified by the industry-wide adoption of the “shift-left” methodology, which mandates early validation through virtual platforms to enable hardware-software co-verification prior to silicon fabrication. However, despite their necessity, manually crafting these high-fidelity models remains a labor-intensive and error-prone process, creating a significant bottleneck in the agile hardware development cycle [5], [6]. Fig. 1.Performance capability of state-of-the-art LLMs using optimized prompt engineering and structured generation workflows (without Co- Evolutionary Verification). The radar chart highlights the significant struggle of current models in generating correct SystemC reference models across various hardware domains, particularly in Control Logic and Memory & I/O. To alleviate this engineering burden, recent advancements in Large Language Models (LLMs) have sparked intense interest in automating EDA tasks [7], [8]. While LLMs like GPT- 4 have demonstrated remarkable proficiency in generating generic software, applying them to the strict constraints of hardware modeling presents unique challenges. Within the hardware domain, the majority of research progress has been concentrated on RTL code generation, exemplified by ap- proaches such as RTLCoder [9], ChatChisel [10], ReChisel [11], and ChatCPU [12]. Complementing these generation efforts, benchmarking studies [13] have also established robust evaluation frameworks specifically for assessing LLM capabil- ities in Verilog. However, SystemC modeling, which requires precise han- dling of transaction-level modeling (TLM) semantics, bit- widths, concurrency, and delta-cycle timing, remains a distinct challenge [14]. As illustrated in Fig. 1, even when equipped with specialized design workflows and sophisticated prompt engineering [15], [16], advanced models struggle significantly to produce functional SystemC models across various hard- ware domains. A naive or purely structured application of arXiv:2604.24218v1 [cs.SE] 27 Apr 2026 LLMs often results in code that looks plausible but fails to compile or simulate correctly. We identify three primary hurdles hindering the practical adoption of LLMs in this domain: Syntactic and Semantic Correctness: Hardware models must adhere to strict event-driven simulation semantics. LLMs frequently generate code with subtle API misuses or missing library dependencies, leading to compilation failures that naive generation cannot resolve. Coupled Validation Failure: A critical risk arises when LLMs generate both the design under test (DUT) and the testbench (TB). Traditional static flows [17] often lead to a sycophantic scenario where the TB is inadvertently tailored to match the DUT’s hallucinations, resulting in a false-positive “PASS”. While introducing manual human-written TBs could mitigate this, it re-introduces the very bottleneck automa- tion seeks to eliminate, as addressed by recent verification frameworks like ChatTest [18] and FIXME [19]. Furthermore, in early agile stages where specifications change frequently, manual TBs suffer from error propagation, where outdated verification logic fails to catch new design errors [20], [21]. Therefore, an automated mechanism to validate the validator itself is essential. Context Limitations: As design complexity grows, the extensive interaction logs required for iterative refinement often exceed the context window of LLMs [22]–[24]. This causes the model to suffer from Catastrophic Forgetting, losing track of initial specifications such as register maps or interface protocols during long interaction sessions. To overcome these challenges, we propose RefEvo, an agent-based framework designed for the agile generation of reliable hardware reference models. Unlike static genera- tion approaches, RefEvo treats generation as a dynamic, co- evolutionary process. Building on the collaborative paradigm of modern multi-agent frameworks [25]–[27]—where plan- ners, coders, and debuggers work in concert—RefEvo intro- duces domain-specific innovations to address the aforemen- tioned problems: • Dynamic Design Planner: To address workflow rigidity, we introduce a planner that acts as a “Brain”, analyzing semantic complexity to autonomously decompose speci- fications and construct bespoke execution workflows. • Co-Evolutionary Verification: To mitigate coupled val- idation failures, we propose a dialectical mechanism where a dedicated Arbiter Agent validates both the code and the TB against the specification oracle, significantly reducing false positives. • Spec Anchoring Context Management: To solve catas- trophic forgetting, we implement a strategy that anchors the immutable specification while compressing interac- tion history, ensuring 100% recall of critical constraints. The remainder of this paper is organized as follows: Sec- tion I reviews related work. Section I details the RefEvo methodology. Section IV presents the experimental results and analysis. Section V concludes the paper. I. RELATED WORK A. LLM-Based Hardware Code Generation The application of LLMs in hardware design has gained sig- nificant traction. Early benchmarking efforts [13] established evaluation frameworks demonstrating that LLMs could gener- ate syntactically correct Verilog code. Tools like RTLCoder [9] have demonstrated that fine-tuned LLMs can generate syntactically correct RTL code, while iDSE [28] also explored the integration of LLMs in high-level synthesis design space exploration. However, these works primarily focus on RTL generation. High-level modeling (SystemC/C++), which re- quires a higher level of abstraction and distinct simulation semantics, remains under-explored. RefEvo bridges this gap by targeting the specific challenges of reference model generation. A critical challenge in LLM-based code generation is the hallucination problem. Recent work on code hallucination de- tection has categorized errors into mapping, naming, resource, and logic errors. Our work addresses the more subtle “Coupled Validation Failure”, where both the model and its TB may be flawed. Unlike prior works that rely on fixed TBs, RefEvo introduces a co-evolutionary approach to dynamically refine the verification logic itself. B. Automated Debugging and Program Repair Automated program repair (APR) has emerged as a crit- ical research area [29]. Recent work has demonstrated the effectiveness of conversation-based APR [30], where iterative dialogue with LLMs can fix bugs at remarkably low cost. Practical APR approaches [31] have focused on reducing re- liance on extensive test suites. In the hardware domain, recent works have attempted to use LLMs to fix RTL bugs based on compiler feedback. However, most existing approaches assume a fixed, correct TB. RefEvo distinguishes itself by introducing a dialectical arbiter that validates the TB against the specification, ensuring that ”repairs” do not simply mask bugs. C. Dynamic Planning and Agent Reasoning The ability to dynamically decompose complex tasks is fundamental to effective agentic systems. TDAG [32] intro- duced a framework that dynamically decomposes tasks into subtasks. Recent advances [33] have integrated dynamic task decomposition with tool selection. RefEvo’s Dynamic Design Planner draws inspiration from these advances, employing semantic complexity analysis to construct tailored execution workflows. I. METHODOLOGY RefEvo is structured as a hierarchical multi-agent frame- work comprising three functional components: Dynamic Planning, the Symbiotic Verification Loop, and Spec- Anchored Context Management. The overall execution flow coordinates four specialized agents to transform ambiguous specifications into verified SystemC models. Fig. 2. The logical architecture of RefEvo. (A) The Dynamic Planning phase where Agent 1 analyzes complexity to construct an execution plan. (B) The Symbiotic Verification Loop where the Modeler (Agent 2) and Verifier (Agent 3) co-evolve under the supervision of the Dialectical Arbiter (Agent 4). A. Dynamic Task Planning Traditional LLM-based EDA flows often enforce a rigid, linear execution sequence, leading to token wastage for sim- ple logic and verification failures for complex systems. As illustrated in Fig. 2A, the Design Planner (Agent 1) serves as the methodological orchestrator of the system. Upon receiving the Design Specification and optional Legacy Assets, Agent 1 performs a dual-stage assessment: • Asset Evaluator: It examines existing codebases or Verification Intellectual Property to determine reusability, minimizing redundant generation. • Semantic Analyzer: It evaluates the design’s complexity across three dimensions: Interface Protocol (e.g., AXI vs. GPIO), State Space (e.g., complex FSMs), and Concur- rency (e.g., multi-clock domains). The output of this component is a structured Execution Plan (JSON), which defines the task decomposition and selects the appropriate routing strategy. B. Symbiotic Verification Loop Guided by the strategy defined in the Execution Plan, the framework enters the execution phase. The core execution engine, shown in Fig. 2B, employs a symbiotic relationship be- tween generation and verification. This component addresses the Coupled Validation Failure by decoupling the modeling and verification responsibilities. 1) Dual-Generator Setup: The framework dispatches two concurrent tasks: the Modeler Agent (Agent 2) generates the SystemC Reference Model, while the Verifier Agent (Agent 3) constructs the TB. These components are integrated into a Simulation Environment for compilation and execution. 2) The Dialectical Mechanism: The Dialectical Arbiter (Agent 4) acts as the central authority. By prompting the Arbiter to strictly verify the specific constraints anchored in the Spec against the simulation trace, it analyzes the Execution Logs against the Oracle Reference (the anchored specification) to resolve mismatches through four distinct routing paths: • Syntax Repair: For compilation errors, the Arbiter ex- tracts error signatures and triggers an implicit repair loop for Agent 2 or 3. • Design Refinement (Red Path): If a functional mismatch violates the specification, the Arbiter identifies the flaw in the DUT and directs Agent 2 to rectify the model logic. • TB Realignment (Blue Path): If the DUT aligns with the specification but the TB asserts a false failure, the Arbiter identifies the hallucination in the verification logic and directs Agent 3 to correct the TB. This path is critical for breaking the symmetry of shared hallucinations. • Success (Green Path): Once the Arbiter confirms func- tional equivalence, it outputs the Golden Model (verified SystemC and TB). C. Spec Anchoring Context Management To support the long-turn reasoning required in verification loop, we implement an Optimization component to prevent Catastrophic Forgetting. As illustrated in Fig. 4, we partition the LLM’s context window into three segments to ensure 100% recall of the specification. • The Anchor (Immutable): The initial Design Specifica- tion is pinned at the top of the context. It is never evicted during sliding window operations, serving as the constant Oracle Reference for Agent 4. • The Summary (Compressed): Historical interaction rounds are summarized into concise state representations, preserving the “reasoning chain” while saving token budget. Fig. 3. End-to-End Success Rate across different models and modes. RefEvo consistently outperforms baselines. Fig. 4. Comparison of context management strategies. Spec Anchoring pins the specification as an immutable anchor and compresses historical logs, ensuring the Dialectical Arbiter always has access to the ground-truth oracle. • The Workspace (Dynamic): The most recent error logs and code snippets are placed here for active processing. This partitioning allows the Dialectical Arbiter to maintain a consistent truth standard throughout the co-evolutionary process, even as the interaction history grows. IV. EXPERIMENTS AND RESULTS A. Experimental Setup We evaluated RefEvo on a benchmark of 20 hardware modules ranging from simple logic to complex protocols (e.g., AXI DMA, FFT, Keccak). The dataset was curated from open- source repositories including OpenCores [34], GenBen [35], and the XuanTie [36] RISC-V project. To ensure evaluation validity, all specifications were vetted by senior verification engineers. We tested five state-of-the-art LLMs, including Gemini- 2.5-Pro, GPT-5.1, GPT-4.1, Qwen3, and Claude-Opus-4.1. We compared four experimental modes to isolate the contributions of our framework: • Naive: One-shot generation without any verification loop. • Flow Only: Structured generation (Planning + Code Gen) without iterative refinement. • FixedTB: iterative refinement enabled, but TB modifica- tion is strictly forbidden. • RefEvo(Ours):ThefullframeworkwithCo- Evolutionary Verification enabled. For ground-truth validation, we employed a SystemVerilog DPI-based co-simulation framework. The generated SystemC models were compared against Golden RTL implementations under identical stimuli. B. Generation Capability Analysis Fig. 3 illustrates the overall success rates. The Naive approach fails almost completely (0-10%) due to pervasive syntax errors and incomplete code structures. Flow Only improves structural correctness, raising the pass rate to 15- 35%, yet functional bugs persist. RefEvo achieves superior performance, with Gemini-2.5 and GPT-5.1 reaching a 95% pass rate. Notably, for Claude-Opus-4.1, our mode outper- forms Flow Only by 70%. Complex modules like fpudiv and keccak consistently fail in baselines but are successfully resolved in the RefEvo mode. C. Ablation Study: Mechanism Effectiveness To validate our verification strategy, we analyzed the failure distribution and the impact of Co-Evolutionary Verification (Fig. 5). 1) Impact of iterative refinement: In Naive/Flow modes, the dominant failure mode is Compile Fail. The in- troduction of the verification loop in FixedTB mode effectively eliminates these syntax errors, shifting the failure distribution towards Func Fail. 2) Impact of Co-Evolution: The comparison between FixedTB and RefEvo modes highlights the ”Coupled Validation Failure” problem. In FixedTB mode, func- tional failures persist because the agent is forbidden from modifying the TB. When Co-Evolution is enabled, the Func Fail rate drops significantly. This confirms that many failures were due to incorrect verification logic rather than flawed models, and our dialectical mechanism successfully resolved them. D. Methodological Robustness To assess whether our framework’s improvements are model-agnostic, we analyzed the performance trend across Fig. 5. Failure distribution breakdown. The transition from Flow to FixedTB eliminates compilation errors, while the transition to RefEvo resolves functional mismatches via Co-Evolution. Fig. 6. Methodological Robustness Analysis. The consistent upward trend across all models confirms that RefEvo effectively enhances generation reliability independent of the underlying LLM’s capability. Fig. 7. Token consumption comparison across Simple, Medium, and Complex design scales. RefEvo achieves an average reduction of 71.04%, with absolute savings scaling significantly for complex designs. different LLMs. As shown in Fig. 6, despite the varying baseline capabilities of different models, the introduction of the RefEvo workflow consistently yields an upward trend in pass rates. This demonstrates that our method provides a robust enhancement component that effectively augments the capabilities of the underlying LLM. E. Efficiency Analysis: Context Compression To evaluate the scalability of our context management, we conducted controlled experiments across three design scales: Simple, Medium, and Complex. As shown in Fig. 7, our Spec Anchoring strategy achieves an average token reduction of 71.04% compared to the baseline. While the relative saving percentage peaks at 81.76% for medium-scale designs, it remains substantial (68.89%) for complex designs. The slight decrease in the savings ratio for the complex scenario is a deliberate architectural trade-off. To ensure 100% Specification Recall—defined as the ratio of critical design constraints correctly retained across interaction turns—RefEvo intentionally preserves the full-length initial specification as an immutable anchor. However, from the per- spective of absolute efficiency, the benefit scales dramatically with complexity. RefEvo saves over 73,900 tokens in the complex scenario—nearly 10× more than in the simple case. V. CONCLUSION This paper presented RefEvo, an agentic framework for agile reference model generation that bridges the gap between LLM capabilities and rigorous hardware verification standards. By integrating dynamic task planning with a co-evolutionary verification loop, RefEvo effectively addresses the challenges of semantic complexity and validation reliability. Our experi- ments demonstrate that the Dialectical Arbitration mechanism significantly mitigates “Coupled Validation Failure”, achieving a 95% success rate. Moreover, the Spec Anchoring strategy proves highly scalable, reducing token consumption by over 70%. RefEvo paves the way for fully automated, high-fidelity SoC verification, enabling a more efficient hardware-software co-design workflow. ACKNOWLEDGMENTS This work is supported by the National Natural Science Foundation of China under NSFC (Grant No. 92464301), the National Key Research and Development Program (Grant No. 2024YFB4405600), and the Key Research and Development Program of Jiangsu Province (Grant No. BG2024010). REFERENCES [1] A. Habibi and S. Tahar, “Design and verification of systemc transaction- level models,” IEEE Transactions on Very Large Scale Integration (VLSI) Systems, vol. 14, no. 1, p. 57–68, 2006. [2] M. Abdollahi, S. F. Yeganli, M. Baharloo, and A. Baniasadi, “Hardware design and verification with large language models: A scoping review, challenges, and open issues,” Electronics (2079-9292), vol. 14, no. 1, 2025. [3] J. Ye, T. Liu, Q. Tian, S. Su, Z. Jiang, and X. Wang, “Chatmodel: Automating reference model design and verification with llms,” 2025. [Online]. Available: https://arxiv.org/abs/2506.15066 [4] A. Moursi, R. Samhoud, Y. Kamal, M. Magdy, S. El-Ashry, and A. Shalaby, “Different reference models for uvm environment to speed up the verification time,” in 2018 19th International Workshop on Microprocessor and SOC Test and Verification (MTV), 2018, p. 67– 72. [5] H. D. Foster, “Trends in functional verification: A 2014 industry study,” IEEE, 2015. [6] P. Ghosh, S. Ghosh, P. Singh, and S. Mishra, “Case study: Re-visiting soc verification challenges and best practices,” IEEE, 2015. [7] M. Liu, T.-D. Ene, R. Kirby, C. Cheng, N. Pinckney, R. Liang, J. Alben, H. Anand, S. Banerjee, I. Bayraktaroglu et al., “Chipnemo: Domain- adapted llms for chip design,” arXiv preprint arXiv:2311.00176, 2023. [8] H. Liu, Y. Lu, M. Wang, X. Yao, and B. Yu, “LLM-assisted circuit verification: A comprehensive survey,” in Proceedings of the Asia and South Pacific Design Automation Conference (ASP-DAC), Hong Kong, 2026. [9] S. Liu, W. Xiao, Y. Li, D. Z. Pan, and Z. Hu, “Rtlcoder: Fully open- source and efficient llm-assisted rtl code generation technique,” IEEE Transactions on Computer-Aided Design of Integrated Circuits and Systems, 2024, arXiv:2312.08617. [10] T. Liu, Q. Tian, J. Ye, L. Fu, S. Su, J. Li, G.-W. Wan, L. Zhang, S.-Z. Wong, X. Wang, and J. Yang, “Chatchisel: Enabling agile hardware de- sign with large language models,” in 2024 2nd International Symposium of Electronics Design Automation (ISEDA), 2024, p. 710–716. [11] J. Niu, X. Liu, D. Niu, X. Wang, Z. Jiang, and N. Guan, “Rechisel: Effective automatic chisel code generation by llm with reflection,” in 2025 62nd ACM/IEEE Design Automation Conference (DAC).IEEE, 2025, p. 1–7. [12] X. Wang, G.-W. Wan, S.-Z. Wong, L. Zhang, T. Liu, Q. Tian, and J. Ye, “Chatcpu: An agile cpu design and verification platform with llm,” in Proceedings of the 61st ACM/IEEE Design Automation Conference, ser. DAC ’24. New York, NY, USA: Association for Computing Machinery, 2024. [Online]. Available: https://doi.org/10.1145/3649329.3658493 [13] S. Thakur, B. Ahmad, Z. Fan, H. Pearce, B. Tan, R. Karri, B. Dolan- Gavitt, and S. Garg, “Benchmarking large language models for auto- mated verilog rtl code generation,” arXiv preprint arXiv:2212.11140, 2022. [14] H. M. Le, V. Herdt, D. Große, and R. Drechsler, “Towards formal verification of real-world systemc tlm peripheral models - a case study,” IEEE, 2016. [15] J. Li, G. Li, C. Tao, J. Li, H. Zhang, F. Liu, and Z. Jin, “Large language model-aware in-context learning for code generation,” 2023. [16] S. Kim, S. Joo, D. Kim, J. Jang, S. Ye, J. Shin, and M. Seo, “The cot collection: Improving zero-shot and few-shot learning of language models via chain-of-thought fine-tuning,” Proceedings of the 2023 Conference on Empirical Methods in Natural Language Processing, 2023. [17] S. Qamar, W. H. Butt, M. W. Anwar, F. Azam, and M. Khan, “A comprehensive investigation of universal verification methodology (uvm) standard for design verification,” Proceedings of the 2020 9th International Conference on Software and Computer Applications, p. 339–343, 2020. [18] G.-W. Wan, S. Su, J. Zhang, S. Z. Wong, M. Xing, L. Ji, Z. Jiang, X. Wang, and J. Yang, “Chattest: Coverage-enhanced testbench gener- ation for agile hardware verification with llms,” in Proceedings of the IEEE/ACM Design, Automation and Test in Europe (DATE).Verona, Italy: IEEE/ACM, Apr. 2026, p. 1–7, hal-05482572. [19] G.-W. Wan, S. Su, R. Wang, Q. Chen, S.-Z. Wong, M. Xing, H. Feng, Y. Wang, Y. Zhu, J. Zhang, J. Ye, X. Wan, T. Ni, Q. Xu, N. Guan, Z. Jiang, X. Wang, and J. Yang, “Fixme: Towards end-to-end benchmarking of LLM-aided design verification,” in Proceedings of the Fourtieth AAAI Conference on Artificial Intelligence, ser. AAAI ’26, 2026, to appear. [Online]. Available: https://arxiv.org/abs/2507.04276 [20] Y. Hu, J. Ye, K. Xu, J. Sun, S. Zhang, X. Jiao, D. Pan, J. Zhou, N. Wang, and W. Shan, “Uvllm: An automated universal rtl verification framework using llms,” 2024. [21] N. Kabylkas, T. Thorn, S. Srinath, P. Xekalakis, and J. Renau, “Effec- tive processor verification with logic fuzzer enhanced co-simulation,” MICRO-54: 54th Annual IEEE/ACM International Symposium on Mi- croarchitecture, p. 667–678, 2021. [22] X. Jiang, Y. Dong, L. Wang, Z. Fang, Q. Shang, G. Li, Z. Jin, and W. Jiao, “Self-planning code generation with large language models,” 2023. [23] C. Xing, S. Wong, X. Wan, Y. Lu, M. Zhang, Z. Ma, L. Qi, Z. Li, N. Guan, Z. Jiang, X. Wang, and J. Yang, “ChipMind: Retrieval-Augmented Reasoning for Long-Context Circuit Design Specifications,” in Proceedings of the Fourtieth AAAI Conference on Artificial Intelligence, 2026, to appear. [Online]. Available: https://arxiv.org/abs/2512.05371 [24] L. T. Fu, J. Zhou, S. Ren, M. Zhang, J. Xiong, H. Jiang, N. Guan, X. Wang, and J. Yang, “Chatsva: Bridging sva generation for hardware verification via task-specific llms,” 2026. [Online]. Available: https://api.semanticscholar.org/CorpusID:287121296 [25] S. Khanzadeh, “Agentmesh: A cooperative multi-agent generative ai framework for software development automation,” 2025. [26] H. Wu, H. Zheng, Z. He, and B. Yu, “Divergent thoughts toward one goal: LLM-based multi-agent collaboration system for electronic design automation,” in Proceedings of the Annual Conference of the Nations of the Americas Chapter of the Association for Computational Linguistics (NAACL), Albuquerque, New Mexico, 2025. [27] A. Almorsi, M. Ahmed, and W. Gomaa, “Guided code generation with llms: A multi-agent framework for complex code tasks,” 2025. [28] R. Li, J. Xiong, and X. Wang, “idse: Navigating design space exploration in high-level synthesis using llms,” ArXiv, vol. abs/2505.22086, 2025. [Online]. Available: https://api.semanticscholar.org/CorpusID: 278959926 [29] A. Anand, A. Gupta, N. Yadav, and S. Bajaj, “A comprehensive survey of ai-driven advancements and techniques in automated program repair and code generation,” 2024. [30] C. S. Xia, Y. Wei, and L. Zhang, “Automated program repair via conversation: Fixing 162 out of 337 bugs for $0.42 each using ChatGPT,” in Proceedings of the 33rd ACM SIGSOFT International Symposium on Software Testing and Analysis (ISSTA), 2024. [Online]. Available: https://arxiv.org/abs/2304.00385 [31] Q. Xin, H. Wu, S. P. Reiss, and J. Xuan, “Towards practical and useful automated program repair for debugging,” 2024. [32] Y. Wang, Z. Wu, J. Yao, and J. Su, “Tdag: A multi-agent framework based on dynamic task decomposition and agent generation,” Neural Networks, vol. 185, no. 000, 2025. [33] A. G. Gabriel, A. A. Ahmad, and S. K. Jeyakumar, “Advancing agentic systems: Dynamic task decomposition, tool integration and evaluation using novel metrics and dataset,” 2024. [34] OpenCores Community, “OpenCores: Open source hardware IP core community,” 2025, accessed: 2025. [Online]. Available: https: //opencores.org/ [35] G.-W. Wan, Y. Wang, S. Wong, J. Zhang, M. Xing, Z. Jiang, N. Guan, Y. Wang, N. Xu, Q. Xu, and X. Wang, “Genben: A generative benchmark for LLM-aided design,” 2025. [Online]. Available: https://openreview.net/forum?id=gtVo4xcpFI [36] T-Head Semiconductor, “XuanTie open source RISC-V project,” 2025, accessed: 2025. [Online]. Available: https://github.com/T-Head-Semi