Evaluating AI agents with domain experts

AI agents fail across whole workflows, not single answers, so testing them means scoring the full trajectory with people who actually do the work. A chatbot gives one answer you can grade. An agent plans, calls tools, reads results, revises, and acts across many steps, and two agents can land on the same final answer while one took a safe, efficient path and the other made a reckless move that happened to work. Only a domain expert who knows what a correct workflow looks like can tell those two apart, which is why evaluating real-world agents is a job for verified practitioners.

This guide is a practical playbook for testing multi-step agents: why trajectory testing is different, the failure modes you are actually hunting, how to build a trajectory rubric, and how to run an expert evaluation that produces reusable results. It reflects an offering on the CleverX Expert AI service and is written for teams building and shipping agents that do specialized work. For the broader sourcing view, see our companion guide on data for AI agents and sourcing experts for agent evaluation; this piece focuses on the testing workflow itself. It is not professional advice in any specialized field.

Why agent testing is a different problem

A single-output evaluation asks one question: is this answer good? Agent evaluation asks a harder one: was the whole process good? That shift matters because an agent’s final answer hides almost everything about how it got there. An agent can produce a correct summary after silently dropping a critical input, or close a task after a tool call that would be catastrophic on the next input. The output looks fine. The behavior is not.

Research benchmarks show the shape of the problem. SWE-bench tests whether an agent can resolve real software issues end to end, tau-bench evaluates agents on realistic tool-use tasks in customer-facing domains, and WebArena measures agents acting in realistic web environments. What they share is a definition of success tied to completing a real workflow rather than producing plausible text. To build the same rigor inside your own domain, you need testing that inspects the workflow, and the standard for that workflow has to come from someone who performs it. This extends the single-output logic in our guide to model evaluation data and hiring experts to grade AI outputs from one answer to a sequence of actions.

The failure modes you are actually testing for

Agent testing is the discipline of finding failures that a final-answer test cannot see. In practice they cluster into a handful of patterns.

Failure mode	What it looks like	Why a final-answer test misses it
Right answer, unsafe path	The agent reaches a correct result through a step that is dangerous or non-compliant	The result is correct, so the output passes
Lucky tool call	A tool is called with wrong arguments but succeeds on this input	It happens to work this time, so nothing flags
Silent data loss	The agent drops a field or record during a multi-step process	The final output still looks complete
Compounding error	A small early mistake grows into a large final error	Only the end state is scored, not the drift
Overconfident recovery	The agent hides that a step failed and presses on	The confident final answer masks the break

Each of these is a process failure, and process failures are exactly what domain experts are trained to catch. A pharmacist reviewing a discharge-summary agent can see that it dropped an anticoagulant during medication reconciliation even though the final summary reads perfectly. A financial analyst can see that a research agent pulled the right number from the wrong period. A lawyer can see that a review agent flagged a clause using reasoning that would not hold in the relevant jurisdiction. The error reads fine to a generalist and is obvious to a practitioner, which is the entire argument for expert testing.

Build on end-to-end demonstrations first

You cannot score a trajectory against a standard you have not defined, so expert agent testing starts with demonstrations. An end-to-end demonstration is a step-by-step record of an expert completing the full task the way an agent would need to: the sub-goals, the tools and data sources used, the decisions made at each branch, and the reasoning behind them. A demonstration of an analyst building a model shows which sources they pulled, which assumptions they set and why, how they sanity-checked the output, and where they stopped.

Demonstrations do double duty. They are training data, and they are the reference a grader uses to judge an agent’s own run. A grader with a clear picture of the ideal trajectory can say precisely where the agent diverged and whether the divergence mattered, instead of guessing from a failed final answer. This is why the written reasoning in a demonstration is where much of the engineering value sits.

How to build a trajectory rubric

The rubric is what turns expert judgment into a consistent, reusable measurement. A trajectory rubric scores the whole run, not the final answer, and a good one covers five dimensions:

• Outcome correctness. Did the agent reach the right result for the task?
• Process soundness. Was the path professionally defensible, or did it rely on steps a practitioner would reject?
• Tool-use accuracy. Were tools called with correct arguments, and were results interpreted correctly?
• Efficiency. Did the agent reach the outcome without wasteful or risky detours?
• Safety and compliance. Did every step stay inside the rules the domain requires?

Each dimension needs written criteria so that two reviewers looking at the same run reach the same verdict. That is the difference between a rubric and an opinion. Our guide to evaluation rubrics for AI models covers the craft of writing criteria that hold up, and for the benchmark side, domain expert benchmarks for AI evaluation and how to build them explains how to assemble the real tasks you will score against.

The expert agent testing workflow

Running an expert evaluation follows a clear sequence, and each step exists to make the results trustworthy and reusable.

1. Define the task and success criteria. State the workflow the agent must complete and what counts as success for both the outcome and the acceptable process. Ambiguity here poisons every score downstream.
2. Recruit verified experts in the right specialty. Match the practitioner to the workflow, and confirm credentials before anyone produces or grades anything.
3. Collect ideal demonstrations. Have experts record end-to-end trajectories for a representative set of tasks to anchor both training and grading.
4. Build the trajectory rubric. Turn professional standards into the five scored dimensions with written criteria.
5. Assemble benchmark tasks from real work. Draw problems from experts’ actual practice so the test reflects the job the agent will really do, including the messy inputs and conflicting constraints that invented tests smooth away.
6. Score runs and calibrate reviewers. Have experts grade agent trajectories against the rubric, calibrate several reviewers on shared runs, and measure agreement so scores are consistent rather than personal.
7. Feed training, guardrails, and the rubric. Route results into fine-tuning and reinforcement learning, tighten safety constraints, and update the rubric as new failure modes appear.

