🤖 AI

Automated QoR improvement in OpenROAD with coding agents

The paper introduces AuDoPEDA, an autonomous coding agent framework that leverages LLMs to independently propose and implement code improvements in the OpenROAD EDA tool, achieving significant reductions in wirelength, clock period, and power consumption.

Original authors: Amur Ghose, Junyeong Jang, Andrew B. Kahng, Jakang Lee

Published 2026-02-11

📖 4 min read☕ Coffee break read

CC BY 4.0

Original authors: Amur Ghose, Junyeong Jang, Andrew B. Kahng, Jakang Lee

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 teach a high-school student to become a master chef in a world-class, Michelin-star kitchen.

The kitchen is massive, the recipes are written in complex code, the tools are highly specialized, and if the student makes one tiny mistake—like adding too much salt or turning the heat too high—the entire five-course meal is ruined. Usually, you’d need a master chef (a senior engineer) to stand over their shoulder for years to teach them.

This paper, AuDoPEDA, describes a way to build an "AI Sous-Chef" that can teach itself how to run that kitchen and, more importantly, how to actually improve the recipes to make the food taste better.

Here is how they did it, broken down into four simple steps:

1. The "Library & Map" Phase (The Onboarding)

Most AI models are like students who have read a lot of Wikipedia but have never stepped into a real kitchen. They know what "salt" is, but they don't know where the salt is kept in this specific kitchen or how this specific stove works.

The researchers first gave the AI a "map" of the entire kitchen (the OpenROAD software). They used a tool to scan millions of lines of code and turned it into a structured guidebook. Instead of just reading raw text, the AI now understands: "If I turn this knob (a piece of code), it affects this burner (a specific function), which eventually changes the temperature of the soup (the final chip design)."

2. The "Recipe Research" Phase (The Planning)

Once the AI knows where everything is, it doesn't just start cooking randomly. It goes to the "library" to read professional culinary textbooks (scientific research papers).

It combines what it learned about the kitchen with what it learned from the textbooks to come up with a plan. It doesn't just say, "I'll make the soup better." It says, "Based on this textbook, if I slightly increase the simmering time and reduce the liquid, the flavor will be more concentrated. I will test this by changing exactly these three ingredients."

3. The "Precision Prep" Phase (The Localization)

Before the AI touches a single ingredient, it creates a very detailed "prep list." It identifies exactly which knife to use, which pan to grab, and—most importantly—it sets safety rules. It decides: "If the soup gets too salty, I will immediately pour in more broth to fix it," or "If the stove catches fire, I will stop everything and revert to the original recipe."

4. The "Taste Test" Phase (The Execution & Feedback)

This is where the magic happens. The AI actually "cooks" (writes and runs the code). But it doesn't just finish and walk away. It performs a rigorous "Taste Test" (called QoR or Quality of Results).

It measures the "flavor" using three main metrics:

Wirelength (The Ingredients): Is the layout efficient, or is it a messy pile of spaghetti?
Clock Period (The Timing): Is the food being served at the right speed, or is it too slow?
Power (The Energy): Is the kitchen using too much gas to cook this meal?

If the "taste" is better, the AI keeps the change. If the "taste" is worse, the AI realizes its mistake, looks at the "burnt" dish, learns why it happened, and tries a different recipe.

The Result: A Self-Improving Kitchen

The researchers found that the AI didn't just make small tweaks; it actually discovered better ways to "cook" computer chips. It managed to:

Reduce "spaghetti" wiring by up to 5.9%.
Speed up the "service" (timing) by up to 10%.
Lower the "gas bill" (power consumption) by up to 19.4%.

The Big Picture: Instead of humans spending years manually tweaking complex software to make chips faster and more efficient, we are building AI "engineers" that can read the manuals, study the science, and teach themselves how to build better technology.

Technical Summary: AuDoPEDA – Automated QoR Improvement in OpenROAD with Coding Agents

1. Problem Statement

