Andrii Bidochko

• Updated: July 10, 2026
• 6 min read

AgenticPD: A Stage-Aware Agentic Framework for Physical Design QoR Optimization

Direct Answer

AgenticPD introduces a stage‑aware, agent‑centric framework that orchestrates specialized AI agents around the boundaries of the semiconductor physical design flow to optimize quality‑of‑results (QoR) more efficiently. By reusing intermediate checkpoints and evaluating candidates only at post‑route sign‑off, the system delivers stronger timing performance while staying competitive on power and area.

Background: Why This Problem Is Hard

Physical design in electronic design automation (EDA) translates a logical netlist into a silicon layout that meets stringent timing, power, and area constraints. Each stage—floorplanning, placement, clock‑tree synthesis, routing, and sign‑off—introduces decisions that ripple through later stages. A sub‑optimal choice early on can force costly re‑iterations later, inflating both compute time and engineering effort.

Traditional optimization approaches treat the entire flow as a flat parameter‑tuning problem or rely on large language models (LLMs) to generate scripts that run the full EDA flow for every trial. This brute‑force strategy suffers from two critical limitations:

• Expensive evaluations: Running a full flow from RTL to sign‑off can take hours on high‑performance clusters, making exhaustive search infeasible.
• Lack of stage awareness: Flat tuning ignores the distinct objectives and toolsets of each stage, leading to sub‑optimal trade‑offs and missed optimization opportunities.

Consequently, chip designers face a bottleneck where improving one QoR metric often degrades another, and the cost of exploring the design space grows exponentially.

What the Researchers Propose

AgenticPD reframes physical design QoR optimization as a multi‑agent collaboration problem. The framework introduces three core concepts:

1. Stage‑aware agents: Dedicated AI agents operate within the confines of a single design stage (e.g., placement, routing) and leverage stage‑specific tools and metrics.
2. Judge Agent: A higher‑level orchestrator that navigates the overall search, decides when to switch stages, and selects promising intermediate states for further exploration.
3. Agent harness: A shared infrastructure that records structured observations, execution histories, and context, enabling agents to branch from prior checkpoints rather than restarting from scratch.

By aligning each agent’s expertise with its stage’s objectives, the system reduces unnecessary full‑flow reruns and focuses computational effort where it matters most.

How It Works in Practice

Conceptual Workflow

The AgenticPD workflow proceeds as follows:

1. Initialization: The physical design flow starts from a baseline checkpoint (e.g., after floorplanning).
2. Stage‑specific decision: The active stage‑aware agent proposes a set of local modifications (e.g., adjusting placement density) and runs the stage‑local toolchain to evaluate immediate impact.
3. Observation capture: Results, along with tool logs and metric deltas, are stored in the agent harness.
4. Judge evaluation: The Judge Agent reviews the observations, compares them against a multi‑objective reward function (timing, power, area), and decides whether to:
   • Continue iterating within the same stage, or
   • Advance to the next stage using the current checkpoint as a new starting point.
5. Branching & checkpoint reuse: If a promising intermediate state is identified, the system forks a new optimization branch, preserving the checkpoint to avoid re‑running earlier stages.
6. Final evaluation: All candidate designs are ultimately assessed at the post‑route sign‑off stage, ensuring a fair comparison of end‑to‑end QoR.

Component Interactions

Each component communicates through a lightweight API:

• Stage‑aware agents: Issue tool commands, retrieve metrics, and push observations to the harness.
• Judge Agent: Pulls observations, runs a policy (often a reinforcement‑learning or heuristic‑based model), and issues control signals (continue, switch, branch).
• Agent harness: Maintains a versioned database of design states, enabling rapid rollback and parallel exploration.

This separation of concerns makes the system modular; new agents can be added for emerging stages (e.g., advanced packaging) without redesigning the entire framework.

Evaluation & Results

The authors benchmarked AgenticPD against two baselines:

• A flat‑parameter tuning approach that runs the full flow for each configuration.
• An LLM‑generated script pipeline that also executes the complete flow per trial.

Key evaluation scenarios included:

1. Standard ASIC design blocks with varying complexity.
2. Real‑world industrial benchmarks where timing closure is the primary driver.

Findings highlighted that AgenticPD consistently achieved:

• Stronger post‑route timing: Up to 12% improvement in worst‑case slack compared to baselines.
• Competitive power and area: Within 2–3% of the best‑performing baseline, demonstrating that timing gains did not come at the expense of other QoR metrics.
• Reduced compute cost: By reusing checkpoints and limiting full‑flow evaluations, total runtime dropped by roughly 40%.

These results validate the hypothesis that stage‑aware agent collaboration can navigate the design space more intelligently than monolithic optimization loops.

Why This Matters for AI Systems and Agents

AgenticPD showcases a practical blueprint for building AI‑driven orchestration layers in complex engineering pipelines. Its implications extend beyond EDA:

• Modular agent design: Demonstrates how specialized agents can be coupled with a central judge to balance local expertise and global objectives.
• Checkpoint‑based branching: Offers a reusable pattern for any workflow where intermediate states are expensive to recompute (e.g., large‑scale simulations, data‑centric ML pipelines).
• Multi‑objective reward shaping: Provides a template for integrating timing, power, and area—analogous to latency, cost, and accuracy in other domains.

For organizations building AI agents, the framework suggests a path toward UBOS platform overview that can host stage‑aware agents, manage state versioning, and expose a unified API for orchestration. Leveraging such infrastructure can accelerate the development of domain‑specific agents without reinventing the underlying execution engine.

What Comes Next

While AgenticPD marks a significant step forward, several open challenges remain:

• Scalability to advanced nodes: As process technologies shrink, the number of design constraints explodes, demanding more sophisticated reward functions.
• Learning robust policies: Current implementations rely on heuristic judges; integrating deep reinforcement learning could further improve decision quality.
• Cross‑tool compatibility: Extending the framework to support multiple EDA vendor toolchains would broaden adoption.

Future research may explore hybrid agents that combine symbolic reasoning with neural models, or integrate real‑time feedback from silicon prototypes. Companies interested in pioneering such capabilities can explore the Workflow automation studio to prototype custom agent pipelines, or join the UBOS partner program for collaborative development.

References

AgenticPD paper on arXiv

Andrii Bidochko

CTO UBOS

Andrii Bidochko is an AI entrepreneur and researcher focused on AI agents, reinforcement learning, and autonomous systems. He writes about the technologies shaping the future of machine intelligence, from frontier models and agent architectures to real-world AI applications.