Tracing Isn't Trust: What Enterprises Actually Need to Measure in Agentic AI

At KubeCon + CloudNativeCon Europe on March 25, 2026, Solo.io announced two things. The first was agentevals, an open source project that instruments and benchmarks agentic AI behavior across any model or framework. The second was the contribution of agentregistry to the Cloud Native Computing Foundation, giving the cloud native ecosystem a shared infrastructure layer for tracking deployed agents.

The announcements landed with weight because the underlying problem is real: enterprises have been running AI agents in production without any agreed-upon way to know if those agents are behaving correctly. Logs tell you the agent ran. Latency metrics tell you how fast. Neither tells you whether the agent did the right thing.

What traditional observability misses

Traditional monitoring was designed for deterministic systems. A service is up or it's down. A query succeeded or it failed. The system health dashboard tells you when something breaks.

Agentic AI is not deterministic. An agent reasons across multiple steps, selects tools, retrieves context, plans, and executes — often without human review of each decision. The same agent can produce different outputs from the same input on different runs. That's by design. It's also what makes traditional observability structurally incomplete as an evaluation framework.

According to Solo.io's CEO, "Evaluation is the biggest unsolved problem in agentic infrastructure today." The specific failures that slip through standard monitoring are instructive:

• An agent picks the wrong tool for a step and the workflow completes anyway — technically healthy, wrong outcome
• Retrieval pulls an outdated policy document and the agent answers confidently based on it
• A model swap or prompt update changes agent behavior subtly; no alert fires
• The agent follows a plausible but flawed trajectory and produces an answer that looks correct

None of these register as errors in a traditional observability stack. A system can be passing every health check while delivering bad business outcomes at scale.

Why evaluation is becoming its own control layer

The Solo.io agentevals project approaches this differently. It uses OpenTelemetry — the industry standard for distributed tracing — to capture and correlate individual invocations across an agentic loop, then scores them against "golden eval sets" using an extensible evaluation engine. The key insight: treating the agentic loop the way observability platforms treat distributed systems, rather than the way LLM monitoring platforms treat single-turn model calls.

This matters because the enterprise AI conversation in 2026 has shifted. Burley Kawasaki, who leads agent deployment at Creatio, put it plainly to VentureBeat: "People have been experimenting a lot with proof of concepts, they've been putting a lot of tests out there. But now in 2026, we're starting to focus on mission-critical workflows that drive either operational efficiencies or additional revenue." (VentureBeat)

The market is moving from "can we run an agent?" to "can we trust an agent in production?" Those are different questions that require different tooling.

Evaluation frameworks are also starting to sit alongside governance infrastructure and agent registries — not as optional debugging tools but as production controls. Solo.io contributing agentregistry to CNCF on the same day as the agentevals launch reflects this: the enterprise agent stack now has a discovery layer (registries), a trust layer (evaluation), and increasingly, a governance layer (policy enforcement). Each is emerging as a distinct infrastructure component, not a feature of a single platform.

The part observability doesn't reach

Here's where the observability narrative has a gap most vendors aren't addressing directly.

A large share of agent failures in enterprise deployments don't come from model quality, tool selection bugs, or trajectory errors. They come from the knowledge the agent reads.

Enterprises deploy agents to answer questions, route decisions, draft content, and take actions — often using internal documents, policies, SOPs, product manuals, or compliance materials as their primary context. The agent queries a knowledge base. It retrieves what looks like the right document. It generates a confident answer. And nobody notices that the document it retrieved was outdated, or conflicted with another policy in the same system, or was scoped to the wrong team, or simply wasn't the most recent version.

Instrumentation tells you what the agent did. It doesn't tell you whether the document it retrieved was trustworthy.

This is why enterprises that deploy AI agents on document-heavy knowledge bases are discovering that agent evaluation and retrieval evaluation need to happen together. As we've written previously, you can't stress-test an enterprise agent built on ungoverned knowledge — no eval framework will compensate for a knowledge base that's drifting, contradicting itself, or pulling from stale sources. And the agentic AI failure rate driven by document and knowledge chaos is a production problem most teams haven't started measuring yet.

What enterprises should actually measure

If you're standing up agent evaluation in a production environment, the measurement set needs to go beyond tool choice and output quality. Specifically:

Task completion quality — Did the agent complete the intended task? Not just return output, but accomplish the goal?

Tool choice correctness — Did the agent select the right tools in the right sequence? Wrong tools can complete steps while corrupting the overall workflow.

Retrieval relevance — Did the retrieved documents actually match the query intent? A high-confidence retrieval of the wrong document is worse than no retrieval.

Source freshness — When was the retrieved document last updated? Is it current relative to when the policy, product, or process it describes was last changed?

Contradiction rate — Do retrieved documents conflict with each other? An agent reconciling contradictory sources is making editorial decisions it probably shouldn't be making.

Permission compliance — Was the retrieved content appropriate for the requesting user's access level? This becomes a governance and audit issue fast.

Behavioral drift over time — Does agent behavior change after model updates, prompt changes, or knowledge base updates? Drift without detection is how silent regressions happen.

Most of these can't be measured at runtime without also measuring the quality of the knowledge layer feeding the agent. Enterprise agent platforms are consolidating, and the knowledge layer is increasingly where the measurement gaps are showing up — not the orchestration or execution layers that most eval tools are focused on.

At Mojar AI, the architecture that matters for this problem is upstream: source attribution on every retrieved chunk, contradiction detection across the knowledge base, freshness tracking, and permission-aware retrieval scoping. That's not a replacement for agent evaluation tooling — it's what makes agent evaluation results trustworthy. If you can't vouch for what the agent read, you can't fully interpret what the agent did.

What to watch

Agent evaluation is early but hardening fast. The agentevals launch at KubeCon is a signal that cloud native infrastructure teams are taking this seriously, not just AI application teams. Expect evaluation to become a standard part of the agent deployment checklist in the same way security scanning became standard for container deployments.

The more interesting question over the next 12-18 months is whether retrieval quality metrics get folded into agent eval frameworks natively, or whether enterprises have to instrument that layer separately. Right now, it's the latter — which means most production agent deployments are flying partially blind. That's a solvable problem, but only if teams are asking the right measurement questions from the start.

The bar has moved. It's no longer enough to ship an agent that runs. The question is whether you can demonstrate it's behaving correctly — and that demonstration has to include what the agent knew, not just what it did.