The development of Electronic Design Automation (EDA) tools is severely bottlenecked by the scarcity of expert engineers capable of navigating massive, multi-language (C++, Tcl, Python, Verilog) codebases. While Large Language Models (LLMs) excel at local coding tasks, they struggle with repository-scale engineering due to:

Context Dilution: Difficulty reasoning across millions of lines of code and undocumented invariants.
Domain Complexity: The need to bridge high-level scientific literature (e.g., placement/routing algorithms) with low-level implementation.
Closed-Loop Validation: The requirement to not just write code, but to ensure that changes improve physical design metrics like Power, Performance, and Area (PPA).

2. Methodology (The AuDoPEDA Pipeline)

The authors propose AuDoPEDA, an autonomous, repository-grounded system that treats EDA development as a structured, four-stage programmatic pipeline:

Stage 0: Documentation Bootstrap & Code Graphing:
The system uses tree-sitter to parse the OpenROAD repository into a language-agnostic property graph ( $G$ ). It builds a "Docmaker" pipeline that traverses this graph bottom-up to create "documentation cards." These cards summarize APIs, invariants, and configuration knobs, creating a hierarchical knowledge base that mitigates context loss.
Stage 1: Literature-Grounded Planning (via DSPy):
Instead of simple prompting, the system uses DSPy to compile a declarative LLM program. The planner retrieves information from two corpora: the generated code documentation ( $C_{repo}$ ) and a domain-specific literature corpus ( $C_{lit}$ , e.g., DAC/ICCAD papers). It synthesizes high-level research directions (e.g., "adjusting legalization cost to reduce congestion").
Stage 2: Plan Localization:
The high-level plan is projected onto the code graph to identify specific "edit surfaces" (files/functions). It generates a granular plan consisting of an ordered set of diffs ( $\Delta_i$ ), pre-flight checks, runtime probes (telemetry), and post-condition acceptance criteria.
Stage 3: Autonomous Execution & QoR Feedback:
A Codex-class agent acts as an executor. It applies diffs, compiles the code, and runs full OpenROAD design flows. It uses a hill-climbing strategy, iterating on changes based on self-measured signals (wirelength, timing slack, power). It includes safety guardrails like "revert-on-regression" to ensure no change introduces Design Rule Check (DRC) violations or timing failures.

3. Key Contributions

A Graph-Structured Documentation Framework: A generalizable method to transform raw EDA codebases into machine-understandable, hierarchical knowledge.
DSPy-Integrated Planning: A method to bridge the gap between academic EDA research (literature) and practical implementation (code).
Autonomous EDA Agent: An end-to-end system that moves beyond "scripting assistance" to "algorithmic contribution," capable of proposing and verifying structural code changes.
Task Suite & Evaluation Protocol: A standardized way to evaluate LLM agents on PPA-oriented improvements within the OpenROAD ecosystem.

4. Experimental Results

The system was tested on the OpenROAD stack across various Process Design Kits (PDKs) like ASAP7, SKY130HD, and Nangate45. The agent produced single, repository-level code modifications (rather than per-design parameter tuning) that yielded:

Routed Wirelength (rWL) Reduction: Up to 5.9% reduction. The agent restructured the detailed placement swapper to be routability-driven, balancing wirelength against congestion.
Effective Clock Period (ECP) Improvement: Up to 10.0% reduction. The agent developed a sophisticated timing-driven placement and resizer framework using nonlinear weight-curve shaping and length-based adjustments.
Power Reduction: Up to 19.4% reduction. The agent moved from a path-based sizing approach to an instance-based ranking approach, combining cell downsizing with buffer removal and VT swapping.

5. Significance

AuDoPEDA represents a paradigm shift in EDA R&D. It demonstrates that LLM agents can function as autonomous researchers rather than mere coding assistants. By coupling structured code representation with scientific literature and a closed-loop physical design verification flow, the system can discover and implement complex algorithmic improvements. This paves the way for "self-improving" EDA toolchains that can continuously optimize themselves as new research emerges.