Step six is where a lot of programs cut corners and pay for it later. If reviewers are not calibrated, a passing score means one thing to one grader and something else to another, and the whole evaluation loses meaning. Measuring inter-rater agreement on shared runs is the cheapest way to know your scores are real. When you are ready to buy this expert time at scale rather than assemble it ad hoc, our guide to how AI labs buy expert data covers procurement, pricing, and quality control.

From testing to training

Expert testing is not only a gate at the end of the pipeline. The judgments it produces feed back into the model. The preferences experts express when they rank one trajectory over another become a training signal through reinforcement learning from human feedback, the same mechanism explained in our overview of how RLHF works, applied to sequences of actions rather than single responses. Over successive versions, the rubric and benchmark set become a regression suite that catches when a new model quietly gets worse at a workflow it used to handle.

This closed loop is also what makes a safety claim about an agent defensible. Standards bodies are converging on the same expectation: the NIST AI Risk Management Framework and the transparency obligations in the EU AI Act emphasize documented, role-appropriate evidence of how a system behaves. For an agent, that means evidence about its whole workflow, produced by people qualified to assess it. OpenAI’s own practices for governing agentic AI systems make a similar point about keeping humans able to inspect and intervene in agent behavior.

Why verification is load-bearing

If a benchmark or a safety claim about your agent rests on expert judgment, you have to be able to show who those experts were and why they were qualified. Self-reported resumes do not survive that scrutiny, especially in regulated domains. CleverX verifies experts through four layers: government ID, professional licence or credential confirmation, LinkedIn experience matching, and recorded expert interviews that test whether the person can actually reason through the work rather than just hold a title. The credibility of your evaluation is only as strong as the credibility of the people who produced it.

The same logic governs the broader trust story for vertical systems, which we cover in why vertical AI needs expert data to be trustworthy. Agent testing is one of the most demanding places that argument shows up, because the thing being judged is a process, and process judgment is the hardest kind to fake.

Where CleverX fits

CleverX is an on-demand platform that connects AI teams with verified, practising professionals across fields and geographies, drawn from more than 10 million verified participants. On the platform, experts record end-to-end demonstrations, define trajectory rubrics, supply benchmark tasks from real work, and score agent runs with written rationales, across finance and accounting, healthcare, law, engineering and manufacturing, insurance, and operations. Because every expert is verified, the people testing your agent are practitioners, not anonymous workers, and the results hold up to customer and regulatory scrutiny.

Models know a lot. What they lack is judgment, and for agents that gap shows up as workflows that look right and go wrong. Expert testing of the whole trajectory is how you find those failures before your users do, and how you prove the agent’s process, not just its answer, meets a professional standard.

Frequently asked questions

Why do you need domain experts to evaluate AI agents?

“Because an agent completes a professional workflow, and only someone who performs that workflow can judge whether the path it took was sound, not just whether the final answer looks right. A crowd worker can tell you an output reads well. A practitioner can tell you the agent reconciled the wrong account, skipped a required check, or cited an authority that does not apply. Agent evaluation is a judgment about process, and process judgment in a specialized field has to come from an expert in that field.”

How is evaluating an agent different from testing a single model output?

“A single-output test scores one answer. Agent evaluation scores a trajectory, meaning the full sequence of steps, tool calls, and decisions the agent made to finish a task. Two agents can reach the same final answer while one took a safe, efficient path and the other made a reckless move that happened to work, and only trajectory-level testing tells them apart. That is why agent evaluation measures outcome correctness, process soundness, tool-use accuracy, efficiency, and safety rather than a single score.”

What is a trajectory rubric?

“A trajectory rubric is a scoring guide that turns professional standards into measurable dimensions for an agent’s whole run rather than its final answer. It typically covers outcome correctness, process soundness, tool-use accuracy, efficiency, and safety, with written criteria for each so different reviewers reach the same verdict. Experts build it from how their field actually judges good work, and it is what makes agent scores consistent and reusable across versions.”

What are the main failure modes of AI agents in real workflows?

“The common ones are a right answer reached through an unsafe path, a wrong tool call that happens to succeed on this input, silent data loss during a multi-step process, compounding errors where a small early mistake grows, and overconfident recovery where the agent hides that something went wrong. All of these are invisible to a final-answer test and only surface when an expert inspects the trajectory step by step.”

How do you set up an expert agent evaluation?

“Define the task and what counts as success for both outcome and process, recruit verified experts in the right specialty, collect ideal end-to-end demonstrations, build a trajectory rubric, assemble benchmark tasks from real work, then have experts score agent runs against the rubric and calibrate several reviewers on shared runs. Feed the scored results into training, guardrails, and the rubric itself as new failure modes appear.”

How does CleverX help test AI agents?

“CleverX connects AI teams with verified, practising professionals who produce end-to-end demonstrations, define trajectory rubrics, supply benchmark tasks from real work, and score agent runs with written rationales. Experts are verified through government ID, licence confirmation, LinkedIn matching, and recorded interviews, drawn from more than 10 million verified participants, with delivery on demand across finance, healthcare, law, engineering, insurance, and operations.”

Agents fail on process, and process is what only a practitioner can judge. Train your AI with verified experts on CleverX