OpenAI recently released GPT-6 Astra and, while introducing its Computer Use capabilities, presented a demonstration of PCB design in KiCad. Components were placed, traces were routed, copper pours were added, and a circuit board gradually took shape. OpenAI explicitly stated that the demonstration was a 15-second condensed replay, not the actual time required to complete the task.
The demonstration was impressive, but as someone working in electronic design, I am more interested in another question:
Did the large model actually learn PCB routing through vision, mouse input, and keyboard input, or did it call a professional tool to complete an automated workflow?
Both approaches can produce a routed PCB, but their technical implications are very different.
Without making this distinction clear, a successful demonstration can easily be interpreted as proof that a general-purpose large model has effortlessly solved the long-standing engineering problem of PCB autorouting.
To examine the difference, I conducted two experiments with Astra and recorded the process.
1. First Experiment: Completed in Approximately 12 Minutes, but Who Actually Routed the Board?
Both experiments used the same environment and started from the same board: a design opened in KiCad with component placement completed but routing not yet performed.
In the first experiment, I simply asked Astra to complete the routing and did not restrict the method it could use.

Approximately 12 minutes later, Astra produced a routing result.
Looking only at the opening and closing screens, it certainly appears that the AI routed the PCB by itself. However, the actual execution sequence was:
KiCad exported a DSN file → Freerouting performed the autorouting → the SES result was imported back into KiCad.
DSN is a design file supplied to an external router, while SES is used to transfer the routing result back into the design software. This is not a new workflow created by the large model. It is an existing method for coordinating KiCad with an external autorouter.
In this experiment, Astra's main contributions were understanding the task, organizing the steps, calling the tools, and returning the result to the design environment.
Freerouting performed the core routing computation.
That contribution is still valuable. Connecting multiple operations that would otherwise require manual execution is itself an efficiency improvement. However, the result should be described more precisely:
Astra automatically organized a PCB routing workflow. It did not demonstrate that it had independently mastered PCB routing using only visual input, a mouse, and a keyboard.
In addition, "completed" in this context means that the task produced a routing result. It does not automatically mean that the design passed production-level verification.
2. Second Experiment: With External Tools Restricted, Only Three Short Traces Were Completed in One Hour
For the second experiment, I kept the same environment and the same initial board state, but changed one instruction:
External tools were not allowed. Astra had to route the board in KiCad through visual interaction with the mouse and keyboard.
The result was clearly different from the first experiment. After running for one hour, I stopped the task manually.
This comparison strengthened my conclusion: at least in these tests, access to a professional routing tool had a decisive effect on the result.
However, the limits of the experiment must also be stated clearly. These were two runs on the same board. The restriction in the second run was imposed through the prompt, and this was not a systematic evaluation across different boards, parameters, or repeated trials. The experiment does not prove that pure graphical interaction can never complete a routing task. Nor does it prove that OpenAI's official demonstration used the same backend toolchain.
The point is to question the capability interpretation encouraged by the demonstration, not to use two personal experiments to make an unverified technical claim about the official demonstration.
3. Using Industrial Software Does Not Mean Solving the Algorithms Behind It
One concept requires clarification: Computer Use and tool calling are not mutually exclusive.
According to OpenAI's documentation, Computer Use can operate through structured mouse and keyboard actions, but it can also use code execution and relevant libraries to interact with an interface. Therefore, demonstrating Computer Use cannot be interpreted as proof that the entire task was completed without code or other tools.
The more meaningful question is not whether the model used a tool. It is this:
Who performed the most difficult computation in the task?
The question can be taken one step further. Even if a model operates entirely through mouse clicks and presses an "Autoroute" button in a software application, the software's internal routing engine may still be the component planning the traces—not the model itself.
The interaction method does not explain the underlying solving capability.
I do not consider the use of professional tools to be cheating. On the contrary, enabling AI systems to use professional tools is an important direction for industrial AI.
The problem arises when promotional framing causes viewers to interpret "the model successfully called a solver" as "the model has replaced the solver." These are two different forms of progress:
- One form of progress makes professional tools easier to use.
- The other improves the solution of the professional engineering problem itself.
Both are important, but they must not be conflated. The first must not obscure the contribution made by the second.
4. The Difficulty of PCB Autorouting Is Not Simply Connecting the Nets
Autorouters have existed for a long time. It is therefore inaccurate to describe the field as if no software has been able to route PCBs automatically for decades. The real challenge is obtaining stable, efficient, and high-quality results on complex boards under strict design constraints.
PCB routing is not performed on a blank canvas where any two points can be connected arbitrarily. Trace width, clearance, differential-pair spacing, length matching, via count, and other factors may all become constraints that must be satisfied. KiCad's own routing and design-rule-checking functions address many of these issues.
From a computational-complexity perspective, the classic rectilinear Steiner tree problem associated with circuit interconnects has a decision form that has been proven to be NP-complete, while the corresponding optimization problem is NP-hard. This is a classic example of why routing optimization is difficult.
However, this point must not be exaggerated:
NP-hard does not mean that a practical problem cannot be solved, nor does it mean that AI cannot contribute a breakthrough.
It means that completing one example does not demonstrate a general, high-quality solving capability for a large range of complex designs.
A PCB autorouting result should not be evaluated only by counting the traces visible in the final image. A meaningful evaluation should also consider:
- the size and complexity of the task;
- the design constraints applied;
- whether all required connections were completed;
- the results of design-rule checking; and
- the amount of manual correction required afterward.
"A routing result exists" and "the design is ready for engineering release" are not the same conclusion.
5. Why This Distinction Matters for Real Research
I am not raising this issue to dismiss AI.
My concern is that when a condensed demonstration is separated from its technical context and circulated outside the industry, it may become a very different statement:
"General-purpose large models can already draw PCBs automatically, so why continue researching autorouting?"
If investors or industrial decision-makers see only the final result and not the professional tools, domain data, and verification procedures behind it, teams working in this field may face an unfair comparison:
- On one side is a condensed demonstration designed to emphasize a successful outcome.
- On the other side is real research that must address complex constraints, failure cases, reliability, and delivery requirements.
Such a comparison can undervalue specialized research and make it more difficult for fields that require long-term investment to receive sufficient time and resources.
The successful use of a tool by AI does not mean that developing and improving the tool is no longer important.
In fact, if a successful industrial AI workflow depends on a professional solver, that workflow also demonstrates the value of the solver.
The technologies performing the underlying work—and the people continuously improving them—should remain visible.
6. I Believe in AGI, but an LLM Is Not Magic
I strongly support AGI and believe that the future of electronic design will become more efficient and more automated.
I expect large models to take on more responsibilities: understanding requirements, organizing design workflows, coordinating tools, explaining results, and even helping explore new algorithms and design methods.
However, the breakthrough I expect is not one in which every contribution is reduced to the statement that "the model can click the mouse."
What I would like to see is a genuine combination of large models with domain data, geometric algorithms, physical analysis, topology planning, machine learning, and professional engineering tools. These systems should demonstrate their capabilities through repeatable experiments that clearly establish which problems they solve.
For industrial software demonstrations, I want to see more than an attractive final screen. The presentation should also clarify the complete toolchain, actual execution time, design constraints, and verification results.
If professional tools were used, their contribution should be identified clearly.
If the achievement is workflow automation, the value of that workflow automation should be shown.
If a new solving capability has been developed, the claimed breakthrough should be demonstrated through reproducible results.
LLMs are not magic. Progress in industrial engineering requires both stronger large models and sustained specialized research.
We can celebrate advances in AI without underestimating the tools, data, and researchers that make those advances possible.
Calling an autorouter does not mean becoming an autorouter.
Respecting this distinction is the responsible way to set expectations for industrial AI.