copperhead: Cursor for circuit boards
copperhead is an AI agent that designs, documents, and validates real PCBs from a prompt, working on your existing KiCad repository. Built and proven on a shipping open source board.
Most Claude demos are software.
This one is a circuit board.
View the full deck (PDF)
It works on the KiCad files already in your repository: the schematic, the
layout, the bill of materials, the pinout, the design docs. It reads and edits
the real .kicad_sch and .kicad_pcb sources, propagates every change across
everything that references it, and verifies its own work by running kicad-cli
ERC and DRC until the checks pass.
| Submission | |
|---|---|
| Team | Chouhan Industries |
| Built by | Animesh Chouhan |
| Repo | chouhanindustries/copperhead |
| Proof board | animesh-chouhan/open-telegraph |
| Slides | Copperhead.pdf |
| License | Apache-2.0 |
Open Telegraph, the board whose build produced copperhead, then was redesigned through it
The problem, and who hurts
Hardware design is one specialist holding an entire board’s constraints in their head for months. Input range, quiescent current, package, sourceability, strapping pins, antenna keepout: every part choice touches all of them at once, and every change ripples into five documents that nobody updates in time.
So the docs drift from the schematic. The BOM drifts from both. And the traps get caught at bring-up, or after the boards come back from fab, at $200 and three weeks a spin.
This is not a guess. It’s what building Open Telegraph looked like before the agent existed: a 40 × 40 mm ESP32-S3 Morse key with a 25 µA deep sleep budget, where one wrong regulator, a part whose quiescent draw alone eats the entire budget, silently kills the product.
What we built
An agent loop that leaves artifacts on disk, not advice in a chat window.
copperhead do "move the key input to a different RTC-capable pin"It reads the MCU strapping table, picks an RTC-capable pin that isn’t a strapping
pin, edits the schematic, propagates the new pin into the pinout and subsystem
docs and the firmware scaffold, runs kicad-cli ERC until it’s clean, and commits
with the reasoning attached.
The same loop runs from nothing: hand it a product brief and it produces a specification with every assumption flagged, an architecture, part selection with a justification per line, an ERC-clean schematic, a DRC-clean draft layout, gerbers, renders, a BOM you can order, and a bring-up plan. Every stage is gated by real validation tooling before the next one starts.
copperhead routing a board
The draft layout is correct, not optimal, and it says so itself, in a LAYOUT.md
that lists exactly what a specialist should redo before fab. Non-optimal is
acceptable. Unlabeled non-optimal is not.
Two invariants
What makes the loop trustworthy isn’t the model, it’s what the model isn’t allowed to do:
- Nothing starts without a spec. The agent can’t touch a KiCad file until a validated change proposal exists; the edit tools are structurally unavailable until it does. Every edit is traceable to a documented intent.
- Nothing is “done” until the tools agree. Every file mutation is followed by an ERC/DRC run before the agent reports success, and every mutation happens inside a git snapshot that rolls back if verification fails.
Spec-gated in, verification-gated out: the design can’t drift from its requirements, because drift is a build failure.
The before and after
The honest read on a real board:
| Today | With copperhead | |
|---|---|---|
| Idea to manufacturable files | Weeks to months | Days |
| Docs vs. schematic | Drift by default | Regenerated on every change |
| Datasheet traps | Caught at bring-up | Caught before commit |
| Who can do it | A hardware specialist | One person with a repo |
That’s a 10x reduction in time plus a collapse in error rate. The second effect is the one that makes it stick: once a change to your board propagates everywhere and self-verifies, going back to updating five documents by hand feels broken.
Where we sit against the field
| Competitor | What they do | The gap |
|---|---|---|
| Flux.ai | Agentic AI inside their own browser ECAD | Closed source, and you must move into their editor |
| Diode | AI board design as a service | $10k to $50k per board, an outcome you buy, not a tool you own |
| Quilter | Physics-driven AI layout, per board | Layout only, no design reasoning or docs |
| DeepPCB | RL placement and routing | Same, and you pay per minute of compute, results or not |
| siliXon | Text to PCB from scratch | Doesn’t iterate on designs that exist |
| Siemens Fuse | Agentic AI across Xpedition and HyperLynx | Enterprise-only, locked toolchain |
Everyone else is an autorouter, a walled-garden editor, or an enterprise EDA add-on. copperhead is the only agentic workflow that runs on open, real files in the repo you already have. “Cursor on your repo,” not “come use our IDE.”
Global on day zero
KiCad is the default open source ECAD tool worldwide, and the proof board is
published under CERN-OHL-S v2.0. There’s nothing India-specific in the product:
the first user in Berlin and the first user in Bengaluru run the same
npm install against the same file formats.
The market underneath this is specific and growing. EDA for PCBs and multichip modules, the segment copperhead actually plays in, is worth $9.8B today and projected to reach $18.2B by 2034 at a 7.3% CAGR, inside a broader $20B+ EDA market being pulled toward AI-enhanced flows and cloud deployment.
It’s also concentrated: Cadence, Synopsys, Siemens EDA, and Altium dominate, selling seats into closed enterprise toolchains (Allegro, Xpedition, Altium Designer) priced and packaged for teams that already have a hardware department. The one tool in that top tier that isn’t a walled seat is KiCad. That’s the opening: copperhead enters from underneath, on the open file formats a single builder already has in their repo, in Asia-Pacific manufacturing hubs and everywhere else at once.
Go-to-market
Three segments, in order: indie hardware builders, crowdfunded-device startups, and small EE consultancies who bill by the board.
The channel is the product. copperhead is Apache-2.0 and Open Telegraph is fully public, so the first hundred users land through the repo itself, Hacker News, r/PrintedCircuitBoard, the KiCad community, with the board as the proof that none of this is a demo. Monetization is a design-agent SaaS on top of the open CLI: hosted runs, longer context over a design history, and team-level review.
Try it
copperhead is open source and now live at copperhead.sh. Docs: copperhead.sh/docs.
npm i -g @chouhan/copperhead
export ANTHROPIC_API_KEY=<api-key>
copperhead create --brief brief.md# Pocket Morse key
A pocket-size Morse key that types over
Bluetooth as a standard keyboard.
- ESP32-S3, BLE HID
- Li-Po cell, USB-C charging
- Sleep current budget: 25 µA
- 3.5 mm jack for an external paddleEverything it writes is plain markdown, JSON, and KiCad source. There’s no proprietary format to get stuck in, and no editor to move into.
What this looks like live
One prompt against a real board. copperhead reads the design docs, proposes the change, edits the KiCad schematic, carries the new pin across every doc and the firmware scaffold, runs ERC and DRC, reads the violations back, and commits with the reasoning attached. A circuit board, redesigned in front of you.
The point
The Morse key is the proof; the agent is the product. Building Open Telegraph produced copperhead, and redesigning the board through copperhead proved it. Now that loop is packaged so anyone can run it: one person, one repo, from idea to manufacturable files in days instead of months. For the longer story of how it came together, see building open hardware with Claude.