Ada

The Devin for Hardware

Comment

Good hardware design help is valuable to everyone who builds electronics, but it's not always within reach. Ada aims to fix that.

Whether you've got a chip picked out and no idea which pin is AVDD, need a sensor board laid out before a deadline you've already blown, or have sworn a blood oath to the ancient soldering gods to never again copy a decoupling network by hand at 3 a.m., Ada has you covered with datasheet-grounded circuits, a placed and routed board, and a review of its own work with every claim cited to a page.

We wanted to use Google's Agent Development Kit and Gemini 3.7's native PDF vision to explore how well an agent could read the datasheets, propose a circuit, place and route a real KiCad board, and then argue against its own design — and this is the result.

How we built Ada

As a group of friends with backgrounds ranging from broke undergrads to embedded-firmware engineers to people who have shipped real silicon, we drew our design from constraint programming, grid search, native document vision, and adversarial self-critique. By combining an OR-Tools CP-SAT constraint solver, a two-layer A* maze router, Gemini's PDF vision, and an adversarial reviewer inside Google ADK's dynamic-workflow framework, we came up with a solution to a problem that at first looked like a herculean task.

  • A Google ADK dynamic Workflow — read → propose → validate → place → repair → schematic → route → review — where each stage is a node calling a shared body, with an ADK LlmAgent root that owns the conversation and calls the whole pipeline through one generate_board tool
  • Gemini 3.7 Flash for datasheet vision, circuit proposal, and adversarial review, with a Gemma fallback rung and provider failover that checks every response for usable text before accepting it
  • An OR-Tools CP-SAT placer with real courtyard clearance, 90° rotation, edge constraints for connectors and antennas, and symmetry breaking over interchangeable passives (a board with 24 identical caps admits 24! relabelings of the same layout)
  • A two-layer A* maze router with bounded rip-up-and-retry, budgeted in node expansions rather than seconds so the same board routes the same way twice, and every net it cannot finish named with a reason instead of silently dropped
  • SPICE simulation for function, an independent geometry audit layer, and KiCad's own kicad-cli ERC and DRC as the outside authority our 1010 offline tests were calibrated against
  • Pure integer-nanometre arithmetic end to end, no KiCad install and no pcbnew DLLs — the board file is the interface, and it runs identically on macOS, Linux, and Windows
  • Cloud Run plus Firestore for the hosted surface, with extracted datasheet facts cached so the second run on a part is free

If you're interested in the whole story of how we built Ada and the details of the architecture, take a look at our GitHub README!

Challenges we ran into

Our project was wrought with too many challenges to count, from a CP-SAT model that quietly bound the board's height to its width and declared any tall component infeasible, to a single ground net expanding into 1,225 pairwise edges and swamping every signal in the layout, to KiCad's Y axis pointing down while our packer's points up and mirroring every board invisibly, to rebuilding a previous version that turned out to be hollow — its "KiCad integration" was a script that moved the operator's mouse to screen coordinate (1600, 590) and pressed Ctrl+V, and its datasheet cache was twelve committed JSON files, so the demo never called a model at all. Oddly enough, the biggest challenges were often when we had disagreements about how much to trust the model — where verification should end and autonomy should begin. However, although we'd disagree about the best course of action, in the end we all had the same goal of building something that was checkably right and genuinely useful to a lot of people. That being said, we would always eventually sit down and come to an agreement and, with each other's support and late-night pep talks over Discord, rise to the challenges and overcome them together.

What's next?

Although Ada isn't ready to replace a hardware engineer, its surprisingly good performance shows that native document vision and agent frameworks like ADK have made previously intractable problems like datasheet-grounded circuit design accessible to LLM-based approaches. Thus, we hope that our work serves to inspire others to tackle these problems and explore the newly-open frontier between language models and physical engineering themselves.

Nevertheless, we still plan to continue work on Ada, specifically footprint generation directly from datasheet package drawings (the most common cause of a dead first-spin board, and unlike layout it is objectively checkable against the PDF), part availability as a design-time constraint, manufacturability rules distinct from design-rule checks, and the guided cursor that teaches KiCad's own UI instead of hiding it — bringing a beginner into the loop rather than automating them out of it. We also intend to keep widening the router and the SPICE verifier, since there is quite a bit more of the design loop left to close.

Live demo

Try it live! A Cloud Run instance is running with no login required. Or clone the repo and run the full offline test suite and end-to-end demo in about four minutes — no API key, no network, and no KiCad install required. Add a GOOGLE_API_KEY to go from a plain-language prompt to a complete KiCad project.

DISCLAIMER

The output of an open-source AI agent is not a substitute for engineering review. Ada's router leaves hard nets unrouted on purpose, its placer reports FEASIBLE rather than OPTIMAL, and a board can pass every automated check and still have a regulator wired to the wrong pin. Open the project in real KiCad, run ERC and DRC, and review the schematic before you send anything to a fab. If you fabricate a board from this tool's output, you are doing so AT YOUR OWN RISK.

The purpose of this project is to explore how far an agent can be trusted in a domain with no cheap oracle, where the ground truth is a fabricated board weeks and hundreds of dollars away. Although the application will help you get to a manufacturable design faster, every claim it makes should be checked against the datasheet page it cites.

Thanks!

We give our thanks to the organizers of the All Things Agentic Hackathon and to the Google ADK and Gemini teams for providing a platform through which we could share our work with others, and a special thanks to the KiCad project, whose open, documented board format is the entire reason this tool can exist without ever touching anyone's mouse.

AllThingsAgenticHackathon

Built With

Share this project:

Updates

Submission history