Siemens made Calibre the acceptance test for its DRC repair agent. Synopsys built Autopilot on what it calls ground-truth engineering engines. RISC-V is converting certification requirements into machine-readable coverpoints and self-checking tests. Pasqal put human approval and returned QPU evidence around its experiment agent. Four different workflows reached the same architecture: the agent proposes and executes, but a separate verifier decides whether the work counts.
The hardware agent is becoming replaceable. The verifier is becoming the moat.
This shifts the idea to validation to decision loop at its middle. Models have made idea generation and action cheap. They have not made a DRC-clean layout, a conformant processor, or a valid quantum experiment subjective. Hardware autonomy scales only when the definition of done is executable, authoritative, and isolated from the agent trying to satisfy it. The constraint being removed is not the engineer writing every command. It is the engineer serving as the only process that can interpret the result and decide what happens next.
The same architecture is appearing everywhere
Siemens' Calibre DRC Agent is the cleanest example. The agent identifies a violation, proposes a repair through Aprisa, and runs Calibre again. Calibre does not grade the quality of the explanation. It checks the geometry against foundry-qualified rules. The loop can continue because the verdict is machine-runnable and independent of the model.
Synopsys Autopilot makes the commercial argument explicit. Its long-horizon agents can use Synopsys, partner, or third-party models, while the platform's claimed differentiation comes from proprietary context, privileged APIs, and EDA and simulation engines that produce the engineering verdict. Model optionality is a feature because Synopsys owns the part that is harder to swap: the tools that establish coverage, closure, signoff, and physical validity.
The same split is forming outside EDA. The draft RISC-V Certification Test Plan maps profiles and configurations into coverpoints, deterministic test generation, reference-model checks, and self-checking assembly tests. A vendor can change its core, generator, or development process without changing the public definition of compliance. Certification becomes reproducible evidence instead of an expert interpreting a private harness.
Pasqal's Neutral Atom Toolkit puts the split at a different boundary. An agent defines an experiment, implements it in Pulser, emulates it, submits the approved job, and analyzes the result. The expensive action stays behind human approval, and the claim stays anchored to returned hardware data. Claude Code, Cursor, Codex, and Gemini CLI are supported interfaces. Pasqal does not need to win the model layer if it owns the path from experiment intent to controlled QPU execution and evidence.
These are not four examples of AI adoption. They are four examples of verification becoming the control plane for autonomous work.
Why now
Three years ago, the model could not reliably keep a long engineering loop coherent. Today, long-context agents can inspect tool output, retain state, recover from failed steps, and choose another action. That makes multi-hour and multi-day execution plausible.
The more important change happened underneath the model. The engineering verdict is becoming callable. Calibre can be invoked inside an agent loop. RISC-V requirements can compile into tests. Cloud QPUs expose program submission and returned measurements through software. NI's new SystemLink control plane exposes distributed test assets, analysis, and results through APIs and Python. The bench, simulator, standard, and signoff engine are turning into services an agent can query.
The longer arc predates the agent boom. Google's OpenHTF has treated a hardware test as Python phases, measurements, pass limits, instrument plugs, and a final verdict for years. What agents add is not the test contract. They add a cheap, persistent consumer of that contract. Once a team has an executable definition of done, an agent can attempt the work thousands of times without making the acceptance criterion thousands of times more expensive.
Research results point in the same direction. Trace2Skill, published in May, improves an RTL agent by feeding it bounded verifier evidence from failed runs while keeping the hidden harness inaccessible. The model weights do not change. Better connection between action and verifier feedback produces the breakthrough passes. A March paper on tool-integrated PPA-aware RTL generation reached the same design from another angle: programmer, correctness, and PPA agents iterate against EDA tool feedback rather than trusting one-shot generation.
Why now is therefore two answers, not one. Agents can finally sustain the loop, and hardware tools can finally return enough structured evidence to steer it.
Who captures the value
Siemens and Synopsys are positioned to capture more value than the foundation-model vendors in advanced EDA. A customer can replace one frontier model with another. Replacing Calibre's foundry-qualified rule decks, VCS coverage infrastructure, PrimeTime timing signoff, or Ansys multiphysics models is a different class of migration. Siemens and Synopsys hold their advantage through authoritative validators and the customer history around them, not through a better general model.
RISC-V core vendors and firmware teams benefit from the open version of the same pattern. A shared certification pipeline reduces arguments about what compatibility means and moves failures into CI. Teams building test infrastructure benefit across the physical stack. Their work changes from lab automation support into the acceptance layer for autonomous engineering.
The exposed category is the standalone hardware copilot whose product stops at a plausible artifact. An RTL generator without an independent testbench, a PCB agent without authoritative DRC, or a lab agent without calibrated measurements is autocomplete with a larger blast radius. Claude Code, Cursor, and Codex will still earn usage, but they will not own the decision surface. The vendor that owns the verifier can route among those models, negotiate their price down, and keep the customer relationship.
What builders should do
Do not start an agent program by selecting a model. Pick one expensive engineering loop and write down its acceptance contract.
For a physical-design team, that might be a repetitive DRC class with a foundry-qualified rerun after every proposed fix. For a RISC-V team, it might be a profile configuration that generates the applicable architectural tests and blocks release in CI. For a test organization, it might be one failure-analysis path where raw measurements, calibration state, limits, and disposition are available through an API.
Budget two engineer-weeks to make that verifier callable and to log every agent attempt, verdict, intervention, and regression. Then test two models against the same contract. If switching models changes the workflow less than changing the verifier, the architecture is sound. If the agent can declare success without producing independent evidence, stop. The team has automated artifact generation, not engineering.
One caveat could break the thesis. Some hardware decisions cannot yet be reduced to a stable oracle. Analog layout quality, intermittent system failures, novel materials experiments, and early architecture trades still depend on judgment across incomplete evidence. If teams discover that encoding acceptance criteria costs more than the labor agents remove, human review remains the scaling limit. Proprietary validators could also become a tax rather than a moat if customers cannot inspect why a run passed.
By the end of 2027, serious hardware-agent evaluations will lead with verifier escape rate and human interventions per closed loop, not model benchmark scores. The standalone copilot category will be absorbed into EDA and test platforms that own the acceptance engine. Builders have one practical move before then: spend the next two engineer-weeks making one definition of done executable. Every model gets cheaper. Trusted evidence does not.