🤖 AI

AgentDSE: Reasoning-Augmented Architectural Design Space Exploration

AgentDSE introduces a reasoning-augmented, simulator-in-the-loop methodology driven by a general-purpose LLM coding agent that significantly reduces the number of evaluations required for architectural design space exploration by emulating human-like reasoning to achieve competitive design quality while producing fully traceable search decisions.

Original authors: Chenyu Wang, Jiahe Caroline Shi, David Kong, Duane S. Boning, Zishen Wan, Yilun Du, Vijay Janapa Reddi

Published 2026-06-23

📖 4 min read☕ Coffee break read

CC BY 4.0

Original authors: Chenyu Wang, Jiahe Caroline Shi, David Kong, Duane S. Boning, Zishen Wan, Yilun Du, Vijay Janapa Reddi

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine you are trying to find the perfect recipe for a cake, but you have a very strict rule: you can only bake the cake 100 times. If you bake it 10,000 times, you run out of flour and money.

This is the problem computer engineers face when designing new computer chips. They have to test millions of different design combinations (like changing the size of the kitchen, the type of oven, or the mixing speed) to find the best one. Traditionally, they use "black box" methods: they just throw darts at a board, bake a cake, see if it's good, and try again. It's slow, wasteful, and nobody really knows why a specific recipe worked until they've baked it thousands of times.

AgentDSE is a new tool that changes the game. Instead of just throwing darts, it uses a smart, reasoning AI chef (a Large Language Model) to figure out the recipe before baking.

Here is how it works, using simple analogies:

1. The "Black Box" vs. The "Reasoning Chef"

The Old Way (Black Box): Imagine a chef who has no idea how cooking works. They just guess, "Maybe I should add more salt?" They bake the cake, taste it, and if it's salty, they try less salt next time. They don't understand why it failed; they just know the result. This takes thousands of tries.
The AgentDSE Way (Reasoning Chef): This AI chef actually reads the recipe book and understands physics. It says, "Wait, if I make the oven too small, the heat won't circulate, and the cake will burn. Let's try a bigger oven first." It uses logic and reasoning to eliminate bad ideas before it even turns on the oven.

2. The "Digital Lab Notebook"

The paper highlights a unique feature: Traceability.

In the old way, the computer optimizer keeps its "thoughts" hidden inside a black box. You get a result, but you don't know how it got there.
AgentDSE keeps a digital lab notebook (files like notes.md and history.jsonl). Every time the AI makes a guess, it writes down why it made that guess.
- Example: "I tried a small cache memory because I thought the data was small. The test showed it was too slow, so I realized the data was actually huge. Next time, I'll try a bigger cache."
- This makes the process inspectable. Humans can read the notebook to see the AI's logic, spot mistakes, or understand why a design failed.

3. The Results: Doing More with Less

The researchers tested this "Reasoning Chef" in three different "kitchens" (computer design problems):

DNN Accelerator Mapping: Designing chips for AI.
Hardware/Software Co-design: Designing chips and the software that runs on them together.
CPU Cache Optimization: Designing the memory storage inside a computer processor.

The findings were impressive:

Speed: AgentDSE found designs just as good (or better) than the old methods, but it used 10 to 100 times fewer tests.
The "Anonymization" Test: To prove the AI was actually thinking and not just guessing numbers, the researchers hid the names of the parts (like calling a "cache" just "Item A"). Even without names, the AI was still very good at guessing. But when they gave it the real names and context, it became 2.4 times faster. This proves that understanding the meaning of the parts helps the AI reason better.

4. Why This Matters

The paper claims that AgentDSE bridges the gap between human intuition and computer speed.

Humans are good at reasoning: "If I do X, then Y will happen because of physics."
Computers are good at testing: "Let's try 1,000 variations."
AgentDSE combines them: It uses an AI to reason like a human expert, which means it doesn't need to test 10,000 variations. It tests 100, learns from the results, and writes down its reasoning for the next step.

Summary

Think of AgentDSE as a smart apprentice who doesn't just blindly follow orders. It looks at the blueprint, thinks about the physics, makes a hypothesis ("I bet this will work"), tests it, writes down what happened, and uses that lesson to make the next guess.

The result? It finds the best computer chip designs using a tiny fraction of the time and energy required by traditional methods, and it leaves a clear paper trail so humans can understand exactly how it got there.

Technical Summary: AgentDSE

Problem Statement

Traditional Architectural Design Space Exploration (DSE) is characterized by extreme inefficiency, often requiring tens of thousands of simulator evaluations to navigate vast, discrete, and highly discontinuous design spaces (e.g., exceeding $10^{20}$ configurations for DNN accelerator mapping). Current methods—including Random Search (RS), Genetic Algorithms (GA), Bayesian Optimization (BO), Reinforcement Learning (RL), and differentiable DSE—treat the simulator as a "black-box oracle." They query the simulator for scalar feedback (e.g., Energy-Delay Product or Instructions Per Cycle) without leveraging semantic information regarding bottlenecks, data reuse, hierarchy, or workload structure. Furthermore, these black-box approaches offer no insight into why a configuration was selected, making it difficult to debug simulator artifacts or validate search decisions. While recent work has explored Large Language Models (LLMs) for hardware design, many existing approaches remain tied to target-specific workflows, precomputed databases, or custom multi-agent systems, lacking a reusable mechanism to translate LLM reasoning into simulator-call selection.

