You've set up your AI agent. You've built the knowledge base, wired up the tools, and established feedback loops. But there's a question that keeps you up at night: Can I trust it?

Trust is the fundamental currency of AI agent adoption. Without it, you micromanage — double-checking every output, redoing work the agent already did, defeating the entire purpose of having an assistant in the first place. With it, your agent becomes a genuine force multiplier, handling work autonomously while you focus on higher-value decisions.

The problem is that trust is usually a feeling, not a measurement. "I feel like the agent is getting better" tells you nothing useful. What you need is a Trust Score — a quantitative framework that turns vibes into numbers and gives you a clear path from "I'm not sure" to "I trust this agent with my calendar, my inbox, and my customers."

The Four Metrics of Agent Trust

After working with dozens of small business owners building AI agents, we've settled on four metrics that capture the full trust picture. Each one measures a different failure mode, and together they give you a single score you can track over time.

1. Accuracy Rate (AR)

What it measures: How often does the agent get the answer right on the first try?

Accuracy is the most intuitive metric, but it's also the easiest to misinterpret. An agent that answers "I don't know" to everything has perfect accuracy — it never makes a mistake because it never attempts anything. Real accuracy measures correct autonomous executions divided by total autonomous attempts, with explicit "I don't know" responses treated as neutral (they don't help, but they don't hurt either).

To measure it: review your agent's action log at the end of each day. Mark each task as correct, incorrect, or declined (agent passed or requested guidance). Your accuracy rate is: correct / (correct + incorrect).

Baseline target: 85% for general assistance tasks. 95%+ for structured operational tasks like scheduling or data entry.

2. Correction Frequency (CF)

What it measures: How often do you need to intervene and tell the agent it was wrong?

Accuracy measures the things you catch. Correction frequency measures how often the agent makes mistakes noticeable enough to warrant a correction. These are different numbers because most small errors go unnoticed — until they compound. A high correction frequency means the agent is making visible mistakes regularly, which erodes trust fast.

To measure it: count the number of explicit corrections you give the agent per week. A correction is any time you say "that's wrong," "fix this," or "no, that's not what I meant." Divide by total tasks completed that week.

Baseline target: Fewer than 1 correction per 20 tasks (5% correction rate). At more than 1 per 10 tasks, you have a trust problem that won't fix itself.

3. Task Completion Rate (TCR)

What it measures: When you delegate a task, does the agent actually finish it?

This is the trust metric that matters most for autonomous delegation. An agent that starts tasks brilliantly but never finishes them is worse than an agent that declines tasks it can't handle — because the unfinished task falls through the cracks, and you only discover it when it's too late.

To measure it: for every delegated task with a clear completion condition (email sent, calendar event created, report generated), track whether the agent reached that completion condition within a reasonable timeframe without follow-up.

Baseline target: 90% completion rate for routine tasks. Lower for novel or ambiguous tasks, which is fine — the agent should be flagging those for human input, not attempting them autonomously and failing.

4. Response Relevance (RR)

What it measures: How often does the agent stay in its lane?

This is the boundary metric. An agent with perfect accuracy on-topic but constant drift into off-topic behavior is still untrustworthy. Relevance measures whether the agent's outputs are appropriate to its role, its access level, and the specific task at hand.

