AIapplications Case Breakdown: Self-Verifying, Long-Running Agents Inside the Siemens Fuse EDA AI Agent Stack

Most enterprise AI initiatives do not stall because a model is weak. They stall because nobody can say who signed off on the output, and because an agent that must be watched every few minutes never survives production. That is why the latest extension of the partnership between Siemens and Nvidia, which adds self-verifying agentic workflows to the Fuse EDA AI Agent, deserves to be read by application owners as a deployment pattern rather than only as a chip-design announcement. It answers a question that digital, product and operations leaders now face in every department: what has to be true before an autonomous agent can be trusted to run unattended for hours or days on work that carries real cost?

The vendor's own description gives a compact answer — a closed evidence loop. The agent plans, delegates and acts, but engineering correctness is decided by deterministic simulation, verification and physical design tools. A language model alone does not decide whether a design is correct; the agent must gather proof from those engines before the next decision is made.

What the update actually wires together

From an application-integration standpoint, the release links five layers that are usually bought and operated separately:

• Reasoning and agent software. Planning and multi-step execution are extended with the Nvidia Nemotron 3 Ultra model, agent behavior is evaluated with the Nvidia NeMo Gym open library, and Nvidia OpenShell secure runtime supplies an isolated environment in which agents execute.
• Accelerated compute. Nvidia CUDA-X libraries speed up the numerical operations behind simulation and physical verification, shortening the gap between an agent action and the feedback the agent needs next.
• Domain tools. The work reaches across Siemens EDA technologies: Catapult high-level synthesis, custom IC design and verification with Solido, physical implementation through Aprisa, signoff verification with Calibre, and design-for-test via Tessen.
• Orchestration surface. The system is now integrated into Intelligence Center X, so agent creation and orchestration happen inside an enterprise industrial AI environment instead of a side project.
• Evidence generators. The agent monitors a workflow, inspects results, alters its configuration and reruns operations while checking progress against established engines — for example deciding which SPICE analysis to run or whether another process, voltage and temperature (PVT) corner is needed, while the simulator still produces the electrical result.

Three releases, one capability curve

1. DAC 2025 — foundation. The Fuse EDA AI System delivered the data and model infrastructure required to apply generative AI to EDA data at all.
2. GTC, March 2026 — execution layer. The Fuse EDA AI Agent introduced a supervisory agent that breaks an engineering objective into tasks, delegates work to specialized agents, and connects to EDA applications through Model Context Protocol (MCP) interfaces.
3. DAC 2026 — duration. Long-running agents keep working after the first tool call: launch a simulation, inspect returned logs, identify a failure, modify the setup, try again.

The curve matters for anyone planning a roadmap: capability arrives in the order data foundation, then controlled execution, then unattended duration. Skipping a stage is the most common reason agentic pilots look impressive in a lab and collapse in production.

Figure 1: The Fuse EDA AI platform roadmap advances from a foundational AI architecture in 2025 to end-to-end orchestration and self-verifying, long-running agents in 2026. (Source: Siemens)

Reference case: library characterization end to end

Library characterization is a useful illustration precisely because the underlying simulations were already automated, so the bottleneck was supervision rather than compute. For a standard-cell, memory or custom-IP library, characterization across different operating conditions must be completed before timing and power models can be used. Engineers first configure the library and run preliminary simulations to confirm the environment behaves. Amit Gupta, senior vice president and general manager of Solido Custom IC and chief AI strategy officer, at Siemens EDA, Siemens Digital Industries Software, describes that preparatory phase as “pipe cleaning”. When simulations fail from an incorrect setup or a convergence issue, someone must inspect the result, change the configuration and rerun the task; only then does the full characterization run begin. Continuous monitoring of failures, review of outliers and decisions on extra PVT corners follow. “It comes out to about a four-to-six-week process for a library,” Gupta said — a four-to-six-week calendar dominated by human loops.

The Solido Characterization agent automates much of that loop. An engineer can initiate the process with a single prompt; the agent launches hours-long runs, monitors them, reacts to failures, changes configurations, reruns jobs and performs final quality-assurance steps. Using the Solido Characterization Suite with agentic AI, Siemens reports characterization turnaround cut by more than 10× and token cost by 5× to 10×, with Liberty files generated and verified automatically.

Deterministic tool	Role in the agentic workflow	What the agent reads back
Solido Characterizer	Manages the characterization tasks	Task status and completion state
Solido LibSPICE	Runs the circuit simulations	Raw electrical results and logs
Solido Generator	Produces the Liberty models	Model files ready for quality checks
Solido Analytics	Examines results, supports outlier analysis	Outliers and pass/fail signals

The productivity gain is concentrated in the gaps between simulations — the manual work of restarting, reconfiguring and re-checking. Nvidia CUDA-X accelerates the numerical operations used by simulation and physical verification tools, and Nvidia's PhysicsNeMo open-source PyTorch framework for physics AI models gives the agent fast estimates so it can explore a design and decide where higher-fidelity simulation is actually required.

