> ## Documentation Index
> Fetch the complete documentation index at: https://docs.usefini.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Resolution vs deflection

> How Fini defines AI resolution rate and deflection rate, why the two differ by the Waiting for Customer share, and why Fini reports and bills on resolutions.

export const RateCalculator = ({resolved = 700, escalated = 200, waiting = 100}) => {
  const FV = {
    lime: "#C3EE5E",
    ink: "#131415",
    line: "rgba(127,127,127,0.28)",
    soft: "rgba(127,127,127,0.07)",
    softer: "rgba(127,127,127,0.04)",
    muted: "rgba(127,127,127,0.95)",
    pass: "#C3EE5E",
    warn: "#FFB020",
    fail: "#FF4D4D",
    radius: 14
  };
  const fvCard = {
    border: `1px solid ${FV.line}`,
    borderRadius: FV.radius,
    padding: 18,
    margin: "20px 0",
    background: FV.softer
  };
  const fvChip = active => ({
    border: `1px solid ${active ? FV.lime : FV.line}`,
    background: active ? FV.lime : "transparent",
    color: active ? FV.ink : "inherit",
    borderRadius: 999,
    padding: "6px 12px",
    fontSize: 13,
    fontWeight: 600,
    cursor: "pointer",
    lineHeight: 1.2
  });
  const fvBtn = primary => ({
    border: `1px solid ${primary ? FV.lime : FV.line}`,
    background: primary ? FV.lime : "transparent",
    color: primary ? FV.ink : "inherit",
    borderRadius: 10,
    padding: "7px 14px",
    fontSize: 13,
    fontWeight: 600,
    cursor: "pointer"
  });
  const fvLabel = {
    fontSize: 11,
    fontWeight: 700,
    letterSpacing: "0.08em",
    textTransform: "uppercase",
    opacity: 0.6,
    marginBottom: 8
  };
  const [r, setR] = useState(resolved);
  const [e, setE] = useState(escalated);
  const [w, setW] = useState(waiting);
  const total = Math.max(0, r) + Math.max(0, e) + Math.max(0, w);
  const pct = x => total ? Math.round(x / total * 1000) / 10 : 0;
  const res = pct(r), esc = pct(e), defl = total ? Math.round((100 - esc) * 10) / 10 : 0;
  const gap = Math.round((defl - res) * 10) / 10;
  const field = (label, v, set, color) => <label style={{
    display: "flex",
    flexDirection: "column",
    gap: 4,
    fontSize: 13,
    flex: "1 1 150px"
  }}>
      <span><span style={{
    display: "inline-block",
    width: 10,
    height: 10,
    borderRadius: 3,
    background: color,
    marginRight: 6
  }} />{label}</span>
      <input type="number" min="0" value={v} onChange={ev => set(Number(ev.target.value) || 0)} style={{
    border: `1px solid ${FV.line}`,
    borderRadius: 8,
    padding: "7px 10px",
    background: "transparent",
    color: "inherit",
    fontSize: 14
  }} />
    </label>;
  const bar = (label, value, color, sub) => <div style={{
    marginTop: 12
  }}>
      <div style={{
    display: "flex",
    justifyContent: "space-between",
    fontSize: 13.5
  }}><b>{label}</b><b>{value}%</b></div>
      <div style={{
    height: 10,
    borderRadius: 999,
    background: FV.soft,
    overflow: "hidden",
    marginTop: 5
  }}>
        <div style={{
    width: `${Math.min(100, value)}%`,
    height: "100%",
    background: color,
    transition: "width .35s"
  }} />
      </div>
      <div style={{
    fontSize: 12,
    opacity: 0.65,
    marginTop: 4
  }}>{sub}</div>
    </div>;
  return <div style={fvCard}>
      <div style={fvLabel}>Try it: same conversations, two metrics</div>
      <div style={{
    display: "flex",
    gap: 12,
    flexWrap: "wrap"
  }}>
        {field("Resolved by AI", r, setR, FV.pass)}
        {field("Escalated to Human Team", e, setE, FV.warn)}
        {field("Waiting for Customer", w, setW, "#6B6B6B")}
      </div>
      <div style={{
    display: "flex",
    height: 14,
    borderRadius: 999,
    overflow: "hidden",
    marginTop: 16,
    background: FV.soft
  }}>
        <div style={{
    width: `${res}%`,
    background: FV.pass,
    transition: "width .35s"
  }} />
        <div style={{
    width: `${pct(w)}%`,
    background: "#6B6B6B",
    transition: "width .35s"
  }} />
        <div style={{
    width: `${esc}%`,
    background: FV.warn,
    transition: "width .35s"
  }} />
      </div>
      {bar("AI resolution rate", res, FV.pass, "Counts only conversations with status Resolved by AI.")}
      {bar("Deflection rate", defl, "#6B6B6B", "100% minus Human escalation rate, so Waiting for Customer counts as deflected.")}
      {bar("Human escalation rate", esc, FV.warn, "Share of conversations escalated to a teammate.")}
      <div style={{
    marginTop: 14,
    fontSize: 13.5,
    padding: "10px 12px",
    borderRadius: 10,
    background: FV.soft
  }}>
        {total === 0 ? "Enter some numbers to compare." : gap > 0 ? <span>Deflection reads <b>{gap} points higher</b> than resolution because {w} waiting conversation{w === 1 ? "" : "s"} count as deflected but not as resolved.</span> : <span>With no conversations waiting on the customer, the two numbers match.</span>}
      </div>
    </div>;
};

