Skip to content

EvoDRC: A Self-Evolving Agentic Framework for Automated DRC Violation Repair

🕒 Published (v1): 2026-07-22 10:59 UTC · Source: Arxiv · link

Ask a follow-up

Open an assistant pre-loaded with this paper's context.

💬 Ask ChatGPT✦ Ask Claude

TL;DR

EvoDRC is a skill-evolution framework that deploys LLM repair agents on block-level chip layouts to automate post-route DRC violation repair. It transfers repair knowledge from a reference design, decomposes large layouts into bounded crops, and continuously evolves layer-specific skill files using a traceable knowledge database. On seven block-level designs from the DAC26-DRC-Benchmark, EvoDRC achieves a 73.5% reduction in design rule violations (DRVs).

Problem

Post-route DRC closure in advanced-node physical design requires manual engineering change order (ECO) iterations that can consume days to weeks of layout engineer effort. Existing agentic LLM approaches operate only at standard-cell scale and degrade severely on block-level layouts (up to 765 DRVs spanning 12 rule types); they also require hand-crafted, design-specific skill files that are unavailable for new target designs.

Method

EvoDRC proceeds in three iterative stages:

Stage 1 — Layout Decomposition. Given a GDSII and KLayout DRC report, EvoDRC classifies routing types, constructs first-order crops around DRV bounding boxes (bounded at \(k\,\mu\text{m} \times k\,\mu\text{m}\), set to \(2\,\mu\text{m} \times 2\,\mu\text{m}\) in experiments), merges overlapping crops into second-order crops, and unions row-aligned crops into final repair crops dispatched to agents in parallel.

Stage 2 — Agentic Repair. Each repair crop is assigned to one ReAct-paradigm LLM agent (Claude Sonnet 4.6, medium reasoning effort) that receives: (i) DRM images for visual rule context, (ii) the crop as a KLayout Python script with DRV annotations, and (iii) layer-wise skill files combining the KLayout DRC deck with distilled repair knowledge. Four internal roles—planner, adversarial plan reviewer, DRC engineer, patch reviewer—structure each agent's reasoning. Three sandboxed preview tools assist exploration: a local DRC analysis tool (reports target-DRV clearance and new DRVs), a connectivity check tool (DFS over merged metal-via stack to detect broken nets), and an impact preview tool (reports neighboring objects' layers and editability classes). Objects are classified into four editability classes (A: free via edits; B: free polygon edits; C: end-resize only for cropped stripes; D: frozen standard-cell internals).

Stage 3 — Assess, Record, and Evolve Skills. Agent outputs pass a full-design connectivity check before acceptance. Conflicting via edits between agents are resolved by testing each individually and selecting the one with greatest net DRV reduction. Accepted operation–DRV-change pairs are appended to the Knowledge DB, organized by metal layer and iteration. Two skill-evolution agents then run in parallel per layer: the Skill Refiner incrementally updates the existing skill file using the current iteration's records; the DB Summarizer reconstructs a skill file from the complete layer history. Both candidates undergo three script-based mechanical checks (source existence, claim citation, ambiguity filtering). A Skill Judge agent then scores surviving candidates on reference traceability, record coverage (recency-weighted), and writing quality, selecting the majority winner. The updated skill file seeds the next iteration.

Key Contributions

  • First agentic DRV repair framework targeting block-level post-route ECO at scale (up to 765 DRVs, 12 rule types).
  • Skill-evolution formulation: cross-design knowledge transfer from a reference layout (CLA) combined with test-time iterative skill refinement on the target design.
  • Layout decomposition mechanism enabling parallel agent dispatch with bounded crop sizes and explicit object editability classes.
  • Traceable Knowledge DB that stores only final operation–DRV pairs (not intermediate speculative edits), preventing noise accumulation.
  • 73.5% aggregate DRV reduction across seven block-level DAC26-DRC-Benchmark designs.

Results

  • Overall: 73.5% reduction in net DRV count across all seven block-level test cases (initial counts 68–765).
  • Benchmark: DAC26-DRC-Benchmark with ASAP7 PDK, KLayout 0.30.1; no prior automated ECO-style DRC repair baseline at this scale exists per the authors' knowledge.
  • Three ablations run to isolate individual mechanisms (initial CLA-derived skills, skill evolution, layout decomposition); per-block per-iteration breakdown in Table 5 (truncated in provided text).
  • Maximum five iterations allowed; early stopping at zero violations.

Limitations

  • Results limited to seven designs on a single PDK (ASAP7); generalization to commercial foundry rule decks undemonstrated.
  • Connectivity check is a simple DFS reachability test, not a full LVS run; logical equivalence is not verified.
  • Reference design (CLA) is substantially smaller (\(37\) initial DRVs, \(4.8\,\mu\text{m}^2\) die area) than the target blocks (\(68\)–\(765\) DRVs, up to \(57.9\,\mu\text{m}^2\)), creating a domain gap in initial skill transfer.
  • Crop size (\(2\,\mu\text{m} \times 2\,\mu\text{m}\)) is a fixed hyperparameter; its sensitivity is not analyzed.
  • Repairs are strictly local; ripple effects beyond the crop boundary are detected post-hoc but not preventively reasoned about.
  • Skill evolution is per-layer; cross-layer interaction rules are not explicitly captured in the skill files.

Relevance to Harnesses / Meta-Harnesses

EvoDRC is a domain-specific meta-harness: it orchestrates a fleet of ReAct agents, adjudicates conflicting agent outputs via a deterministic arbiter, and maintains a feedback loop (Knowledge DB → Skill Evolution → next iteration) that updates agent behavior between runs—exactly the structure of a self-improving agent harness. The Skill Refiner / DB Summarizer / Skill Judge pipeline is a three-stage quality gate embedded inside the harness itself, demonstrating how meta-harnesses can encode structured LLM-as-judge evaluation with mechanical pre-filters to enforce traceability. The distinction between storing only final agent verdicts (not intermediate trial states) to prevent knowledge-base corruption is a concrete lesson for harness designers managing persistent agent memory. The framework's design—parallel agent dispatch with sandboxed preview tools, conflict resolution logic, and iterative skill evolution—offers a reusable template for any domain where agents must repair structured artifacts under complex constraint sets.