The world’s fussiest proofreader
Every chip layout has to obey a rulebook written by the factory that will build it: spacing here, wire width there, thousands of rules deep. A large modern design breaks them in tens of thousands of places. The software that hunts for those breaks is called design rule check, and it has traditionally flagged the violations and left an engineer to correct them, one at a time, for weeks.
That correction step is what the toolmaker and the foundry are now automating: agents that drive multi-step, multi-tool fixes inside the sign-off flow and feed designers recommendations and real-time command execution. It is, by any measure, agentic AI in a high-stakes engineering workflow — the wrong fix means a chip that cannot be manufactured, at a cost measured in tens of millions and months.
And the announcement contained no numbers for it. No benchmark against a human fix, no methodology, no named customer running it on a production design. Anyone weighing the claim is weighing a description of a capability, not a measurement of one. That is worth noting. It is not the interesting part.
The permission slip
The quieter half of the announcement listed certifications: the verification platform certified for the foundry’s four most advanced processes, the simulation suite certified for accuracy on the same nodes, the analysis tools certified for sign-off on specific process variants, the packaging and thermal tools certified for stacked-die designs.
Certification sounds like paperwork. In this industry it decides whether a design team can start work at all, because the factory will not accept a tapeout verified by a tool it has not signed off, and the toolmaker cannot write the rule decks without the factory’s cooperation. The agents are the headline; the certifications are the permission slip. Whatever the agent does inside the flow, its output has to pass a sign-off that the factory defines, the tool enforces and the agent cannot waive.
That is the structure worth copying, and it is almost never present when enterprise agents are deployed.
What sign-off looks like outside a fab
Translate it. An agent that reconciles transactions, updates customer records, closes tickets or drafts a regulatory filing needs the equivalent of the foundry’s rule deck: a definition of what a correct result is, expressed as checks the system of record can run, agreed before the agent starts, and enforced at the point the output lands.
- The rules live with the system, not the agent. The reconciliation agent does not decide what “balanced” means; the ledger does. The agent updating a record does not decide which fields it may touch; the CRM’s validation does. Sign-off belongs to the system of record because that is where accountability already lives.
- The check runs on every output. Sampling is for monitoring. Sign-off is universal, which is exactly why it has to be automated — the same reason the layout check is software and not a person with a ruler.
- Certification precedes production. A tool is certified on a process before any design ships on it. An agent should be qualified against an evaluation set — real cases with agreed correct outcomes — before it touches live records, and re-qualified when the model or the workflow changes.
- Failure is a stop, not a note. A design that fails sign-off does not go to the factory with a comment attached. An agent’s output that fails the check does not land, and a person looks at it.
New workflows create new checks
One more thing the announcement illustrates. As chips are stacked rather than shrunk, heat stops escaping the way flat-chip simulators assume, and thermal analysis has quietly become a sign-off problem rather than a packaging afterthought. A change in how the work is done created a new class of check that did not previously need to exist.
Agents do the same to business workflows. An agent that processes ten times the volume a person did, or acts across three systems in sequence, creates failure modes the existing controls were never written for: cascading updates, rate effects, cross-system inconsistencies. The certification mindset says those checks get written before the agent runs at scale, not after the first incident review.
The tedious middle
The toolmaker’s bet is that the tedious middle of chip design — the part nobody frames a press release around — is where AI earns its keep. We think the same is true of enterprise work: reconciliation, validation, routing, the correction of thousands of small errors. But the semiconductor industry is only comfortable putting agents there because it spent decades building the sign-off that makes their output trustworthy. Enterprises want the agents. The lesson is to build the sign-off first.
