AI, electronics and IoT
Software development with AI agents: the PCB Viewer case
An EDA tool in real use at Cubit, developed by LLM agents under engineering coordination: the process that separates adopting AI from trusting its results.

In this article
Software development with AI agents has moved past the demo stage: according to the Stack Overflow Developer Survey 2025, 84% of developers use or plan to use artificial intelligence tools in their work, and 51% of professionals use them every day. Trust, however, lags behind: in the same survey only 3.1% of respondents say they fully trust the results, and 45.7% admit they do not.
At Cubit the subject was tackled starting from an internal problem. In a hardware project the useful information already exists (schematics, netlist, bill of materials, layout, design decisions) and serves many functions: firmware, mechanics, purchasing and, today, AI agents. Yet it often stays readable only to those who use the design tool. That limitation gave rise to the PCB Viewer: an EDA viewer developed, documented and tested by a group of LLM agents, with a single engineer defining requirements, constraints and acceptance criteria. The tool is now in use within the company.
An Altium Designer project you can browse
The PCB Viewer is a web application that opens genuine Altium Designer projects in the PcbDoc, SchDoc, PrjPcb and PcbLib formats: to consult them you do not need the design suite installed. The project is uploaded as an archive, with automatic format recognition and parameter resolution. The multilayer layout is explored in two dimensions, pad by pad and track by track; schematics are browsed sheet by sheet, with nets highlighted; the board can be examined in 3D, rebuilt from the project’s STEP models. Around the rendering sit the tools of everyday work: search by component and by net, highlighting with cross-reference between schematic and PCB, measurements, detail panels on objects, layers and components.


The architecture separates responsibilities: a Python backend governs rendering and services, a .NET microservice reads the Altium Designer files and extracts geometries, schematics, project parameters and three-dimensional models. Specialist functions such as connectivity, schematic and 3D view are add-ons that switch on above a common core. For 3D the scene is assembled on the server, from STEP models converted to GLB, with a component-by-component fallback when a model is missing. The project started from the ODB++ format and was extended to Altium Designer files later; operation too follows a product discipline, with testing and production on separate environments. At the origin lies the internal need described above: to analyse, debug and document electronic designs outside the design department as well.
Multi-supplier costing of the bill of materials
The economically most significant part is the costing module. For each component, the system compares offers from several suppliers, unit price, minimum order quantity, multiples, price breaks and, where they matter, packaging constraints, and sets the theoretical cost, computed on the quantities in the bill, beside the real cost of the first order, which takes those constraints into account. In the project shown in the images the bill has 69 components, a price was found for 97% of them, and the gap between the two costs can be read line by line.

This is the kind of function that separates an engineering tool from a demo. The value lies in the semantics of the calculation: the minimum order quantity that kicks in or not, the packaging that forces you to buy more parts than you need, the price break that applies to the quantity actually ordered. Anyone who stops at the theoretical cost when quoting never sees that gap; the module’s specifications and its checks were written on these rules.
The API that makes hardware readable to agents
The function with the greatest impact on daily work is the least conspicuous: the backend also exposes design and netlist through an API, making programmatically queryable a body of technical knowledge that already exists in the Altium Designer project, but in a format meant for those who draw. Connections, pinouts, components on individual buses: once available in structured form, this information serves the company’s AI agents to generate and verify firmware code from a reliable reference, with a level of context that previously required manual steps. On the bill of materials, a semantic comparison entrusted to a language model helps match components.
With the API the viewer turns from a consultation tool into a platform for accessing design data, and that step bridges the disciplines: firmware writers consult layout, schematics and netlist; those who handle mechanics and heat dissipation use the 3D view; purchasing works on the bill of materials; agents go through the API. Decisions stay with the engineer; what shrinks is the copying work, with the class of errors it brings along.
How the development was organised
For anyone wanting to repeat the experience, the method matters more than the result: it is the part that transfers. The work began before the platform, with a shared knowledge system: atomic memory and RAG accessible to every agent, under a company versioning policy. Development was then carried out by LLM agents coordinated by a single engineer, responsible for requirements, constraints and acceptance criteria, with a Test-Driven Development approach: the tests, derived from the acceptance criteria, are written before the code, and the agents work both on development and on review, under supervision.
For the costing module, the data contract was written and frozen before parallel work was opened: a binding specification that no working group could reinterpret in its own way. Each agent worked in its own copy of the code, on files that did not overlap with the others’, with small, verifiable changes; the coordinator reran the integration checks and opened the merge request only when the acceptance criteria were met.
Around the project the rules of any well-run software job apply: every activity has its own issue and its own branch, no agent merges to the main branch on its own, everyone has a recognisable identity in version control, and a piece of work is called finished only after a concrete, documented check. Priorities, architectural choices and the final merge stay with people.
The same rules would hold for a group of people working in parallel on the same code; with agents they were applied to the letter. Within these boundaries AI multiplies the engineer’s capacity to execute, and every step remains controllable.
Anthropic’s multi-agent research system
The scheme with one coordinator and several specialised agents is certainly found outside Cubit too. Anthropic documents it for its own multi-agent research system: in internal evaluations it reports a 90.2% advantage over a single agent, while consuming about fifteen times the tokens of a normal conversation. Those are numbers from a specific case, and costs must be assessed project by project. What transfers is the control structure: the division between those who coordinate and those who execute, with explicit contracts between the parties, makes the result verifiable, not merely plausible, for the same reason that engineering contracts keep apart whoever writes the specification, whoever executes and whoever tests.
Validate before you propose
The PCB Viewer remains an internal tool; the public account comes today, when the platform was already in use. What Cubit offers customers is the method, with the skills the project demonstrates: hardware-software integration, agentic development, making the most of a company’s technical knowledge. These technologies were put to the test on a problem of our own, with our own data and costs, before becoming a proposal.
The difference between a development process with AI agents and an isolated experiment lies in the structure: requirements and acceptance criteria written beforehand, scopes and contracts during, independent verification at the end. Skills are validated first and talked about afterwards.
What to take into the project
With AI agents, trust in the result comes from the structure of the process: requirements and acceptance criteria written beforehand, scopes and contracts during, independent verification at the end.
Want to make your hardware designs readable by software and AI agents? Compare requirements and available data with the Cubit team.
Talk to Cubit