The companies generating schematics from a prompt are doing the part we don’t do. Then they hit placement and routing, try to get a language model to do it, and find out that models are bad at geometry.
Watch it: https://www.youtube.com/watch?v=apvE_ElRhiA
Listen: https://podcast.altium.com/e/ai-pcb-routing-without-the-epic-fails-inside-deeppcb/
There’s a wave of tools that turn a prompt into a schematic. Describe what you want, get parts, get a netlist, get something you can look at. Some of them are good.
They’re complementary to DeepPCB. They decide what the board is, and we place and route it.
Where those tools stop
A schematic says what connects to what. It doesn’t say where anything physically goes.
So every one of these tools reaches the same wall. You have a netlist and a parts list. Now something has to place the components and run copper between them. Without breaking clearance. Without wrecking the impedance on the pairs. Without dropping a via through a plane it needed as a reference. A generated netlist has the same gap a hand-drawn one has. Nothing in it says which net is USB, or how wide the power trace should be. Someone still has to do the autorouter configuration, or something has to do it for them.
The reflex is to ask the model to do that too. It’s right there, it wrote the schematic, why not.
Language models are bad at geometry, and it isn’t a phase
Nabil put it plainly on the podcast: the LLMs are really bad at geometry.
The two halves of this problem are different kinds of problem.
Deciding what a board is for is conceptual. What is this product. Which rails does it need. Is this net USB or a button. Models are good at that, and getting better fast.
The other half is spatial. You’re fitting copper through clearances down to 0.1 mm. A few hundred decisions deep, each one changing what’s possible for the next. That’s a sequential search with a hard geometric constraint at every step. Seven-plus years of reinforcement learning went into it.
So the split writes itself
A model decides what the board is. A router decides where every trace physically goes. A person keeps control of the trades between them. The router is the low level. Above it sits Cooper, and natural language PCB routing is how your intent reaches it before any copper moves.
We built for that split on purpose. There’s a REST API. It takes a board and its constraints, not a conversation. Generate a schematic, call us, get a routed board back.
Nabil’s word for it on the episode was compiler. You write the source, the compiler emits the binary. You don’t expect the language you wrote in to also be the assembler. We’d like to be the compiler for AI-generated schematics.
What that means in practice
DeepPCB focuses on place and route. No schematic generator, no parts search.
It also means being specific in public about what the router does today rather than vague about everything. A tool that claims the whole flow has to stay vague. A tool that claims one stage can be exact.
We post detailed use-cases on real boards: https://deeppcb.ai/benchmarks/
The bet
The front end of hardware design is getting automated. That means more schematics needing placement and routing, not fewer. They all still need copper.
We’d rather be the thing all of those tools call.
If you’re building in that space, the answer to “can we call you” is yes.
API docs: https://docs.deeppcb.ai
Full conversation with Zach Peterson, including the compiler framing in Nabil’s own words.
Watch: https://www.youtube.com/watch?v=apvE_ElRhiA
Listen: https://podcast.altium.com/e/ai-pcb-routing-without-the-epic-fails-inside-deeppcb/
