Your AI agent failed. The model might not be the problem.

As AI agents move into production, the path between a request and its result is becoming less predictable. An agent can choose its own tools and change course as it works, which makes failures harder to diagnose when there isn’t an obvious error to trace.

In a recent interview with The New Stack, Nvidia VP of Product Adel el Hallak described the additional visibility developers will need as agents take on more complex work.

Nvidia is also part of an industry effort to share what companies learn when those systems fail. The Secure Agent Findings Exchange, or SAFE, is backed by roughly 140 companies and aims to create shared infrastructure for reporting agent failures, borrowing from vulnerability disclosure in traditional software.

“When we find these vulnerabilities, it’s not just for one company,” el Hallak tells The New Stack. “It’s for everyone to patch across.”

But agent failures don’t necessarily trace back to a single component, raising a more basic question for developers. When an agent fails, what exactly do you debug?

“When we find these vulnerabilities, it’s not just for one company. It’s for everyone to patch across.”

Why traditional observability falls short

With conventional software, developers usually have a starting point when something goes wrong, whether it’s an exception, a failed request or a service that goes down. An agent can keep running while heading in the wrong direction, carrying an earlier mistake through the rest of a task without producing anything that looks like a conventional software failure — or, as el Hallak put it, simply deciding to “get creative” when it shouldn’t.

Even the best-performing coding agents fail more than 60% of the time on tasks drawn from real codebases. Knowing the agent failed, though, is different from knowing why.

“It’s not enough to just look at the logs or the inputs and the outputs,” el Hallak tells The New Stack. “It is important to figure out how it got to the answer. What were the reasoning traces? What tools did it utilize? Where did it get stuck? Where did it decide to try a new approach?”

That can require replaying the agent’s execution to see where it went off course. What looks like a model failure may have started somewhere else in the stack. And that’s the tricky part for developers. Agent bugs aren’t always model bugs.

“It’s not enough to just look at the logs or the inputs and the outputs. It is important to figure out how it got to the answer. What were the reasoning traces? What tools did it utilize? Where did it get stuck? Where did it decide to try a new approach?”

Runtime as collection point

Nvidia sees the runtime as the logical place to capture much of that information. Its OpenShell agent runtime, which sits underneath the NemoClaw platform, manages sandboxing, and policy enforcement while providing visibility into an agent’s execution.

El Hallak called OpenShell the one non-negotiable component across Nvidia’s reference architectures.

“You can change whatever harness you need. I’m even open to using whatever models you need,” el Hallak tells The New Stack. “But the governance, the secure and open runtime that we want to leverage at all times is OpenShell.”

Nvidia breaks the agent stack into three layers: the model provides the intelligence, the harness orchestrates its work, and the runtime governs execution. When an agent fails, the model itself may not be what went wrong.

Nvidia’s NOAH research, for example, showed that changing the harness while keeping the underlying model fixed can improve agent performance, which also means a poorly matched harness can drag down an otherwise capable model.

“Every model’s different. Some could be more chatty than others,” el Hallak tells The New Stack. “Making sure those two things are either co-developed together or have profiles that are specific to models is a new unlock.”

Safety as systems engineering

Nvidia CEO Jensen Huang has described AI safety as an engineering problem, an approach el Hallak compared to traditional software testing.

“If there’s a bug in your software, you don’t release it,” el Hallak tells The New Stack. “You work until it’s fixed and it passes all your tests.”

Agents complicate that model because reproducing a failure can require reconstructing what happened across the system. That requires instrumentation, which comes with its own cost. OpenAI has found that monitoring adds roughly 20% to inference compute for its most capable persistent agents.

Nvidia’s approach combines governed harnesses, sandboxed runtimes and confidential computing intended to protect models and user data.

“There are ways where you make guarantees all the way down to the silicon,” el Hallak tells The New Stack.

SAFE extends that engineering approach beyond a single company’s systems by creating infrastructure for organizations to share what they learn when agents fail.

“If there’s a bug in your software, you don’t release it. You work until it’s fixed and it passes all your tests.”

Agents debugging other agents

CrowdStrike is fine-tuning Nvidia’s Nemotron models on years of security data to create paired agents, with one finding exploits and another patching them.

If either agent goes wrong, the final output may not reveal why. A bad patch, for example, could trace back to the model, the agent’s execution path or the tools it used along the way.

“I don’t need general purpose for a given task. I need specialization,”el Hallak tells The New Stack

As companies build agents around increasingly specialized workflows, those failures may not show up in general-purpose model benchmarks or safety tests, putting more pressure on developers to understand what happened during execution.

Toward shared failure reporting

For platform teams, finding the failure is one problem. Reconstructing enough of the agent’s execution to understand what caused it is another.

SAFE is intended to make those findings useful outside the company where they were discovered. Traditional software has established systems for sharing vulnerabilities and fixes, but nothing comparable exists yet for agent failures. The goal is to keep every team from having to discover the same failure on its own.

The post Your AI agent failed. The model might not be the problem. appeared first on The New Stack.