Methodology: AgentDSE

The authors propose AgentDSE, a simulator-in-the-loop methodology driven by a general-purpose Large Language Model (LLM) coding agent. Rather than treating DSE as purely numerical sampling, AgentDSE frames it as an iterative, history-aware reasoning process.

Core Workflow

Workspace Abstraction: The DSE problem is encapsulated in a structured, editable workspace containing:
- Task Brief (README.md): Objective, domain context, and budget.
- Action Space (action_space.md): Candidate fields, valid ranges, and constraints.
- Workload/Hardware Files: Target specifications.
- Candidate File (candidate.yaml): The design to be evaluated.
- Evaluation Harness: Scripts to validate candidates, invoke the simulator, and return metrics.
- Search State: Persistent logs (notes.md, history.jsonl, best.json) recording observations and the best design found.
The Optimization Loop: The agent operates through a "hypothesis-test-refine" loop:
- Reasoning: The agent reads the workspace, forms hypotheses about which design dimensions to explore, and filters candidates against constraints.
- Action: It writes a candidate to candidate.yaml and executes the evaluation harness.
- Observation: It receives measured metrics, updates the search state, and records observations and rationale in notes.md.
- Refinement: Based on the feedback, the agent refines its hypotheses for the next iteration.
Domain Agnosticism: The framework requires no model fine-tuning, no precomputed design databases, and no domain-specific optimizer code. It relies solely on the agent's native coding loop (read, edit, execute) applied to the simulator interface.

Key Contributions

An Agentic DSE Paradigm: Formalizes DSE as a domain-agnostic agent-simulator workflow where architectural reasoning is an iterative loop driven by simulator feedback. The same workspace abstraction is successfully reused across three distinct simulators (MAESTRO, Timeloop/Accelergy, and ChampSim) without fine-tuning.
Cross-Domain Sample Efficiency: Demonstrates that AgentDSE achieves competitive or superior design quality with up to two orders of magnitude fewer simulator evaluations compared to traditional baselines (RS, GA, PPO) and differentiable methods (DOSA).
Auditable Optimization Traces: Unlike black-box optimizers, AgentDSE produces inspectable traces (notes.md, history.jsonl) that surface architectural hypotheses, performance cliffs, implicit priors, and simulator artifacts, making every search decision traceable.

Experimental Results

The authors evaluated AgentDSE across three domains:

1. Hardware/Software Co-Design (Timeloop/Accelergy)

Comparison: Head-to-head against DOSA, a representative differentiable DSE engine.
Setup: AgentDSE started from a "cold start" (no precomputed dataset) with a strict budget of 80 ground-truth Timeloop calls per layer. DOSA utilized a precomputed dataset of 72,701 samples and performed gradient descent on an analytical predictor.
Per-Layer: AgentDSE matched DOSA's Energy-Delay Product (EDP) with a geometric-mean ratio of 0.99× (9 wins, 13 ties, 2 losses) using ~37× fewer real simulator calls.
Network-Level: AgentDSE achieved a 1.15× improvement in network EDP over DOSA's reproduced best, using ~165× fewer real Timeloop calls.
Ablation: An "Anonymized Agent" (stripped of physical semantics) still outperformed DOSA in sample efficiency (71 calls vs. ~1,125), but the "Full-Context Agent" (with physical reasoning) further reduced calls to 29, demonstrating that architectural reasoning provides a multiplicative speedup over the LLM's inherent combinatorial optimization capability.

2. DNN Accelerator Mapping (MAESTRO)

Comparison: Against RS, GA, and PPO.
Results: AgentDSE achieved the best model-level EDP for LLaMA-3.1-8B and OpenVLA workloads using only 100 simulator calls per shape. This represents a 200–500× reduction in simulator budget compared to baselines (20,000–50,000 calls).

3. CPU Cache-Hierarchy Optimization (ChampSim)

Comparison: Against RS, GA, and BO.
Results: AgentDSE matched the final IPC of baselines (which used 1,000 evaluations) while self-terminating after ~50 calls.
Efficiency: AgentDSE reached the quality of 1,000-call baselines in 20–50 calls (20–50× speedup) and showed a 7–15× sample efficiency advantage in convergence-matched comparisons.

Significance and Claims

The paper claims that AgentDSE bridges the gap between human architectural intuition and automated search by embedding reasoning directly into the optimization loop. Its primary significance lies in:

Replacing Black-Box Sampling: It shifts the paradigm from treating simulators as opaque oracles to using them as grounded feedback mechanisms for an agent that reasons about constraints, bottlenecks, and workload structures.
Traceability: It transforms DSE from a "black box" into a transparent process where search decisions, hypotheses, and failures are explicitly recorded and inspectable.
Generalizability: It demonstrates that a single, unmodified coding agent workflow can effectively solve diverse architectural problems (DNN mapping, co-design, CPU hierarchy) without the need for domain-specific training or precomputed datasets.

The authors note that while the approach relies on high-capacity LLMs (introducing API costs), the reduction in simulator evaluations (which are often computationally expensive) offsets this. They position this as an early empirical case for general-purpose coding agents as practical DSE engines, with future work aimed at exploring "zero-shot" discovery in non-intuitive design spaces.