Evals-as-indexes make agent trace search practical at production scale

At a glance

What this is: NHI Mgmt Group's analysis, drawing on Judgment Labs's blog post: Evals-as-indexes let teams search agent traces by behaviour instead of brittle keywords, making production investigations faster and more reliable.

Why it matters: This matters because agent telemetry is becoming too large and too semantically rich for manual review, so governance now depends on searchable behavioural labels, not just raw logs.

Context

Production agent telemetry creates a governance problem before it creates a tooling problem: the same run can contain thousands of model calls, tool invocations and intermediate decisions, and the behaviour that matters is often buried in free-form text. When that evidence is spread across spans, keyword search can miss the pattern even when the failure is real.

The practical issue is not whether traces exist but whether teams can query them for meaningful state, such as user frustration, instruction following or failed recovery. In agentic AI programmes, telemetry has to function like an evidence layer, not just an archive, and that makes agentic AI identity and trace governance closely linked.

That starting position is increasingly typical for long-horizon agents and other systems that generate dense, multi-step interactions.

Key questions

Q: How do evals improve agent trace search?

A: Evals improve agent trace search by converting subjective behavior into structured labels that can be filtered like database columns. Instead of asking a model to rediscover the same pattern on every query, teams precompute judgments such as success, recovery or failure and then inspect the supporting traces behind those labels.

Q: Why does keyword search miss important agent failures?

A: Keyword search misses important agent failures because many failures are behavioural, not lexical. An agent can choose the wrong tool, act on stale context, overstep delegated authority, or mishandle a workflow without ever using the expected words. To catch those cases, use evals that score task completion, tool use, policy compliance, and failure modes from real traces, not just term matches.

Q: How should teams validate evals before using them as indexes?

A: Teams should validate evals as indexes by checking that the rubric actually retrieves the failures they care about across a labelled test set. That means measuring precision on known bad traces, recall for edge cases, and consistency between human reviewers and the eval output. Calibrate thresholds before operational use, because a weak rubric can surface irrelevant examples and miss privilege, tool-use, or data-handling failures.

Q: What is the difference between vector search and eval-based search?

A: Vector search retrieves similar text or embeddings by proximity in semantic space. Eval-based search retrieves examples by matching scored behaviours, outcomes, or failure patterns against a rubric, so it can find agent mistakes that look different on the surface but fail the same control, tool-use, or policy condition.

Technical breakdown

Why raw trace search breaks down at scale

Raw trace search fails because the signal is distributed across many spans and often expressed in natural language rather than fixed fields. A single user journey can include multiple model responses, tool calls, retries and corrections, so a search term may hit one fragment while missing the span that actually proves the outcome. Vector search helps with semantic similarity, but it still evaluates each question from scratch and cannot reliably encode a bespoke rubric such as whether a request was completed, partially completed or later recovered. The result is context rot, where the search process itself degrades as more irrelevant evidence accumulates. Read Investigating Agent-Initiated Data Exfiltration.

Practical implication: Design trace systems so the search layer can query structured behavioral labels, not only free text.

How evals become searchable columns

An eval is a structured judgement about a trace or span, such as whether the user was frustrated, the agent followed instructions, or the action succeeded. When those judgments are stored alongside telemetry as columns, they become filters rather than one-off assessments. That changes the search model: instead of asking the system to infer behavior from scratch every time, the evaluator precomputes the label once and the data agent reuses it across many queries. This is especially useful when multiple evals describe different dimensions of the same run, because the agent can combine them into a row-level decision and then inspect the supporting spans behind that decision.

Practical implication: Store eval outputs with trace and span identifiers so investigators can filter by behavior and inspect the evidence chain.

Why search quality depends on eval quality

Evals-as-indexes only work if the labels are dependable enough to guide retrieval. A noisy eval that over-fires creates false positives, while an under-firing eval hides the very behavior the team is trying to find. That means the index is only as trustworthy as the rubric behind it and the calibration of the judge that produces it. Teams should treat these evals like any other control data: validated against hand-labeled examples, monitored for drift, and reviewed when the agent’s task mix changes. Otherwise the search layer can look sophisticated while quietly returning incomplete or biased evidence.

Practical implication: Validate evals against hand-labeled traces before using them as an operational search index.

NHI Mgmt Group analysis

