Agentic hardware design

Agentic hardware design: agents build, gates judge.

Agentic hardware design means an AI agent does the engineering in a loop: it plans, builds, runs the test, reads the result and goes again. Nihil is the agentic hardware-in-the-loop IDE for products made of circuit boards. Your own agents design the PCB, write the firmware and model the enclosure, and a simulator and four gates decide what is true.

3ways to split the work: one agent, a few helpers, or a swarm

34tools your agent reaches through one MCP server

4gates no agent can talk its way past

0models hosted, tokens resold: the agents are yours

What agentic means for hardware

A chat model answers once and stops. An agent keeps going: it reads the project, makes a plan, calls real tools, looks at what came back and decides the next move, until a check it was given passes or it has a question for you. That loop is what the word agentic is for.

Search for it and most of what comes up is about chips: agents that write RTL and drive synthesis and verification, such as the AiEDA framework for digital ASIC design. That is real work, and it is a different field. This page is about the hardware most teams ship: a circuit board or several, firmware on a microcontroller, wiring, and an enclosure around them.

For that kind of product the hard part was never getting an agent to produce files. It is knowing whether the files describe something that works. So an agentic workflow for hardware needs two things a code editor does not have: a way to run the design before it exists, and a judge that is not the agent.

One turn of the loop

Inside Nihil an agent works through one MCP server, nihil, with 34 tools, and through the same nihil command line you can type yourself. A turn looks like this:

  1. Read the card. Work arrives as a card: the goal, what to read first, the paths it owns and must not touch, and acceptance written as text plus the command that proves it.
  2. Change the source. A board is a Python generator, an enclosure is a CadQuery script, firmware is portable C. The agent edits those, never a layout by hand.
  3. Run it. The board goes through the pipeline. The firmware compiles for the microcontroller and for your PC, and the PC build runs on a chip model wired into the solved circuit and into the product’s digital twin.
  4. Read the verdict. Each test ends in accept lines that the engine judges. The answer is two words: nihil obstat, nothing stands in the way, or obstat.
  5. Fix, or ask. A failure goes back into the source. A decision that is yours becomes a question on your desk, with a default and a deadline, so the work does not stall while you are away.

The demo project shows a turn that ended in no. Its PWM drive reads obstat, because in a 300-second soak at the hottest ambient one part’s case reached 60.98 °C against a 60 °C limit. No agent gets to round that down. The whole path from a sentence to a board you can order is its own guide.

Nihil's Replica space on its Audit tab for the demo project: car_ctrl is expanded and reads nihil obstat at step 14 of 14 with ERC and DRC at zero, while pwm_amp and pwm_gen read obstat in red: their system fails STRESS-08 and their ERC, DRC and distributor checks have not run.
What an agent’s work is held to. One board of the demo passed every gate; two read obstat, and the checks that never ran are shown as not run, not as green.

How much you hand over

Agentic does not have to mean unattended. There are two ways to work, and you can drift between them in the middle of a project.

  • Side by side. You steer every part, net and decision. Pin a note on the thing you mean, run one card at a time, read its transcript, open a terminal and talk.
  • Autopilot. You say what you want and leave. Ready cards run, questions wait on the desk with their defaults, and a digest is there in the morning.

How many agents work at once is a separate choice:

How wide the work runs
ModeWhat happens
NoneOne session does everything itself, with no helpers.
SomeThe default. A lead agent hands out work that splits cleanly to two to four helpers at a time.
SwarmEvery ready card of every ready wave starts at once, each with its own agent, capped by what the machine can carry.

What keeps several agents out of each other’s way is plain git. Work is cut into waves, each wave into lanes, each lane into cards. A lane owns a set of paths in its own worktree, and two lanes that claim the same path are flagged before anything launches. So one agent can be on the enclosure while another is still routing the board it fits around.

A card can also run headless, with nobody at a terminal: Claude Code as a background job, its messages and tool calls shown live in the app. Long jobs keep going with the app closed, and work can run on a schedule. When your agent hits its usage limit, each one finishes its turn and writes down where it stopped, and the lanes pick up from that note after the reset.

What checks the agents

Handing over work is only useful if you can trust what comes back without rereading all of it. These are the rules an agent in Nihil cannot argue with.

  • The gates. Every board runs the same fourteen steps. Four are gates: circuit stress, ERC, the final DRC with parity and a live check of every purchased part. No fab file exists until all four are clean.
  • The engine judges. A pass is a number the simulator computed against an accept line. The same inputs and the same seed give the same trace hash, so anyone can run it again.
  • Not run is not passed. Nothing turns green by being skipped.
  • Grants, not trust. A headless agent may always read and may always write project records. Starting a program, such as a build or a flash, needs a grant from you, and nothing in a project folder can give one.
  • Files are not orders. Your messages, the card and Nihil’s rules are instructions. Everything else an agent reads through Nihil, from a job log to what a board prints on its serial port, is marked as information.
  • An agent’s schedule is a proposal. A schedule an agent adds starts nothing until you allow it once.
  • The record outlives the chat. Every run keeps who ran it, on what, and what the verdict was.

