🤖 AI

SKILL: Self-correcting Knowledge-guided Iterative Large Language Model Agent for Logic Optimization

The paper introduces SKILL, a self-correcting, knowledge-guided iterative multi-agent system that combines specialized Large Language Models with Proximal Policy Optimization to significantly outperform traditional expert flows in logic synthesis optimization by achieving a 12.4% improvement in PDA metrics and an 86.3% success rate on large-scale benchmarks.

Original authors: Rui Yang

Published 2026-08-18

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Rui Yang

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

The digital world runs on logic, the invisible architecture of decisions that powers everything from smartphones to satellites. At the heart of this architecture lies a critical step called logic synthesis, where engineers translate high-level design ideas into the actual physical arrangement of billions of tiny switches on a computer chip. For decades, this process has relied on rigid, expert-written instructions that tell the computer how to rearrange these switches to make them faster, smaller, and more energy-efficient. However, as chips grow more complex, these fixed instructions struggle to keep up, often missing better solutions hidden within the vast, chaotic possibilities of how a chip could be built. The search for the perfect arrangement is like trying to find a single specific grain of sand on a beach that changes shape every time you look at it, making it nearly impossible for traditional methods to navigate efficiently.

To solve this, researchers at the University of California, Riverside, have developed a new system called SKILL, which acts as a smart, self-correcting guide for chip design. Instead of following a static script, SKILL uses a team of advanced artificial intelligence models that work together to explore the design space, much like a group of specialists collaborating on a difficult puzzle. One model acts as a strategic planner, mapping out the long-term goals for the chip's performance. A second model dives deep into the details, spotting specific bottlenecks and structural weaknesses in the design. A third model handles rapid analysis, checking thousands of possibilities in real-time to keep the process moving. These three digital minds do not work in isolation; they are paired with a learning agent that interacts directly with the industrial software tools used to build chips. This agent tries out different changes, observes the results, and learns from the feedback, creating a continuous loop of trial, error, and improvement.

What sets this system apart is its ability to recognize when it is making a mistake and fix itself without human help. In the past, if an automated system made a poor choice that made a chip slower or larger, it might continue down that wrong path until the entire process failed. SKILL, however, constantly monitors the health of the design. If it detects that a change has made the chip worse, it immediately stops, analyzes why the decision failed, and asks its team of AI models to devise a new strategy to recover. This self-correcting mechanism allows the system to navigate the complex landscape of chip design with a resilience that previous methods lacked, turning dead ends into new opportunities for optimization.

The researchers tested SKILL on a wide variety of real-world chip designs, ranging from small academic projects to massive industrial systems containing up to 500,000 logic gates. They compared the system's performance against the best existing methods, including those run by human experts and other automated learning systems. The results showed that SKILL consistently produced better outcomes, improving the balance of power, speed, and physical size by an average of 12.4 percent compared to the expert-designed flows. This improvement is significant in the world of chip design, where even a single percentage point can mean the difference between a device that fits in a pocket and one that requires a cooling system. Furthermore, the system succeeded in optimizing 86.3 percent of the designs it attempted, demonstrating a high level of reliability even when dealing with the most complex circuits.

The success of SKILL comes from how it bridges the gap between high-level reasoning and low-level execution. While traditional artificial intelligence often struggles to understand the specific rules of chip design, SKILL's team of models can interpret the abstract goals of a design and translate them into concrete actions that the synthesis tools can perform. This collaboration allows the system to learn from the actual behavior of the design software, rather than just guessing based on patterns. The researchers found that removing any one of the three AI models or disabling the self-correction feature led to a noticeable drop in performance, proving that the combination of strategic planning, detailed analysis, and rapid feedback is essential for the system to work.

This approach marks a shift in how automated design tools are built. Rather than relying solely on mathematical algorithms to search for solutions, SKILL integrates the reasoning capabilities of large language models with the precision of industrial engineering tools. The system does not just find a solution; it understands why a solution works and how to recover when it does not. By grounding these intelligent agents in the real-world feedback of professional design software, the researchers have created a tool that adapts to the unique challenges of each chip it designs. As digital systems continue to grow in complexity, this ability to learn, reason, and correct itself offers a promising path forward for the future of electronic design, ensuring that the chips of tomorrow can be built with the efficiency and reliability that modern technology demands.

Technical Summary: SKILL – Self-correcting Knowledge-guided Iterative Large Language Model Agent for Logic Optimization

Problem Statement

Logic synthesis optimization faces significant hurdles due to the exponentially growing search spaces, sparse reward signals, and the diversity of logic structures inherent in modern digital systems. Traditional Electronic Design Automation (EDA) flows, which rely on expert-authored scripts (e.g., ABC, Yosys), lack adaptability across diverse topologies and technology nodes. While Reinforcement Learning (RL) offers a promising alternative by framing synthesis as a sequential decision-making task, existing RL methods often suffer from low sample efficiency, limited interpretability, and difficulties in navigating high-dimensional spaces with delayed feedback. Furthermore, emerging Large Language Models (LLMs) have demonstrated strong reasoning capabilities but have rarely been integrated with low-level toolchains to form closed-loop optimization systems.

