AI Moving a Mouse in Altium Is the Worst Way to Design a PCB

Can an AI model design a PCB by driving Altium? It can move the mouse. In a public test, GPT-6 Astra drove Altium Designer for 62 hours on an 8-layer board with DDR memory. It connected 98.1% of the board, and the board still failed its DDR timing and layer rules. The model was not the problem. The mouse was.

Flux works the other way. The Flux agent works directly with the design data, the routing engine, and the design rules. It routes, checks, and fixes in one loop, with no GUI in between.

“Genuinely torture”

This week OpenAI showed how ChatGPT and Codex help engineers build for the physical world, with a circuit board in the demo. One engineer replied on X:

“getting an agent to design circuit boards using KiCad is genuinely torture”

He is right. And a public test in Altium shows exactly why.

62 hours of clicking through Altium

A PCB layout team gave GPT-6 Astra a real board: an 8-layer HDI system-on-module with an NXP i.MX 8M Mini processor and LPDDR4 memory. Placement and part of the BGA fanout were done. 857 connections were still open. Astra ran on a Windows virtual machine and operated Altium through computer use: screenshots, mouse, keyboard, and scripts. The autorouter was off.

Here is what happened:

• 4 hours and about $400 before the first trace. Astra spent them planning how to operate Altium and writing its own scripts to control it.
• Fast start, then a wall. About 48 connections an hour at the start. About 1 an hour at the end. In the last five hours, it closed one connection, and the run was stopped.
• 1,088 of 1,109 connections complete. Astra closed 836 of the 857 open connections, so 98.1% of the board connected.
• DDR timing failed. 120 ps of within-pair skew against a 1 ps limit.
• 1,555 track segments on ground layers where the rules prohibit routing, and 1,058 segments of impedance-controlled nets on power layers.
• About $2,900 in API spend for a board that does not work.

Astra’s own final report says the board “is incomplete and does not pass electrical or manufacturing acceptance,” and that the remaining work “is much larger than the 21 open edges suggest.”

Honestly, it’s impressive that a general-purpose model drove a professional EDA tool for almost three days. But look at where the time and the money went.

Why the mouse is the bottleneck

The agent had to build a way in before it could engineer. Four hours of tool building, just to read the board and confirm that its own edits stuck. A desktop EDA tool is built for a human hand and a human eye. The agent has to translate every engineering decision into clicks, then check screenshots to find out what happened.

The rules sat behind the interface. The design rules said no routing on ground layers. The agent put 1,555 segments there anyway. Through a GUI, a full rule check is a slow, separate step, so the run pushed it to the end. By then, the board was full of violations. An agent that only checks at the end routes blind.

Rip-up and reroute, one click at a time. As the board filled up, every new route meant tearing out routes the agent had placed earlier. In a GUI, that is slow manual work. Progress fell from 48 connections an hour to 1, then stopped.

The agent babysat a desktop. It ran out of API credits and sat idle for 7 hours. The Altium license dropped twice, and a human had to restore it over remote desktop. The agent fixed its own screen recorder when Windows file locks broke it, and freed disk space when its checkpoints filled the drive. None of that is engineering.

98% connected is not 98% done. Connecting nets and meeting the requirements are two different jobs. The last 2% of a dense board, plus the DDR timing, plus the layer cleanup, is where the real work is.

Your coding agent doesn’t click around VS Code

Watch an AI coding agent work. It doesn’t open an IDE and click Save. It works directly with the files, the compiler, and the tests. It makes a change, runs the build, reads the errors, and fixes them. Hundreds of times an hour.

Now picture it writing code only through screenshots of an IDE, one click at a time. Nobody would build software that way. That is what computer use in Altium asks a hardware agent to do.

I wrote about this last week: using KiCad or Fusion through MCP is like sucking a pizza through a straw. The Altium run is the same lesson at 62 hours and $2,900.

What an agent needs to route a DDR board

An agent needs the engineering itself, not the buttons that a human presses to reach it. That is how we built Flux.

• Rules before routing. Flux sets up the stackup, layer roles, reference planes, and target impedances first. Then it routes to them.
• High-speed routing built in. Flux routes differential pairs at a target impedance, matches bus lengths, and tunes skew as part of the route.
• DDR to a timing budget. Flux plans fly-by or T-branch topology for the DDR nets, calculates a timing budget from the stackup, and routes to the length and skew targets from that budget.
• Checks in the loop. Flux runs airwire and design rule checks when it finishes routing. Its report lists each open connection, what blocks it, and a proposed change.
• Signal and power integrity. Flux simulates the routed board, finds impedance discontinuities, crosstalk, and PDN problems, and fixes them.

And the board is only one part of the device. In the same Flux project, the agent models the enclosure, checks component heights against the lid, writes the firmware, and prepares the manufacturing files.

Ask for the result, not the clicks:

Plan a fly-by topology for the LPDDR4 address and command nets, and route it to a timing budget.
Route the DDR data byte lanes to the strobe as a bus. Match their lengths within 0.25 mm and keep skew below 0.1 mm.
Fan out the BGA with blind, buried, and microvias from the board stackup.
Review the signal and power integrity of this board and fix the issues you find.

Start Free Trial

Where this ends

Computer use in desktop EDA is the Cursor phase of hardware: AI bolted onto the tools we already have. Software already moved past it. The agent became the primary interface, and the tools moved behind it. Hardware is next!

The goal isn’t AI-assisted CAD. The goal is to make the CAD disappear.

So stop teaching agents to move a mouse. Give them the engineering!