In Fini (usefini.com), **AI resolution rate** counts only conversations with the status **Resolved by AI**, while **Deflection rate** is `100% - Human escalation rate` and therefore also counts conversations still **Waiting for Customer** as deflected. Fini treats resolution rate as the headline metric and prices on resolutions, because a deflected conversation is not necessarily a solved one.

Both metrics exist in the product and both are useful. This page gives the exact definitions, shows how far apart they can drift with a worked example, and explains when each one is the right number to look at.

## The exact definitions

Every conversation the agent handles ends in exactly one of three statuses, and the three sum to 100% of conversations in the selected window:

* **Resolved by AI**: the agent resolved the conversation without a human.
* **Escalated to Human Team**: the agent handed the conversation to a teammate.
* **Waiting for Customer**: the agent replied and is waiting on the customer.

| Metric | Definition in the product | Includes Waiting for Customer? |
| - | - | - |
| **AI resolution rate** | Share of conversations with status **Resolved by AI**. | No |
| **Human escalation rate** | Share of conversations with status **Escalated to Human Team**. | No |
| **Deflection rate** | `100% - Human escalation rate`. The share of conversations that did not escalate. | Yes, counted as deflected |

Put another way:

```text theme={null}
Deflection rate     = Resolved by AI share + Waiting for Customer share
AI resolution rate  = Resolved by AI share
Gap between them    = Waiting for Customer share
```

The same split as a picture. Deflection is the outer box; resolution is only the part of it that actually ended resolved (example figures, matching Agent A in the worked example below):

```mermaid theme={null}
---
title: "Example: 1,000 conversations"
---
flowchart LR
    subgraph ALL["All conversations: 100%"]
        direction LR
        subgraph DEFL["Deflection rate: 80%"]
            direction TB
            RES["Resolved by AI<br/>700, 70%<br/>AI resolution rate"]
            WAIT["Waiting for Customer<br/>100, 10%<br/>the gap"]
        end
        ESC["Escalated to Human Team<br/>200, 20%<br/>Human escalation rate"]
    end

    classDef source fill:#F7F7F7,color:#131415,stroke:#E8E8E8
    classDef agent fill:#131415,color:#FFFFFF,stroke:#131415,stroke-width:3px
    classDef surface fill:#FFFFFF,color:#131415,stroke:#131415
    classDef human fill:#C3EE5E,color:#131415,stroke:#131415,stroke-width:2px

    class RES human
    class WAIT source
    class ESC surface
```

