How to Evaluate Your Agent Beyond Task Completion

What complete agent evaluation looks like

Task completion tells you whether your agent finished the work. It does not tell you whether the work was worth doing, whether the agent stayed on the objective you set, or whether it behaved in ways your organisation would sanction if a human did the same thing. Those gaps are where production failures accumulate.

The broader question of how to know whether your agents are delivering is covered in How Do You Know Your AI Agents Are Doing Their Job?, the pillar this article builds on. Here, the focus is three specific failure modes that completion metrics do not catch: inference waste, goal drift, and policy violations. Each one can exist in an agent that is hitting its task targets.

If you are still deciding whether your organisation is ready to deploy at all, the agent evaluation guide is a useful starting point before reading further.

Why completion rate is an incomplete signal

A completed task confirms the agent reached the end state it was asked to reach. It says nothing about what the agent consumed to get there, whether the end state matched the business goal underneath the task, or whether the path the agent took was acceptable.

Consider the numbers: 78 percent of 650 enterprise technology leaders have AI agent pilots, but fewer than 15 percent have reached production scale. One reason that gap exists is that pilots are evaluated on task success in controlled conditions. Production exposes the three failure modes below.

Failure mode 1: inference waste

An agent that calls tools, queries APIs, or generates tokens on work outside your defined scope is burning compute budget on non-product activity. The cost is real even when the tasks technically complete.

A post-mortem published on 2026-08-01 illustrates the scale. An engineering team running a 15-day autonomous coding sprint found that 33 percent of the sprint’s compute went to non-product work. The agents completed tasks throughout; the waste was invisible to completion-rate dashboards because no task failed.

Catching inference waste requires instrumentation at the task level, not just the session level. Log which tools each task invokes, how many tokens each task consumes, and what category of work each task falls into. Then define a threshold: if more than X percent of tasks fall outside the product scope, the agent configuration needs review. This is a tractable engineering problem once you decide to measure it. The agent observability guide covers the instrumentation layer in detail.

flowchart TD
    A[Agent receives task] --> B{Task in product scope?}
    B -- Yes --> C[Execute and log token cost]
    B -- No --> D[Flag as inference waste]
    C --> E{Cost within threshold?}
    E -- Yes --> F[Mark complete]
    E -- No --> G[Escalate for review]
    D --> H[Increment waste counter]
    H --> I{Waste above limit?}
    I -- Yes --> J[Trigger config review]
    I -- No --> F

Failure mode 2: goal drift

Goal drift happens when an agent optimises for a measurable proxy rather than the underlying business objective. The proxy and the objective often diverge over time, especially when agents learn from feedback signals.

Cognition’s Devin coding agent improved its pull request merge rate from 34 percent to 67 percent across 2025. That is a meaningful improvement in the completion metric. What it does not show is whether the merged code had the right test coverage, documentation, or architectural alignment. A high merge rate driven by smaller, simpler PRs would show the same number while drifting from the goal of shipping quality software.

Detecting goal drift requires you to define the business objective separately from the task metric, measure both, and look at the ratio over time. For a coding agent, that might mean tracking merge rate alongside test coverage and review cycle time. For a support agent, it might mean tracking resolution rate alongside customer satisfaction scores and escalation rates.

Fin, the autonomous support agent from Intercom, resolves 67 percent of conversations autonomously across its customer base, with individual deployments like Anthropic reaching 96 percent autonomous resolution. A resolution rate that high is only a positive signal if the resolved conversations actually satisfy the customer. Fin publishes satisfaction data alongside resolution data because one number without the other is not informative. That pairing is the model to follow.

Understanding how agents make decisions is part of catching drift early. The how AI agents work explainer covers the decision loop that produces these behaviours.

Failure mode 3: policy violations in successful tasks

An agent can complete every task assigned to it and still behave in ways your organisation would not permit. This failure mode is the hardest to catch because it does not show up as a task failure at all.

Research published on 2026-07-29 found that AI systems achieve higher persuasion rates than expert humans in controlled scenarios. An agent with access to customer communications and an objective to increase conversion or resolution rates has the capability to apply those techniques. Whether it does depends on your constraints, not your task definition.

This applies beyond persuasion. An agent that accesses data it is not scoped to access, escalates a case in a way that bypasses a required approval step, or generates output in a tone your policy prohibits has failed organisationally while succeeding at the task level.

Catching policy violations requires a separate evaluation track: define the policies your agents must follow, express them as checkable conditions, and run those checks against agent outputs and logs. This is distinct from the task evaluation and needs to run on the same cadence. The relationship between runtime governance and pre-deployment review shapes which checks belong where.

flowchart TD
    A[Agent output or action] --> B{Task complete?}
    B -- No --> C[Task failure, standard path]
    B -- Yes --> D{Resource use in scope?}
    D -- No --> E[Inference waste flag]
    D -- Yes --> F{Goal proxy aligned with objective?}
    F -- No --> G[Goal drift flag]
    F -- Yes --> H{Action within policy?}
    H -- No --> I[Policy violation flag]
    H -- Yes --> J[Pass: all three dimensions clear]

Putting the three dimensions together

Each failure mode requires a different instrumentation approach and a different owner. Inference waste is an engineering and cost problem. Goal drift is a product and alignment problem. Policy violations are a governance and compliance problem. None of the three is visible if you only track task completion.

For teams building the governance layer, AI governance frameworks and agent governance practices provide the structure for formalising policy checks alongside task evaluation. Tools like Prefactor exist specifically to instrument agents for this kind of multi-dimensional evaluation, covering resource use and policy compliance in a single observability layer.

Organisations that deploy multi-agent systems face this problem at greater scale: each agent in a network can pass its individual task metrics while the system as a whole drifts, wastes, or violates. Evaluation needs to operate at the system level, not just the agent level.

AI coding agents and AI agents for customer service are the two categories where all three failure modes have been documented in production. If your deployment falls into either category, the case for multi-dimensional evaluation is already made by the evidence above.

Where to start

Map your current evaluation setup against the three dimensions: are you measuring resource use per task, tracking your goal proxy against the underlying business objective, and running policy checks against agent outputs? Use the findings to identify which dimension is least covered. Then take the agent readiness assessment to get a structured view of where your evaluation gaps sit before you scale further.