Evals are becoming the missing control plane for agent telemetry: raw traces alone are too unstructured to support dependable investigation at production scale. The important shift is not better keyword search but pre-classified evidence that can be filtered, audited and rechecked. For agentic programmes, that turns monitoring data into a governance asset rather than a forensic afterthought.

Trace search is now an evidence-quality problem, not a data-volume problem: the hard part is deciding which behavioral labels deserve to be indexed. If the rubric is vague, the search layer becomes noisy; if it is precise, the index can accelerate both troubleshooting and accountability. This is where operational observability starts to overlap with agent credential lifecycle thinking, because the same discipline of structured state and review applies.

Behavioural indexing will favour teams that define outcomes clearly: searches such as completed, failed, recovered or unresolved only work when those states are consistently judged across runs. That pushes organisations toward explicit evaluation policy, not ad hoc inspection. The practitioner implication is simple: if you cannot name the behaviour, you cannot reliably search for it.

Long-horizon agents create an auditability gap that traditional logs do not close: a trace may show every step, yet still fail to answer whether the overall task succeeded or whether a correction was ignored later. Evals-as-indexes narrow that gap by converting latent behavior into queryable state. Practitioners should treat this as an emerging requirement for agent governance, not just a data engineering convenience.

What this signals

Evals-as-indexes: the next governance step for agent telemetry is to make behavioural labels reusable across investigations, not just useful in monitoring. As agent fleets grow, teams will need a repeatable way to search for state, recovery and failure, not a fresh analysis for every incident.

That shifts programme design toward evaluation policy, trace schema design and evidence retention rather than only prompt tuning or dashboarding. Organisations that do not define searchable outcomes early will end up with logs they can store but not answer from.

The broader implication is that agent oversight will increasingly depend on structured judgement at ingest time. Once teams can query behaviour directly, the quality of the index becomes as important as the quality of the model.

For practitioners

• Define behavioral labels before production rollout Choose a small set of searchable outcomes such as completed, failed, recovered and unresolved, and make sure each one has a clear judging rubric before the agent goes live.
• Store eval results as first-class telemetry Write eval labels, reasons and supporting span IDs into the same system as traces so investigators can filter on behavior and then open the evidence behind each result.
• Calibrate judges against hand-labeled examples Test every eval against a small verified corpus and review false positives and false negatives before using the output as a search index.
• Use evals where raw traces are too large to inspect Apply the indexed search pattern to long-horizon agents and high-volume workflows where keyword search becomes brittle and manual review no longer scales.

Key takeaways

• Agent trace investigations become much more practical when teams reuse eval outputs as structured search filters rather than reading raw spans one by one.
• The hard part is not storing telemetry but defining reliable behavioral labels that consistently capture success, recovery and failure.
• Operational trust in agent search depends on eval calibration, because a noisy index can hide evidence as easily as it can reveal it.

Related NHI Mgmt Group resources: AI Agent Credential Lifecycle and Rotation Guide · Investigating Agent-Initiated Data Exfiltration · Agentic AI Identity Guide

Key terms

• Trace Telemetry: Trace telemetry is structured runtime data that records agent tool calls, inputs, outputs, and timing. For identity security, it becomes evidence of who or what touched a secret, which paths were accessed, and whether behaviour crossed an approved boundary.
• LLM-as-a-judge: A control pattern where one language model evaluates another model's prompts, tool calls, or outputs against policy. It is not content moderation alone. In practice, it acts as a runtime decision layer that can allow, block, redact, or escalate based on semantic context and organisational rules.
• Context rot: Context rot is the loss of investigative focus that happens when an incident agent or analyst is forced to reason across too many logs, traces, and dependencies at once. The result is overconfidence in the wrong clue, which makes approval boundaries and evidence scoping more important than raw model size.
• Semantic Search: A search approach that looks for meaning, not just exact keywords. It can match a user’s question to relevant assets even when the wording differs from the underlying metadata or title. For data discovery, semantic search helps users find datasets, terms, and documentation without knowing the exact label used in the platform.

Deepen your knowledge

NHI Foundation Level course, the industry's only accredited NHI security programme, covers NHI governance, agentic AI identity, and machine identity security. It is relevant for practitioners who need to connect identity controls to broader security operations and evidence handling.