Figure 2: Siemens’ self-verifying EDA architecture combines deterministic EDA engines, optimized AI agents, secure orchestration, Nemotron reasoning models, and CUDA-X accelerated computing. (Source: Siemens)

Even so, Timothy Costa, general manager for industrial and computational engineering at Nvidia, is explicit about the boundary: “The goal is not to replace physics with AI.” Trusted solvers, test data and domain-specific criteria remain the final reference.

Manual loop versus self-verifying agent loop

Dimension	Traditional manual workflow	Self-verifying long-running agent
Task start	Engineer scripts and queues each run	A prompt; the supervisory agent decomposes the objective
Unattended duration	Minutes of hands-on attention per step	Hours-long runs with self-monitoring
Failure handling	Human inspects logs, edits setup, reruns	Agent inspects logs, changes configuration, reruns
Evidence of correctness	Engineer judgement plus tool reports	Deterministic engines; the model does not adjudicate
Cost driver	Manual cycles between simulations	Reduced manual work between simulations
Human role	Operator of every step	Supervisor: observe, pause, stop, redirect

A seven-step path to a supervised agent pilot

1. Select a workflow with a deterministic checker. The pattern only works where an existing tool can prove the result.
2. Map the acceptance criteria the agent must satisfy before it is allowed to move on.
3. Expose the tools through a controlled interface, as the reference implementation does through Model Context Protocol (MCP).
4. Add orchestration inside an enterprise environment rather than on a laptop, mirroring the Intelligence Center X placement.
5. Instrument evaluation. Use an evaluation harness for agent behavior, in the style of NeMo Gym, before widening autonomy.
6. Wrap execution in a secure runtime such as OpenShell, with explicit pause, stop and redirect controls.
7. Keep a human in the loop on outlier review and on any change that can propagate to another stage.

Where the autonomy still stops

The library example has well-defined inputs, tools and acceptance checks. Extending the same autonomy across several domains is harder. Gupta says current work is focused on long-running agents within individual areas such as custom IC design, digital verification, design-for-test and Calibre physical verification, and that “What we see as the next step is being able to stitch those product families together.”

An early demonstration shows why the stitching problem is not a connector problem: Calibre detects a design rule violation, and the agent invokes Aprisa semiconductor software for a digital physical design repair, or Solido for an analog repair. That moves the agent from identifying a problem to changing the design, which creates new verification requirements — fixing a local rule-check violation can introduce a timing, congestion or signal integrity problem elsewhere. The gap is therefore semantic as well as mechanical: Siemens is developing EDA ontologies that map relationships between domains and improve the models' ability to handle different data types, because a change in one stage may invalidate results elsewhere. Near-term deployment will remain domain-scoped and supervised; broader autonomy arrives only when engineering intent can be preserved while agents move across tools, data models and verification steps.

Four misconceptions worth retiring

• “A better model is the missing piece.” The gating factor here is evidence generation, not reasoning quality.
• “Agents replace the physics engines.” They keep the workflow moving; the deterministic engines decide whether results can be trusted.
• “One integration server all domains.” Cross-domain stitching requires design-representation understanding, not only more exposed applications.
• “Long-running means unsupervised.” The reported design keeps engineers able to observe, pause, stop and redirect.

Action recommendations for application owners

• Pilot where acceptance checks already exist and where supervision, not compute, dominates the calendar.
• Budget for the orchestration and secure-runtime layer as part of the agent project, not as an afterthought.
• Track two cost lines separately: model token spend and the human hours reclaimed from the loop.
• Write down which artifact constitutes proof before the agent is allowed to iterate.
• Treat vendor-reported multiples as directional until replicated on your own workloads.

FAQ

What does self-verification mean in this context?

The agent validates its own decisions continuously against proven engineering tools — simulation, verification and physical design — instead of asking a language model to judge correctness.

Which gains are claimed, and how should they be read?

For library characterization with the Solido Characterization Suite, Siemens reports turnaround reduced by more than 10× and token cost reduced by 5× to 10×. These are vendor-reported figures for one workflow; treat them as a starting hypothesis for your own pilot.

Does this mean AI replaces simulation?

No. As Costa puts it, “The goal is not to replace physics with AI”; fast estimates from physics-aware models help decide where a higher-fidelity simulation is needed.

How should teams handle a failure mid-run?

The reference behavior is: inspect returned logs, identify the failure, modify the setup and rerun — with engineers retaining pause, stop and redirect authority throughout.

When will the capability be reachable?

The expanded capabilities are slated for upcoming releases of the AI-native EDA portfolio.

Read as an application story rather than a semiconductor story, the value is transferable: pair an agent with tools that can disprove it, run it inside an orchestrated and secured environment, and expand its freedom only as fast as your verification coverage grows. That is the line ItInsightsWorld will keep watching as long-running agents move out of electronic design and into the rest of the enterprise software portfolio.