Swapping a part on someone else's open-source board is quick in the schematic. The layout is the real job We took DeskHop from @ChihYang04's @boardrepo, swapped USB-A for USB-C. @DeepPCB routed only what changed in 6mins

We get asked a lot what DeepPCB is (because we're talking about LLMs). It's a two level system Low level: the router. You give it a board and it routes it. It's reinforcement learning. That's what we've been working on for 7+ years High level: Cooper, an LLM that supercharges the routing. It reads the board and works out what you meant: which layer should be power, which nets are a diff pair, that you forgot a plane. Then, Copper acts: it sets the router up (for success) For a long time we only had the router. It routed what was in the file, not what the engineer had in mind

Zach Peterson asked us on his podcast how you stop an AI tool producing an epic hardware fail. Here's our answer. We added a natural language layer to DeepPCB because of what users kept writing to us: "where is my differential pair", "why is this layer not a power layer", "where are my decoupling capacitor rules", "why is this track this width" The thing they cared about was never written down anywhere the tool could read it. It was in their head, and the file we received was silent about it A router won't invent intent you never expressed, and you wouldn't want it guessing. The fix is upstream of the router: get the intent into the file first. Then, natural language makes that cheap enough that it gets done Full episode on Altium's OnTrack, 38 mins youtube.com/watch?v=apvE_ElR…

Ask a PCB engineer about autorouters and you get one answer. "They don't work!" They're mostly right but it isn't always the router's fault. An autorouter reads your board file. If the file says a layer is a signal layer, it routes traces where you meant to pour ground. If no rule sets a width, every trace comes back the same width. The intent was in your head and it never reached the tool. You can fix that by hand. On a real board that's about two hours of setup before you find out whether the tool was any good. Most engineers do that arithmetic once and go back to routing manually. That's what we built Cooper for in @DeepPCB. It reads the board and tells you what it found. You accept or reject suggestions and you keep the last word. 👉 Replace two hours of setup with a conversation.

One objection we keep hearing: a frontier model (e.g GPT-6 Astra) just routed a board on its own, so why does a dedicated router still matter? An LLM reasons about what the board is for. High level. Routing is spatial and detailed. You're fitting copper through clearances that are much less than a millimeter, a few hundred decisions deep, with a reference plane to keep intact under the pair Cooper, the natural-language layer in DeepPCB, runs on someone else's LLM. The provider doesn't matter. The key is the routing engine underneath. Take it out and there's not much left Quick extract of Nabil Chouba and I on the Altium® OnTrack podcast on AI autorouting with Zachariah Peterson Full video in the comments, together with comparisons of DeepPCB vs pure LLM board design

We recorded an episode of Altium's OnTrack podcast with Zach Peterson Nabil and I walked through how @DeepPCB works. There's a reinforcement learning router underneath, and Cooper sits on top of it, reading your board and getting your design intent into the file before anything gets routed The boards weren't ours. We received three from Zach's community and routed them. On the one we started from scratch on air, Cooper's first observation was that the ground and power layers were typed as signal. That's the setup gap behind most of the "autorouters don't work" you hear: route that board as it stands and you get traces where you wanted a copper pour We also spent time on what we don't do (yet). We'd rather say it someone else's podcast is easier than it sounds, because the alternative is a customer finding out for themselves These tools change the designer's job. They don't remove the need to know (1) something about PCB design, or at least (2) what you're trying to achieve

Any model that lays out a board has to guess your differential pairs, and guessing wrong is worse than not guessing at all In @DeepPCB, Cooper proposes them, and it sharpens with every better model (GPT-6 Astra included). Better LLM, better Cooper, better DeepPCB

GPT-6 Astra plans a board from a concept. Routing is the opposite problem: fitting copper through gaps in the order of ~0.1mm @DeepPCB spans both: tell Cooper the intent, and the router takes it down to the copper. Neckdown is that in miniature, the trace thins to clear a tight pin, then widens back to spec Concepts in, mm out

Your anomaly list tells you what's broken but never what to do about it Ask Cooper. It names the cause and fixes what it can The better the models behind it get, the more of the work it takes. The routing stays in @DeepPCB

That’s Cooper! Check RHS panel here: app.deeppcb.ai/shared/CGKbu_…

STRF board: github.com/pms67/STRF-Kicad DeepPCB routing: app.deeppcb.ai/shared/CGKbu_… Astra routing: app.deeppcb.ai/shared/F4kbXV…

GPT-6 Astra routed this PCB in 33 minutes. @DeepPCB took 2. Same board, same component placement. The board is STRF, an open-source RF-to-USB dongle: 4 layers, 39 components, 98 connections. But the interesting difference isn’t just the time. Look at the USB data pair in the image. Astra (left) routed it across both outer layers, using four vias. DeepPCB (right) kept both traces on the top layer with none. Across the whole board: 14 layer changes with Astra, 6 with DeepPCB. These are routing decisions. Every trace you commit changes the space available for the next one. Where to stay on a layer, where to change layers, and which detours to avoid are exactly the decisions a specialist routing engine is built to make. Our natural-language assistant, Cooper, reviewed the board and recommended settings for the router. It didn’t route the board. DeepPCB did. That is our architecture: an LLM (Cooper) translates designer intent into constraints and orchestrates the tools. A specialist engine does the routing. This illustrates why Astra shipping is an opportunity for DeepPCB. The opportunity isn’t LLMs versus specialized routing engines. It’s LLMs using them.

Check out our routing app.deeppcb.ai/shared/OkkY9e…

Ok so Astra one-shotted a schematic, a placement and a routed 4 layer board. Already mind blowing We ran the same board through @DeepPCB. Some notes: > The board uses five track widths. It declares one net class, and that class is empty. So four of those widths can't be checked. A DRC has nothing to hold them against > 9 of Astra's 32 vias sit inside pads. On a 4-layer 27-net board. Via in pad means a filled and capped process and a conversation with your assembler. This board doesn't seem to need it Result after 15 mins of routing: >DeepPCB: zero vias in pads, every width under a rule, 1,104mm of copper against 1,282 >DeepPCB places 2x more vias (64 v 32). Split them: 15 layer changes for Astra, 14 for DeepPCB. The other 50 drop the rails into a split power plane on inner-2, which costs holes and a routing layer Those come from the router underneath, not from reasoning. Driving one well doesn't fix what the router itself gets wrong LLMs will keep getting better, and that means more designs. They still need routing. Astra is pretty insane and it's good news for us Any frontier LLM can drive a router like DeepPCB, through our API or with Cooper

Very clear 💪

And the DeepPCB plugin for KiCad: github.com/instadeepai/deepp… if you want a router aware of diff pairs, decoupling caps, etc