The agent can extend the checks too. Ask it for a step and it exists: a new test, a gate, a simulation. It loads only after validation, and if it ever breaks it is switched off with the reason shown. What an AI agent gets for PCB design, tool by tool, and how the simulation behind the verdict works.

Agentic hardware tools, side by side

Several teams are building agents for board-level hardware, and they are aimed at different jobs. Each row says what the tool is in its own words, as its site put it in November 2026.

Agentic tools for board-level hardware
ToolWhat it is, per its own siteReach for it whenWhere Nihil differs
Odem “From concept to hardware”: mechanical design, PCBs and firmware in one workspace, with a download for Mac. You want the mechanics, the board and the firmware in one Mac app. Nihil runs on Windows, macOS and Linux and hosts no model: it takes the agent you already run. Its centre is the proof, with the firmware running on the simulated board.
Copperhead “Cursor for circuit boards”: “an open source, verification-first AI agent for PCB design”. You want an open-source agent for the board itself. Nihil is not open source and is not an agent. It is the IDE around your agent, and it covers the firmware, the enclosure and the twin along with the board.
Schematik “AI Hardware Builder for ESP32, Arduino and Pico”: describe what you want and get code, wiring diagrams and step-by-step hardware instructions. You are building on an ESP32, Arduino or Pico board with modules wired to it. Nihil designs the custom board itself, routes it and gates it. Arduino sketches do not run in its loop yet.
Flux “Create Hardware with AI”: an idea turned into a schematic, a routed PCB and fab-ready files, in your browser. You want to design in a browser tab with nothing installed. Nihil is a desktop app on plain files in your own git, and it judges the board in simulation with its firmware running.

More of them, including the layout specialists and the circuits-as-code frameworks, are in the AI hardware tools, side by side. For the simulators, see Nihil next to Wokwi, Renode and KiCad’s simulator.

Where agentic hardware design still stops

  • A person orders the boards, solders what the fab did not, and holds the probe. The bench has the last word.
  • An agent can write a wrong test. The gates judge the tests you have, so read the accept lines the way you would read any test.
  • A swarm spends your agent’s tokens fast. Nihil’s own docs record one swarm day at 4 to 5 million.
  • Headless runs are built on Claude Code. The other agents work in a terminal.
  • Boards and products, not silicon. No RF, no antenna tuning, no certification.
  • The desktop app is in invite-only alpha.

Questions people ask

What is agentic hardware design?

It is hardware design where an AI agent does the work in a loop instead of answering once: it plans, acts with real tools, reads the result and goes again until a stated check passes. For a product, the agent writes the board, the firmware and the enclosure, runs them in simulation and fixes what failed, while a person sets the goal and answers the questions that matter.

Is agentic hardware design about chips or circuit boards?

Both, and they are different fields. Most research under that name is about chips: agents that write RTL and drive synthesis and verification. Nihil is for products made of circuit boards: the PCB, the firmware on its microcontroller, the wiring and the enclosure. It does not design silicon.

Which AI agents can build hardware in Nihil?

The one you already run. Claude Code comes first, Codex, Gemini and Antigravity launch too, and OpenRouter or a local model also work. Nihil hosts no model and resells no tokens. Every agent it launches gets one MCP server with 34 tools.

Can I use Claude Code to design hardware?

Yes. Claude Code is the agent Nihil is built around first. It runs in a terminal inside the app, or headless as a job, with the nihil MCP server already connected, so it can run the pipeline, the simulators and the gates and read their results.

Can several agents work on one product at the same time?

Yes. Work is split into lanes, and each lane owns its own set of paths in its own git worktree, so two agents are not handed the same file. Nihil shows an overlap before anything launches. You choose how wide it goes: one agent, two to four helpers, or a swarm that starts every ready card at once.

Can an agent work overnight without me?

Yes. A card can run headless as a background job, long jobs keep going with the app closed, and questions collect on the desk for the morning, each with a default and a deadline. A headless agent reads and writes project records freely, and it starts a program, such as a build or a flash, only with a grant you gave.

What stops an agent from shipping a bad board?

The verdict never comes from the agent. Every board runs the same fourteen steps, four of them are gates, and no fab file exists until all four are clean. Each test ends in accept lines that the simulation engine judges, and a check that did not run counts as not passed.

Can text in a file or on a serial port give the agent orders?

It is not treated as an order. Your messages, the brief of the card and the rules of Nihil are instructions. Everything else an agent reads through Nihil, such as files, job logs, an imported design or what a board prints, is marked as information and never as instructions.

Is Nihil a Cursor for hardware?

In the sense people mean, an IDE where an agent does the work, yes. Two things differ. Nihil runs no model of its own: your agent runs in its terminal, on your account. And the work is judged by simulation and gates, with the firmware running, not by reading a diff.

Read next

See it run on a real board.

The demo project is an RC car, its two boards, its twin and every gate’s record, in the real app, read-only, in a tab. The desktop app is in invite-only alpha for Windows, macOS and Linux.