Skip to content

Tool of the Day|Copper — an AI agent that designs orderable PCBs inside KiCad

Nov 15, 20261 min
TL;DRCopper is an MIT-licensed KiCad MCP server with 31 tools covering the whole PCB design pipeline, from parts search to fab-file export. Install: npx -y copper-kicad setup (KiCad 10 required first). It fixes the gap where AI coding agents can write firmware but can't touch board layout, which still means opening an EDA tool by hand.

Look up & save

Loading dictionary…

🌏 中文版

Tool Info

ItemValue
NameCopper (copper-kicad-mcp)
TypeMCP server
GitHubclaynicholson/copper-kicad-mcp
Stars84 (at review time; repo created 2026-11-12)
LanguagePython
LicenseMIT
Installnpx -y copper-kicad setup (install KiCad 10 first)

What problem it solves

Coding agents can already write code, run tests, and open pull requests — but hand one a circuit board and it stalls. Drawing the schematic, picking parts, routing traces, running electrical and design-rule checks (ERC/DRC), and exporting the Gerber files a factory like JLCPCB needs: all of that still means opening KiCad yourself and clicking through it. For hobbyists and small teams, this step demands more hard-won judgment than writing code does — swap a part that's out of stock, size trace width to the current it carries, length-match a differential pair — get any of it wrong and the board is simply dead on arrival.

Copper wires that whole KiCad pipeline up to an AI agent through MCP. Tell it "design a USB-C powered ESP32-C3 board, 30×40mm, with a status LED," and the agent works through it the way an engineer would: it connects pins by net name (U1.PA9 → USB_DP), never by blindly guessing coordinates; it searches LCSC and JLCPCB for parts that actually have stock and imports each one's symbol and footprint (plus a 3D model, when EasyEDA has one); it reruns ERC and DRC after every change and attaches a fix for whatever fails; it routes the board with a staged router that handles length matching, differential pairs, width classes, and copper pours; it renders the schematic, layer views, and a 3D model so it can inspect its own work; and it packages the Gerbers, drill files, BOM, and placement files JLCPCB (or PCBWay, OSH Park) expects.

Copper itself never calls a language model — it uses whatever model your AI app already talks to, and just wraps KiCad as a set of tools. It fits hobbyists who want to run an entire PCB design loop in plain language, small product teams turning around prototypes fast, and teaching contexts where students can watch an AI satisfy ERC/DRC step by step.

The loop itself is the interesting part:

Copper's design loop — ERC/DRC gates every export
Copper's design loop — ERC/DRC gates every exportThe agent sources parts, then enters layout and auto-routing, rerunning ERC/DRC after every change. A failure sends it back to routing with a fix attached; a pass moves on to exporting fab files. Source parts LCSC & JLCPCB stock Layout & auto-route trace & pour routing ERC/DRC clean? every change Report error + fix Export fab files Gerber/BOM/placement no yes retry

Simplified; the real flow also includes rendering and repeated part swaps.

Quickstart

Install

Install KiCad 10 first, then pick the path for your AI app:

# Cursor / VS Code / Windsurf / Codex / Zed, etc. (Node.js 18+)
npx -y copper-kicad setup

# Claude Code
claude plugin marketplace add claynicholson/copper-kicad-mcp
claude plugin install copper@copper

# macOS / Linux one-liner
curl -LsSf https://raw.githubusercontent.com/claynicholson/copper-kicad-mcp/main/installer/install.sh | sh

Or add this entry to your MCP config by hand (Cursor, Claude Desktop, and Windsurf all take the same shape):

{ "mcpServers": { "copper": { "command": "npx", "args": ["-y", "copper-kicad"] } } }

Basic usage

Once it's installed, just ask in plain language — the agent calls Copper's 31 tools in sequence:

You: Design a USB-C powered ESP32-C3 board with a status LED, 30 x 40 mm

What the agent actually does:
1. Searches LCSC/JLCPCB for an ESP32-C3 module, USB-C connector and LED that are in stock, imports each symbol/footprint
2. Wires pins together by net name, not by dragging coordinates
3. Lays out the board and auto-routes it, reruns ERC/DRC, reports every error with a fix
4. Produces schematic, layer and 3D renders for you to check
5. Exports the Gerbers, drill files, BOM and placement files JLCPCB needs, zipped up

Advanced usage

# Try it in a throwaway folder before touching a real project
npx -y copper-kicad setup --demo

# If something's broken, ask the doctor tool what to fix
npx -y copper-kicad doctor

How it compares

CopperKiCAD-MCP-Server (another community option)tscircuit
Works natively on KiCad projects✅✅ (mostly read/write, no auto-routing or part import)❌ (circuits defined as code, not native KiCad)
Auto-search + import in-stock parts✅ (live LCSC/JLCPCB stock)❌Partial (parts looked up separately)
Auto-routing (length match/diff pairs/pours)✅❌Handled separately
Reruns ERC/DRC on every change✅Depends on the implementation—
Exports factory-ready fab files (Gerber/BOM)✅Partial✅ (exports Circuit JSON/Gerber)
Locked to a specific AI model❌ (uses whatever model your AI app already connects to)Depends on the implementation❌

Caveats

  • macOS/Linux install paths are newer. The README says Windows is "tested end to end," while the macOS/Linux one-line installers are new — file an issue directly if one fails.
  • It does reach outside services. Parts search hits LCSC/JLCPCB/EasyEDA (with a jlcsearch.tscircuit.com mirror as fallback), and auto-routing downloads Freerouting plus a Java runtime (about 120MB, once). Your design files themselves aren't uploaded, and there's no telemetry.
  • It's still a young project. The repo was created on 2026-11-12 and has just 84 stars; a low issue count doesn't mean there are no rough edges. Re-check the Gerbers and BOM yourself before actually ordering a production run.

Today's takeaway

I'd assumed "AI doing hardware" stopped at drawing a block diagram or writing firmware, and that an actually orderable PCB still meant going back to manual work. Copper's real insight is wiring a hard feedback loop like ERC/DRC straight into the agent's tool calls — every change gets bounced back by a rule check immediately, so the agent can revise its way to "valid" the way a person does, instead of committing to one generation pass. That's a pattern that generalizes to any agent work with hard constraints — hardware, regulation, a database schema: the tool has to judge right from wrong in real time before the agent can be trusted to run the whole loop on its own.

References