To measure it: sample 20 interactions per week and categorize them as on-task, off-task-but-harmless (agent ventured into a related area without causing problems), and off-task-and-concerning (agent made decisions outside its authority, accessed information it shouldn't have, or took actions that needed human approval).

Baseline target: 0 concerning off-task behaviors per week. Occasional harmless drift is acceptable, but any concerning behavior means your identity and boundaries layer needs reinforcement (see our Agent Engineering guide for the framework).

Calculating Your Trust Score

Once you have your four metrics, calculate a composite Trust Score on a 0–100 scale:

Trust Score = (AR × 0.35) + ((1 - CF) × 0.25) + (TCR × 0.25) + (RR × 0.15)

Where:
  AR  = Accuracy Rate (as a decimal, e.g. 0.92)
  CF  = Correction Frequency (corrections / total tasks)
  TCR = Task Completion Rate (as a decimal)
  RR  = On-Task Rate (on-task interactions / total sampled)

Weighting rationale:
  Accuracy gets the most weight — it's the foundation.
  Correction Frequency and Task Completion are tied — one measures mistakes,
  the other measures reliability.
  Response Relevance gets the least weight because concerning events should
  be a hard zero (they trigger immediate architectural fixes, not scoring).

Here's what the scores mean:

  • 90–100: Fully autonomous. You can trust the agent with most routine tasks without review. Weekly check-ins suffice.
  • 75–90: Mostly reliable. The agent handles the basics well, but you should spot-check complex outputs and maintain daily log reviews.
  • 50–75: Needs supervision. The agent is helpful for simple tasks but requires active monitoring for anything important.
  • Below 50: Not ready for autonomous work. Focus on fixing the weakest metric before delegating anything critical.

How to Improve Each Metric

The beauty of a quantitative framework is that it tells you exactly where to focus. Here's the playbook for each metric:

Improving Accuracy Rate

Accuracy problems are almost always knowledge problems. If your agent is getting things wrong, it probably doesn't have the right information in the right format. Revisit your knowledge base architecture — is the information complete? Is it structured for retrieval? Are there gaps where the agent is guessing instead of looking up? The knowledge base guide covers this in detail.

If the knowledge base is solid but accuracy is still low, the next suspect is context overload. Your agent's prompt may be too long, burying critical instructions under less important ones. Run a context audit: remove everything that isn't directly relevant to the agent's core responsibilities.

Reducing Correction Frequency

Corrections happen when the agent does something wrong in a way that's noticeable and meaningful. This is usually a boundaries problem — the agent is operating outside its core competence. Review every correction from the past two weeks. If three or more fall into the same category, document that category explicitly in the agent's identity and boundaries instructions.

For example, if you're constantly correcting the agent for offer pricing without approval: add a boundary rule that says "You may never communicate pricing, discounts, or offers to customers without explicit approval. Always respond with: 'I need to check with my team on pricing — I'll get back to you within 2 hours.'"

Each correction should result in a new boundary or a knowledge base update. If it doesn't, you're stuck in correction loop — and your correction frequency will never improve.

Boosting Task Completion Rate

Incomplete tasks most often stem from one of two causes: the agent gets stuck midway (tool failure, ambiguous instructions, missing permissions) or the agent silently drops the task (context limits, priority confusion, or user interruption).

The fix for stuck tasks is better error handling. Your agent should have a "can't complete" workflow: if a task fails, log the failure, notify you with the error, and suggest a workaround. Never let the agent respond with "I'll take care of that" and then go silent.

The fix for dropped tasks is task tracking. Give your agent a structured task list that persists across conversations. If you say "schedule a meeting with Sarah next Tuesday," the agent should write that as a pending task, execute it, and mark it complete. If it gets interrupted mid-process, the pending task remains visible in the next conversation.

Controlling Response Relevance

Response relevance is the hardest metric to improve because it's the most architectural. If your agent is consistently operating outside its bounds, you need to tighten the identity and boundaries layer — not add more prompt instructions. A single clear boundary ("You handle scheduling and nothing else") is more effective than twenty scattered disclaimers.

If the agent is accessing information it shouldn't, revisit your knowledge isolation. Separate knowledge stores per role can't be bypassed by creative prompting. If the agent is taking actions it shouldn't, review your tool permissions — the agent can't misuse a tool it doesn't have access to.

The Weekly Trust Review

Here's a 10-minute weekly ritual that keeps your Trust Score trending up:

  1. Pull the numbers (2 min): Calculate your four metrics from the week's logs and corrections. Update a simple spreadsheet or document.
  2. Identify the weakest metric (1 min): Which one dropped or stayed flat? That's this week's improvement target.
  3. Apply one fix (5 min): Use the playbook above to make one concrete change targeting the weakest metric.
  4. Review concerning events (2 min): If there were any off-task-concerning behaviors (RR metric drop), investigate root cause and fix the architecture — not just the prompt.

Do this ritual every week. After four weeks, you'll see the pattern: your weakest metric improves, the composite score trends upward, and the gap between "I think the agent is doing okay" and "I know exactly how the agent is performing" becomes unbridgeable.

Trust Is a Process, Not a Destination

The goal isn't to hit 100 and stop measuring. Agents evolve — new tools get added, business rules change, the agent's training data shifts. A Trust Score that plateaus is a Trust Score that's about to drop. The weekly review isn't a chore; it's the mechanism that keeps your agent compounding in value instead of quietly degrading.

Start measuring today. Even if your score starts low (and it probably will — most agents start in the 50–65 range), the act of measuring turns trust from a vague anxiety into a tractable engineering problem. And tractable engineering problems have solutions.

Six months from now, you won't remember the five minutes it took to calculate your first Trust Score. But you'll definitely remember the month your agent crossed 90 — because that's when it stopped being something you managed and started being something you relied on.

This post is part of our practical agent series. For the measurement foundation, start with the Agent Engineering framework and set up your weekly audit cadence. For the improvement pipeline, the Feedback Loop guide tells you how to turn corrections into compounding improvements.