Teaching evaluation to tell right from finished

Unverifiable answers

Nothing confirmed whether the agent's answer was correct or complete, only that it finished.

Invisible trajectory

No out of the box way to check whether tools ran in the right order, with the right inputs, or in the fewest steps.

Manual log archaeology

Spotting redundant or unnecessary steps meant opening logs record by record. It did not scale past a handful of cases.

Early iteration

Teams can assess execution health, tool usage patterns, latency and failure modes without blocking on ground truth readiness.

Execution behaviour

Task completion, tool invocation, retries and errors describe reliability even when correctness cannot yet be judged.

Regression detection

Reference free metrics apply broadly across executions, so they can monitor trends and surface systemic issues at scale.

Jobs to be done

• Verify that the agent's output is correct and complete, not just finished.
• Check that tools were executed with the right inputs, in the right order.
• See exactly where the agent diverges from expected behaviour.
• Do all of this without reading execution logs one record at a time.
• Iterate on the agent repeatedly without re-authoring ground truth each time.

Constraints I designed against

• Ground truth for agentic execution is structurally complex: an ideal sequence of tool calls, intermediate decisions and expected outputs across a multi step workflow.
• The journey spans AI Agent Studio, Skill Kit and Data Kit, with a live handoff between the last two.
• It must work with both existing execution logs and AutoChat generated runs.
• It must be cold start safe, producing valid ground truth when no execution history exists.
• It must never encode failed or suboptimal runs as expected behaviour.

Manual curation

Strengths

• Captures nuanced human judgement, essential for subjective qualities such as tone and empathy.
• High accuracy for high stakes edge cases.

Costs

• Slow, expensive, poorly scalable, and exposed to human bias.

Automated curation

Strengths

• Rapid generation, at volume and with variety.

Costs

• Bias toward the generating model, needing rigorous fidelity and utility checks.
• No visibility into how well the automated method is actually performing.

Select the agent

Choose the agent or agentic workflow to evaluate, and its version.

Select the records

Pick execution logs, or a source table and records for cold start cases.

Autocurate

The ground truth agent generates expected outcomes for every selected record.

Review and save

The user reviews, edits and verifies. This step cannot be skipped.

What broke

• Orientation collapsed at the seams. Navigation elements and breadcrumbs changed between screens, so each step felt like arriving at a new destination rather than progressing through one flow.
• The primary action moved. On one screen the forward action sat at the top, on the next at the bottom. Reviewers described hunting for it.
• An empty state read as an error. The user had not done anything yet, so this was part of the process, not a failure.
• Selectable units did not look selectable. The expected outcome description, expected tool outputs and expected record field updates prompted a direct question: is this an existing component pattern in our interfaces?
• System generated names were cryptic. Ground truth records arrived with identifiers no practitioner would recognise later.

What got reframed

• This is not setup. Ground truth curation is an ongoing task the practitioner returns to, not a one time configuration step, which changes both where it should live and how it should be entered.
• It has to fit the unified setup effort. The work needs to align with the broader push to unify how builders are set up, and a tab based handoff undercuts unified navigation.
• Why is this not in AI Agent Studio? A recurring question that pushed the roadmap toward a single studio experience rather than a Skill Kit to Data Kit round trip.
• Test before asking customers to tell us. Rather than waiting for usability sessions to surface known issues, run a heuristic evaluation first and fix what we can already see.
• Product naming needs updating. The Now Assist name is being retired and this surface has to follow.

Rewrote the empty state to name the next action instead of reporting a problem. Made the ground truth aspect units visibly interactive. Replaced cryptic identifiers with pre-filled, editable templated names.

Held navigation, breadcrumb and primary action position constant across all three steps, so the flow reads as one place with a progress indicator rather than a sequence of destinations.

Ran a heuristic evaluation with the team ahead of usability testing, then took the flow to internal customers who were already struggling with agent evaluation.

Principle 01

Autogenerate, never auto-trust

Generation is assistive. Verification is human and mandatory, because a bad score usually means bad ground truth rather than a bad agent.

Principle 02

One destination, not three

Navigation, breadcrumb and primary action hold position across every step. A step change should never feel like a product change.

Principle 03

Empty is not broken

A state the user has not reached yet gets an empty state that names the next action. Errors are reserved for actual errors.

Principle 04

Name things the way a person would

Pre-filled, editable, human readable names over system generated identifiers, because these datasets get found again months later.

Principle 05

Show the seam between machine and human

Autogenerated and verified are tracked as separate progress, so the user always knows what still needs their judgement.

Principle 06

Make ground truth arguable

Every record carries its provenance, so a surprising metric score can be traced back to how its reference was made.

Tool choice accuracy

Whether the agent selected the tools the ideal path calls for.

Tool input correctness

Whether those tools were invoked with the right inputs.

Output alignment

Whether the final output matches the expected outcome, semantically or exactly.

Goal attainment

Whether the agent achieved the outcome the use case was defined around.

Field matcher skill

Verifies a value on the record, either exactly or by semantic similarity. This is what turns priority equals High into a scored assertion.

Execution output matcher skill

Verifies output from the agent execution itself, exact or semantic, so a multi step resolution plan can be evaluated as meaning rather than as a rigid string.

Does ground truth need version support?

Versioning enables rollback from bad edits and improves auditing and trust. It also adds storage complexity and another layer in the interface. For an artefact authored once and reused, the case is not obvious.

Where should curation live?

Hosting in Data Kit centralises dataset management and reuses existing data workflows. Hosting inside the evaluation module reduces navigation friction. The leadership review pushed hard toward the second, and toward a single studio.

Should ground truth scores feed the optimisation pipeline?

These metrics compare execution against a reference, so the justification may be too thin to infer a suggested fix. Feeding weak signal into an insight pipeline risks producing confident, useless recommendations.

How do we keep generated runs predictable?

Ground truth comparison assumes a predictable execution path. Without enough context per record, an AutoChat run can take an unintended route, producing a misleading score against a perfectly good reference.

Does conversational ground truth fit this architecture?

Conversational evaluation has its own notion of expected outcome. Whether the two can share a model, or need to stay separate, is unresolved.

Can production become the authoring surface?

Admins already judge agent output while running agents in production. If that judgement could be captured in place, ground truth would stop being a separate authoring task and become a by-product of real work.

The hard part was not the payload

I expected the design problem to be representing a complex JSON structure. It turned out to be sequencing, naming and orientation. The structure became manageable once the flow stopped disorienting people.

Trust is a UI problem too

Ground truth exists to make evaluation trustworthy, which means the interface has to expose how each reference was made. Provenance is not a power user feature here. It is the point.

Heuristic evaluation earns its keep

The sharpest feedback we got was that we should have caught these issues ourselves. Running a structured heuristic pass before customer sessions now happens by default, not on request.