The definitions come straight from the [Analytics](/en/analytics#kpi-cards) page, where the **Deflection rate** and **Human escalation rate** KPI cards sit at the top, the **Resolution rate** trend plots daily resolution alongside the **Waiting for Customer** share, and the **Conversation Status** doughnut shows the three-way split.

## A worked example

Two agents each handle 1,000 conversations in a week. Both escalate 200 of them to humans.

| | Agent A | Agent B |
| - | - | - |
| Total conversations | 1,000 | 1,000 |
| Resolved by AI | 700 | 550 |
| Waiting for Customer | 100 | 250 |
| Escalated to Human Team | 200 | 200 |
| **Human escalation rate** | 20% | 20% |
| **Deflection rate** (`100% - 20%`) | **80%** | **80%** |
| **AI resolution rate** | **70%** | **55%** |

On deflection, the two agents look identical. On resolution, Agent A is 15 points ahead. Agent B is leaving a quarter of its conversations open: customers who were asked a clarifying question and never answered, or who got an answer that didn't settle the issue and went quiet. Some of those customers will come back through another channel, which deflection never sees.

Try it with your own numbers. The defaults are Agent A; enter Agent B (550, 200, 250) to watch deflection stay at 80% while resolution drops:

<RateCalculator resolved={700} escalated={200} waiting={100} />

<Tip>
  When deflection rate and AI resolution rate drift apart, open [Inbox](/en/testing/inbox) and filter **Conversation status** to **Waiting for Customer**. Read ten of those conversations. A pattern of unnecessary clarifying questions usually points to a [Rulebook](/en/automations/rulebook) intent gate that is too strict or a knowledge gap the agent is covering with questions.
</Tip>

## Why Fini leads with resolution

A support team's job is to solve the customer's problem, not to keep it away from a human. Deflection measures the second thing. It goes up when the agent answers correctly, and it also goes up when the agent asks a question the customer abandons, gives an answer the customer doesn't trust, or simply keeps the customer from reaching a person. Resolution rate only goes up when the conversation actually ends resolved.

This is also why Fini's pricing is tied to resolutions rather than conversations or seats. Fini's pricing is usage-based, per resolution, and the billing definition is stricter than the **Resolved by AI** status: a resolution counts only when Fini fully solves the issue, no human ever touches the conversation, and the customer does not reply for 72 hours. A conversation that reopens within 72 hours, or that a teammate replies to or touches, is not a resolution. If you pay for resolutions, the vendor's incentive and yours point the same way: more conversations genuinely solved.

The **Resolved by AI** status can appear in Analytics before the 72-hour window closes, so the billed count can differ from Analytics in the short term. See [What counts as a resolution](/en/billing/what-counts-as-a-resolution) for the billing definition, including [where the Resolved by AI count and the bill can differ](/en/billing/what-counts-as-a-resolution#where-the-product-status-and-the-bill-can-differ), and [Pricing](https://www.usefini.com/pricing) for current plans and rates.

For a longer discussion of the two metrics outside the product, see Fini's article [Deflection rate vs resolution rate](https://www.usefini.com/blog/deflection-rate-vs-resolution-rate-ai-support).

## When deflection is still useful

Deflection is not a wrong number, it answers a narrower question: how much load reached your human team? That is the right lens in a few situations.

| Situation | Why deflection helps |
| - | - |
| **Staffing and capacity planning** | Human escalation rate (and its complement, deflection) maps directly to the tickets your team must handle. The **Hourly breakdown** in Analytics shows where that load lands. |
| **Spotting a broken handoff or connector** | A sudden jump in deflection with no matching rise in resolution can mean conversations are not escalating when they should. Check [Reply Rules](/en/automations/reply-behavior) and the integration first. |
| **Channels where waiting is expected** | On email, many conversations legitimately wait on the customer for days. Read deflection alongside resolution there, rather than resolution alone. |
| **The live Today pulse** | The *Today* pulse in the Analytics header shows today's conversation count and deflection rate for the selected agent, independent of filters. It is a quick health signal, not a performance report. |

The rule of thumb: report **AI resolution rate** to stakeholders as the measure of how well the agent works, and use **deflection** and **Human escalation rate** to plan your team's workload.

## Reading the gap over time

The gap between deflection and resolution is your **Waiting for Customer** share. Track it as its own number:

* **A stable, small gap** is normal. Some customers always go quiet after getting their answer.
* **A growing gap after a change** often means the agent started asking more questions or giving less complete answers. Compare the period before and after the change with the steps in [Measure your resolution rate](/en/how-to/measure-resolution-rate#compare-before-and-after-a-change).
* **A large gap on one intent rule** shows up in the [Intent rule breakdown](/en/analytics#intent-rule-breakdown), where **AI Resolve Rate** is low but **Escalated Rate** is also low. That rule is leaving conversations open rather than resolving or handing off.

## Related

<CardGroup cols={2}>
  <Card title="How accuracy is measured" icon="bullseye" href="/en/performance/how-accuracy-is-measured">
    What the benchmark numbers mean and how to grade accuracy on your own traffic.
  </Card>

  <Card title="Measure your resolution rate" icon="chart-line" href="/en/how-to/measure-resolution-rate">
    Step-by-step in Analytics and through the API.
  </Card>

  <Card title="What counts as a resolution" icon="receipt" href="/en/billing/what-counts-as-a-resolution">
    The billing definition of a resolution.
  </Card>

  <Card title="Analytics" icon="chart-bar" href="/en/analytics">
    KPI cards, the Conversation Status doughnut, and escalation reasons.
  </Card>
</CardGroup>


## Related topics

- [What counts as a resolution](/en/billing/what-counts-as-a-resolution.md)
- [Fini FAQ](/en/faq.md)
- [Measure your resolution rate in Fini](/en/how-to/measure-resolution-rate.md)


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.