DS2SC-Agent: A Multi-Agent Automated Pipeline for Rapid Chiplet Model Generation

Yiwei Wu, Yifan Wu, Yunhao Xiong, Dengwei Zhao, Jiaxuan Shen, Jianfei Jiang, Guanghui He, Shikui Tu, Yanan SunarXiv 2026 · arXiv

TL;DR

DS2SC-Agent is the first end-to-end, fully automated pipeline that translates raw, unstructured industrial datasheets directly into executable SystemC chiplet models. By leveraging a collaborative four-agent framework with closed-loop debugging, the system overcomes traditional LLM bottlenecks like context vanishing and logical hallucinations, drastically accelerating early-stage hardware architecture exploration.

What Problem Does This Paper Address?

In the post-Moore era, chiplet technology—where modular chips are integrated into a single package—has become essential for designing advanced semiconductors. To test how these complex systems behave before manufacturing them, engineers rely on behavioral reference models written in languages like SystemC.

However, building these models is a massive bottleneck. Domain experts must manually sift through industrial datasheets that span dozens of pages, extracting pin configurations, timing constraints, and complex internal logic to write the code. While Large Language Models (LLMs) have shown promise in generating hardware code (like Verilog), they fail catastrophically when fed raw, multimodal industrial datasheets. These documents contain a messy mix of natural language, dense parameter tables, and curve graphs, causing standard LLMs to suffer from "context vanishing" (forgetting initial constraints) and "logical hallucinations."

Methods

To bridge the gap between messy PDFs and clean, executable code, the authors developed DS2SC-Agent, a multi-agent framework that decouples the modeling process into four specialized stages:

Overview of the DS2SC-Agent system
  1. Specification Parsing Agent: Instead of writing code immediately, this agent standardizes the raw PDF datasheet into a machine-readable JSON format called the Spec IR (Specification Intermediate Representation). It uses a "mixed-fill" strategy, where system-level constraints are pre-filled to prune the design space, and the LLM only extracts specific features into designated anchors.
  2. Code Generation Agent: Guided by the Spec IR, this agent constructs the core SystemC hardware model. It adheres to a header-only paradigm (.h), bundling all module declarations and behavioral logic into a single file to simplify downstream compilation.
  3. Testbench Generation Agent: Acting as an independent verification engineer, this agent generates a black-box testbench (main.cpp) based on the simulation test cases defined in the Spec IR.
  4. Automated Debugging Agent: To ensure the code actually works, this agent acts as a closed-loop optimizer. If compilation fails, it analyzes the compiler's stderr logs to fix syntax errors. If the simulation runs but yields incorrect results, it cross-references runtime data (.csv logs) with the Spec IR to fix deep logical flaws using Chain-of-Thought (CoT) reasoning.

Datasets

Because automated SystemC generation from raw datasheets is a brand-new task, no standard benchmarks existed. The authors curated a diverse benchmark suite featuring three real-world, single-function industrial chiplets representing different physical domains:

  • Digital Domain: A Fast Fourier Transform (FFT) module, evaluated using a massive 96-page Xilinx product guide filled with dense text and register maps.
  • Analog Domain: A Limiting Amplifier (LA), evaluated using a concise 6-page datasheet where critical parameters were buried in dense electrical characteristic tables.
  • RF Domain: A Power Amplifier (PA), evaluated using an 18-page datasheet featuring complex non-linear performance curve graphs.

Key Insights and Ideas

  • Decoupling Overcomes Context Limits: Trying to generate a hardware model in a single pass forces the LLM to handle parsing, coding, and testing simultaneously, leading to failure. Separating these tasks across specialized agents keeps the LLM focused and accurate.
  • The "Mixed-Fill" Anchor: Pre-populating deterministic system parameters in the Spec IR acts as an anchor, preventing the LLM from hallucinating basic architectural facts while it extracts complex behavioral logic.
  • Dual-Loop Self-Repair: Mimicking human engineering workflows by separating syntax debugging (compilation phase) from functional debugging (runtime phase) proved vital for achieving 100% compilable and correct code.

Key Results

The framework was evaluated using Gemini 3 Flash as the underlying LLM engine, yielding highly accurate models across all three domains:

  • FFT (Digital): The generated model successfully executed a closed-loop time-to-frequency-to-time domain test. The computational error between the initial input and the reconstructed output was bounded within $10^{-16}$, matching the machine epsilon limit for double-precision floating-point math.
  • Limiting Amplifier (Analog): The system accurately captured three distinct operational phases: linear amplification, non-linear clamping (clamping the waveform to maximum voltage limits), and digital enable/disable logic.
  • Power Amplifier (RF): By utilizing numerical parameter estimation based on sparse data points, the framework successfully fitted the non-linear Rapp model to the PA's physical characteristics, keeping the absolute fitting error strictly under 1dB across the entire dynamic range.

Limitations and Future Work

While highly effective, DS2SC-Agent is currently limited to generating single-function chiplet models. Real-world systems often involve multi-chiplet heterogeneous architectures with intricate inter-chip communication. The authors plan to extend the framework to handle system-level verification for these multi-chiplet systems. Additionally, they aim to explore the use of smaller, domain-specific local LLMs to reduce API latency and protect data privacy in proprietary industrial settings.

Summary updated

Abstract

Constructing behavioral-level chiplet models (e.g., SystemC) is crucial for early-stage heterogeneous architecture exploration. Traditional manual modeling is notoriously time-consuming and error-prone. Recently, Large Language Models (LLMs) have demonstrated immense potential in automating hardware code generation. However, existing LLM-assisted design frameworks predominantly target highly structured or well-defined design specifications. In practical engineering scenarios, raw datasheets typically encompass lengthy, complex, and highly unstructured information. Consequently, reliable code generation directly from these raw datasheets suffers from severe challenges, including context vanishing and logical hallucinations.To overcome this critical bottleneck, this paper proposes DS2SC-Agent(Datasheet-to-SystemC-Agent): the first end-to-end, fully automated generation pipeline that translates raw datasheets directly into SystemC chiplet models. This system establishes a highly efficient multi-agent collaborative framework. By decoupling the intricate modeling tasks, the proposed pipeline orchestrates a fully automated workflow encompassing unstructured long-document parsing, SystemC core code construction, testbench stimulus generation, and adaptive closed-loop debugging. We comprehensively evaluate the proposed framework on representative single-function chiplets across the analog, digital, and radio frequency (RF) domains--specifically, a Limiting Amplifier (LA), a Fast Fourier Transform (FFT) module, and a Power Amplifier (PA). The evaluation demonstrates that our pipeline seamlessly processes complex real-world datasheets to consistently generate functionally correct SystemC models. This provides a highly efficient and reliable paradigm for agile model library construction while drastically minimizing manual intervention.
BibTeX
@misc{wu2026ds,
  author = {Yiwei Wu and Yifan Wu and Yunhao Xiong and Dengwei Zhao and Jiaxuan Shen and Jianfei Jiang and Guanghui He and Shikui Tu and Yanan Sun},
  title = {{DS2SC-Agent: A Multi-Agent Automated Pipeline for Rapid Chiplet Model Generation}},
  year = {2026},
  eprint = {2603.21190},
  archivePrefix = {arXiv},
  url = {https://arxiv.org/abs/2603.21190},
}
Figure