🤖 AI

PCBWorld: A Benchmark Environment for Engine-Grounded PCB Design Automation

The paper introduces PCBWorld, an open-source, engine-grounded benchmark environment built on KiCad that enables RL and LLM agents to interactively route PCBs using native operations and DRC feedback, demonstrating that this approach significantly outperforms existing methods and approaches rule-based routers.

Original authors: Hyungseok Song, Junseok Park, Won-Seok Choi, Seohui Bae, Han-Seul Jeong, Youngjoon Park, Soonyoung Lee

Published 2026-07-08

📖 4 min read☕ Coffee break read

CC0 1.0

Original authors: Hyungseok Song, Junseok Park, Won-Seok Choi, Seohui Bae, Han-Seul Jeong, Youngjoon Park, Soonyoung Lee

Original paper dedicated to the public domain under CC0 1.0 (http://creativecommons.org/publicdomain/zero/1.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 build a miniature city on a flat piece of plastic. This city is a Printed Circuit Board (PCB), and the "roads" are thin copper wires that need to connect specific buildings (electronic components) to each other.

The rules are incredibly strict:

Roads from different neighborhoods (nets) cannot cross or touch, or the whole city short-circuits.
Roads must stay a certain distance apart.
If the city is multi-layered (like a skyscraper), you need elevators (vias) to move between floors.

For decades, humans have used rigid, rule-based computer programs to draw these roads. They work okay for simple cities, but when the city gets huge and crowded, these old programs often get stuck or give up.

Recently, scientists have tried to teach AI (like Reinforcement Learning or Large Language Models) to do this job. But most AI attempts have failed because they were playing a game with the wrong rules. They were trying to draw the roads one tiny pixel at a time on a grid, or they were writing a whole plan in one go without checking if the roads actually fit. It's like trying to navigate a maze by guessing every single step without looking at the walls.

The Solution: PCBWorld

The authors of this paper created PCBWorld, a new "playground" for AI agents. Think of it as a virtual KiCad (a popular, open-source tool for designing circuit boards).

Instead of forcing the AI to guess pixel-by-pixel, PCBWorld lets the AI talk directly to the "engine" that builds the board, just like a human engineer does.

The Engine: It's the construction crew. It knows the rules.
The Agent: It's the architect. It says, "Build a road from point A to point B."
The Feedback: If the architect tries to build a road that breaks the rules (too close to another road), the engine immediately says, "No, that's a violation!" and shows the error. The architect then tries again.

This creates a loop: Plan -> Build -> Check -> Fix -> Repeat. This is how humans actually work, and now AI can too.

The Benchmark: PCBWorld-Bench

To see if the AI is actually good, the authors created a test called PCBWorld-Bench. They didn't just make up fake cities; they used three types of test boards:

Simple Grid Cities: Small, synthetic boards to test basic logic.
Complex Gridless Cities: Synthetic boards where roads can go anywhere, not just on a grid.
Real-World Cities: 679 actual, open-source circuit boards from real projects.

The test scores the AI on whether the final city is legal (no rule violations), complete (all buildings connected), and efficient (shortest roads, fewest elevators).

What They Found

The researchers tested three types of "architects" in this new playground:

The "Pixel-By-Pixel" AI (Grid RL): These agents tried to move one tiny square at a time.
- Result: They collapsed as soon as the cities got slightly bigger. The "maze" was too long and confusing for them to solve.
The "One-Shot" AI (Open-Loop LLMs): These agents tried to write the entire blueprint in one go without checking the engine.
- Result: They failed miserably. Without the engine's immediate "No, that's wrong" feedback, they couldn't follow the strict rules. They built roads that crossed each other or missed the buildings entirely.
The "Interactive" AI (PCBWorld Agents): These agents used the new playground. They made a move, checked the engine's feedback, and adjusted.
- RL Agents: A small AI trained on simple synthetic boards was able to jump straight to solving complex, real-world boards it had never seen before. It performed almost as well as the best human-made rule-based tools.
- LLM Agents: When Large Language Models were allowed to interact with the engine step-by-step, they got much better at the job. However, they were still slow and struggled with the biggest, most complex cities.

The Big Takeaway

The paper proves that for AI to learn how to design circuit boards, it needs to talk to the construction engine and get immediate feedback, just like a human engineer.

Don't guess the whole plan at once.
Don't move one pixel at a time.
Do make a move, check the rules, and fix it.

By building this "engine-grounded" environment, the authors have given AI a realistic way to learn a difficult, rule-heavy skill, showing that interactive learning is the key to unlocking the next generation of automated design.

Technical Summary: PCBWorld - A Benchmark Environment for Engine-Grounded PCB Design Automation

1. Problem Statement

Printed Circuit Board (PCB) routing involves connecting the pads of electronic components with copper traces while adhering to strict design rules (e.g., clearance, track width, layer constraints) to ensure manufacturability. Despite the critical nature of this task, learning-based methods have historically lagged behind traditional rule-based routers. The authors attribute this gap to two primary modeling limitations in existing research:

Grid-Based Abstraction: Many Reinforcement Learning (RL) approaches model routing as cell-by-cell movement on a discretized grid. As grid resolution increases to match production requirements, the search space grows exponentially, making credit assignment and convergence difficult.
Open-Loop Generation: Recent Large Language Model (LLM) approaches often generate complete board files or routing scripts in a single pass without intermediate feedback. Without interaction with an Electronic Design Automation (EDA) engine, these models struggle to satisfy the strict geometric and connectivity constraints required for a valid board.

Industry practice relies on human engineers who interactively route boards using EDA tools, leveraging real-time Design Rule Check (DRC) feedback to correct errors and ensure feasibility. The paper argues that AI agents must replicate this "engine-grounded" interactive loop to achieve competitive performance.

2. Methodology

PCBWorld: The Environment

The core contribution is PCBWorld, an open-source, engine-grounded environment built on the KiCad open-source EDA suite. Unlike GUI-driven agents or abstract grid environments, PCBWorld exposes the KiCad routing engine directly via 58 Python APIs.

Interaction Loop: Agents interact with the environment step-by-step, invoking native KiCad operations (e.g., start_route, make_line, make_via, finish).
State Representation: The state is a nested dictionary capturing the exact board geometry, connectivity, and DRC status, avoiding lossy abstractions like grids or rendered images.
Action Space: Actions are high-level routing commands (selecting nets, drawing segments, placing vias) rather than primitive grid moves. The action space is constrained by the engine's candidate points (pad centers, track endpoints) to ensure syntactic validity.
Feedback: At every step, the agent receives the updated board state and DRC feedback (violations, connectivity status).
Wrappers: The environment provides tailored wrappers for both RL policies (tokenized sequences) and tool-using LLM agents (structured tool-call schemas), allowing both to train and act within the same MDP.

PCBWorld-Bench: The Benchmark

Accompanying the environment is PCBWorld-Bench, a benchmark suite comprising three dataset families in KiCad's native .kicad_pcb format:

D1 (Synthetic Grid-based): Replicates grid-routing tasks from the Jumanji Connector environment across five grid sizes (10 to 500) to test scalability.
D2 (Synthetic Gridless): A synthetic dataset of 2-layer boards with configurable net and pad counts, designed for training and zero-shot evaluation.
D3 (Real Open-Source): A curated set of 679 real-world open-source boards derived from the PCBench corpus, converted to KiCad 9 format. These are stratified by complexity (Small, Medium, Large) and serve as the primary zero-shot evaluation target.

Evaluation Metrics:
The benchmark scores completed boards using the KiCad engine's DRC. Key metrics include:

Clean Pass (CP): The proportion of boards that are fully connected and have zero design-rule violations (DRVs).
Potential Gain: Improvement in board quality (reduced wirelength, via count, and DRVs) relative to the bare board.
Routability: The fraction of required connections successfully routed.
Physical Costs: Total wirelength and via count.

Reward Formulation

The RL objective is formulated as a constrained optimization problem: minimize wirelength and via count subject to zero DRVs. The reward function uses a potential-based shaping approach:
$\Phi(s) = - (f_d(n_{drv}(s)) + \lambda_w \ell(s) + \lambda_v n_{via}(s))$
where $f_d$ is a concave penalty function that heavily penalizes the first violation on any net, driving the policy toward DRV-free solutions.

3. Key Contributions

Engine-Grounded Framework: The first PCB routing environment that exposes native EDA engine operations to agents, enabling interactive, feedback-driven routing similar to human workflows.
Unified Benchmark: A comprehensive benchmark (PCBWorld-Bench) supporting diverse agent types (RL, LLM, rule-based) with a unified evaluation protocol based on engine-verified outcomes.
Zero-Shot Transfer Demonstration: Evidence that policies trained on simple synthetic data can transfer to complex, real-world open-source boards without fine-tuning.
Analysis of Engine Engagement: A systematic comparison showing that interactive, engine-grounded agents significantly outperform open-loop (plan-only or engine-free) LLM baselines.

4. Experimental Results

Scalability of Action Abstraction

On the synthetic grid-based dataset (D1), the authors compared PCBWorld's segment-level API actions (PPO) against grid-action baselines (A2C, Sable).

Result: As grid resolution increased, grid-action baselines collapsed (A2C failed at grid 100; Sable at grid 200) due to the exploding horizon. In contrast, the PPO agent using KiCad-API actions maintained near-perfect routability across all grid sizes, demonstrating that segment-level actions decouple decision complexity from grid resolution.

Performance on Real Boards (D3)

RL Agents: A compact Transformer policy trained from scratch on synthetic data (D2) achieved a Clean Pass (CP) of 0.86 on small real boards (D3-A), outperforming all LLM baselines and matching or exceeding rule-based routers like Freerouting. On larger boards (D3-B), it achieved 0.45 CP, remaining competitive but showing limits in generalization to highly complex topologies.
LLM Agents: Interactive LLM agents (e.g., GPT-5.4) achieved a CP of 0.65 on D3-A, significantly outperforming their non-interactive counterparts (Plan-only: 0.19; Engine-free: 0.02). However, LLMs struggled with larger boards (CP 0.00 on D3-B) and exhibited high inference latency (minutes per board vs. seconds for RL).
Rule-Based Routers: Freerouting remained the strongest baseline on large boards (CP 0.78 on D3-B), highlighting that decades of heuristic tuning still hold value for complex cases.

Impact of Engine Engagement

The study confirmed that interactive engagement with the engine is critical. Agents that generated full board files without feedback (Engine-free) failed to produce valid KiCad syntax or satisfy design rules. Agents that planned actions without feedback (Plan-only) achieved better connectivity but still incurred significant DRVs. Only the interactive agents, which observed DRC feedback after every step, consistently produced clean, manufacturable boards.

5. Significance and Claims

The paper positions PCBWorld as a foundational step toward advancing learning-based PCB design automation.

Paradigm Shift: It argues that the path forward for AI in EDA lies in "engine-grounded" interaction rather than static generation or abstract grid modeling.
Practical Viability: The results suggest that RL agents trained on synthetic data can achieve practical routing capabilities on real-world boards, approaching the performance of established rule-based routers.
LLM Potential and Limits: While current LLMs show promise in geometric reasoning when guided by an engine, their slow inference and inability to scale to complex boards without fine-tuning indicate that they are not yet ready to replace traditional routers for high-complexity tasks.
Open Foundation: By releasing the environment, datasets, and baselines, the authors aim to provide a shared platform for evaluating agentic AI in EDA, fostering progress in both RL and tool-using LLM research.

The authors conclude that while significant challenges remain (particularly in scaling to large, complex boards and incorporating signal integrity constraints), the engine-grounded, interactive approach offers a promising and necessary foundation for the next generation of PCB routing agents.