Methodology: The SKILL Framework

The paper introduces SKILL, a novel architecture that unifies multi-agent LLM reasoning with RL-based environment interaction. The system is formulated as an augmented Partially Observable Markov Decision Process (POMDP), extending the standard tuple to include LLM guidance ( $G$ ), self-correcting feedback ( $C$ ), and ensemble coordination ( $E$ ).

1. Multi-Agent LLM Ensemble

SKILL coordinates three specialized LLMs to bridge abstract reasoning and low-level actions:

GPT-4o (Strategic Planning): Acts as the primary orchestrator, handling high-level optimization direction, long-term planning, and PDA (Power-Delay-Area) trade-off considerations.
Claude Sonnet 4 (Analytical Specialist): Focuses on detailed logic analysis, including critical path identification, bottleneck detection, and pattern recognition.
Gemini 2.5 Pro (Efficient Processing): Manages rapid processing tasks, real-time feedback generation, and dynamic strategy adaptation.
These agents operate through a consensus mechanism (Algorithm 1) that resolves conflicts and generates weighted, actionable guidance.

2. RL Agent with Hierarchical Action Space

A Proximal Policy Optimization (PPO) agent executes the actual optimization. It utilizes a two-level hierarchical action space:

Strategic Level: Aligns with LLM guidance (e.g., timing-focused, area-focused, balanced).
Tactical Level: Executes specific tool transformations (e.g., logic optimization, technology mapping).
The state representation ( $s_t$ ) synergistically combines traditional logic features with LLM-derived insights and historical context.

3. Self-Correcting Mechanism

A critical component of SKILL is its ability to autonomously detect and recover from suboptimal behaviors. The system continuously monitors:

Performance Degradation: Detected if the PDA product increases by >2% after a certain number of steps.
Constraint Violations: Triggers if timing, power, or area exceed specific thresholds.
Upon detection, the system invokes a root cause analysis (Algorithm 2) where the LLM ensemble diagnoses the failure and proposes corrective actions (e.g., rewriting, refactoring, rebalancing) without human intervention.

Key Contributions

Multi-agent LLM-RL Architecture: A novel integration of three specialized LLMs with a PPO agent to bridge the gap between abstract reasoning and executable synthesis actions.
Self-Correcting Optimization Loop: A mechanism that uses environmental PDA feedback to detect failures, diagnose root causes, and trigger LLM-based recovery strategies.
Hierarchical Action Decomposition: A two-level abstraction that aligns LLM guidance with fine-grained tool actions, improving learning efficiency.
Scalable Benchmarking: Validation across diverse benchmarks (IWLS, OpenCores, EPFL) and industrial-scale systems up to 500K gates.

Experimental Results

Evaluations were conducted on the IWLS, OpenCores, and EPFL benchmark suites, as well as industrial-scale designs (100K–500K gates).

Performance Improvement: SKILL achieved a 12.4 ± 2.1% improvement in the Power-Delay-Area (PDA) product. This surpasses expert-crafted scripts (7.3 ± 1.9%) and the best RL baseline, LSO-former (10.1 ± 2.3%).
Success Rate: The system maintained an 86.3% success rate on logic systems up to 500K gates, outperforming LSO-former (65.4% at 500K gates) in reliability at industrial scales.
Ablation Studies:
- Removing the multi-LLM ensemble reduced performance significantly (e.g., removing GPT-4o dropped PDA improvement to 10.8%).
- Removing the self-correcting system resulted in a 3.0% performance degradation, confirming its critical role.
- Hierarchical action decomposition contributed an additional 1.9% improvement.
Scalability: SKILL demonstrated "graceful degradation" in success rates as logic size increased, maintaining superior performance compared to baselines like DRiLLS and EasySO, which showed steeper declines or early degradation.

Significance and Claims

The paper posits that SKILL demonstrates how deeply integrating LLMs with industrial EDA environments fundamentally enhances logic optimization. The author claims that the framework's success stems not merely from algorithmic advances, but from comprehensive environmental interaction:

Agents learn directly from professional synthesis and analysis tools rather than static datasets.
Collaborative intelligence emerges from shared simulation observations among specialized agents.
Adaptive behavior is developed through continuous performance feedback and self-correction.

The author concludes that embedding intelligent agents within authentic EDA workflows—encompassing synthesis, timing, and power analysis—represents a crucial paradigm for advancing automated logic design as system complexity continues to grow. The work suggests that real-world tool integration, rather than isolated algorithmic improvements, is the key to unlocking transformative optimization capabilities.