Skip to content

As of

Are SLAs and ticket volume still the right IT metrics?

SLA compliance and ticket volume are still the standard IT metrics, but once AI agents do the work they can show a healthy service desk while employees wait and decisions rest on stale facts.

For most of the history of service management, the person doing the work was an analyst working a queue. So the measures were built around the queue. How fast did someone pick the ticket up? Was it closed inside its target? How many came in this month, and how many went out?

If an analyst responded quickly and closed on time, the employee was probably helped quickly too.

That link is weaker now. An AI agent answers in Slack or Teams in seconds, fulfills some requests without a ticket, and opens tickets for the rest. The queue is no longer where most of the work happens, so measuring the queue tells you less.

The case for measuring how people experience IT, and not only what the ticket says, is now mainstream, and it's right. This guide adds one measure most scorecards still miss: how fresh the facts were when an AI agent acted on them.

Are SLAs and ticket volume still the right IT metrics?

They're still worth keeping, but neither tells you whether people got what they needed or whether the work rested on current facts.

SLAs are an agreement between IT and the business about what good looks like, and they give your team a shared target. Ticket volume shows where demand comes from. Keep both.

The trouble is what each one leaves out. An SLA measures the ticket's time on the clock, and the clock was designed to pause. Pending approval, waiting on a vendor: each pause is fair to the analyst and invisible on the report. The employee just waits.

Ticket volume has a different problem once an AI agent handles requests in conversation. A falling count could mean requests were resolved without a ticket. It could mean people gave up and asked a colleague. A rising count could mean more demand, or a fix that didn't hold and came back as a new ticket. The number alone can't tell you which.

The two blind spots compound. A sales operations manager moves teams on a Monday, asks for Salesforce access on Tuesday, and the request goes to her old manager for approval because the service desk's user records came from last week's import. The approval sits for days, the grant arrives against her old department's permission set, and she files a second ticket. Both close inside their targets, and the month-end report shows two requests resolved on time while she spent more than a week unable to do her new job.

What experience metrics get right

Experience measures moved the question to the person: time from first ask to a working fix, satisfaction after resolution, repeat contacts about the same thing. Many service desks now report them next to their SLAs.

They also catch the size of a problem the SLA hides. Measured from the first message in the channel, any wait that spans a stalled approval and a follow-up ticket shows up as one long wait, not two on-time closures. A survey after the follow-up would probably say so too.

What they don't catch is why. Long waits often come from facts that went out of date before anyone acted on them: a department, a manager, a group membership as of the last import. A person reading the request might notice. An AI agent acting on the same record would not, and it would act faster, so the wrong grant would arrive sooner. As more of the work is done by agents, the age of the facts they act on becomes part of the service.

Three measures for a service desk where AI agents do the work

Add three measures that follow the person and the decision instead of the ticket.

How long the person waited for a working fix. Start the clock at their first message, wherever they sent it, and stop it when the thing works, not when the ticket closes. Don't pause it for approvals. If approvals are slow, that's a finding.

Which requests still needed a person, and why. A count of escalations is not enough, because each reason calls for a different fix. Tag every request that reached your team with one reason:

  • No policy covered it, so someone had to decide.
  • Policy required an approval.
  • The facts were missing, conflicting or out of date.
  • It needed judgment: an exception, a major incident, a sensitive case.

The first is fixed by writing policy. The second may be right, or may be an approval nobody needs. The third is a data problem, and the fourth is the work your team should be doing.

How fresh the facts were behind each automated decision. For every action an AI agent takes, note the facts it relied on (role, manager, group membership, device) and how long before the decision each was last observed at its source. Report the typical age and the worst case. If your user records come from a weekly import, a fact can be a week old at the moment it's used, and that is the normal case, not the exception.

The worst case matters more than the average. A median fact age of a few hours can hide a long tail of decisions made on records nobody has refreshed since a person changed roles, and those are exactly the decisions that go wrong. Break the number down by fact type as well. Manager and department change rarely but matter a lot when they do; group membership changes often and drives most access decisions.

Why fact freshness belongs on an AI agent scorecard

An analyst who knows the organization notices an approval going to someone who left. An AI agent has no such check. It reasons correctly over what it's given, so the quality of the decision is capped by the age of the facts.

You can only measure fact age if every fact carries two things: the system it came from and the time it was observed there. Most service desk records hold a value and nothing else. The user table says someone is in finance. It doesn't say that came from Workday, or when anyone last checked. Without that, a report can't tell a current fact from a stale one, and neither can the agent.

So put this question to any platform you run or evaluate: for this decision, show me each fact it used, where it came from and when it was observed. If the answer has no source and no timestamp, you can't measure freshness.

How STLabs reports on service delivered by AI agents

STLabs is built so that the measures above come from the same data the work runs on.

Axiom™ is the live model of your organization, built from your HR system, identity provider, device management and other connected tools. It syncs with them in real time, so when Workday changes someone's department and manager, the next request uses the change. Every fact in Axiom™ records which system it came from, when it was observed and how confident Axiom™ is in it, and any answer can be traced back to its source. When you look at a decision, you can see what it rested on and how old each fact was.

Policies & Approvals holds the rules: which requests are allowed, which need approval, and who approves. Because Axiom™ knows who reports to whom from HR, an approval goes to a person's new manager the day they move.

Analytics reports from the same records. It shows what the AI resolved and what it routed to a person, workflow runs over time, median time to resolve, and who has been waiting longest, with related tickets grouped by root cause. Ask "who's been waiting longest?" in plain words and the answer comes back in a sentence. Every action, approval and resolution is recorded, so the reason a request reached a person is already on the record. SLAs still exist, set per queue. They sit beside the measures that follow the person.

How to test your metrics on your own systems

Take last month's numbers and check them against what actually happened.

Pick twenty closed requests at random. For each one, find the first time the person asked, in Slack, Teams, email or the portal, and the moment the thing actually worked. Compare that span with the SLA time on the ticket, and look for follow-up tickets from the same person about the same thing.

For every request that reached a person, write down why, using the four reasons above. If most of them land in "facts were missing or out of date", more people won't fix it; better data will.

Then pick five automated actions and trace their facts. For each one, find when the fact changed in its source system and when your service desk or agent learned about it. Ask your vendor to show you the same thing for one decision. If neither of you can, put that on the list.

Keep the SLA, change what it counts

You don't need a new framework for any of this. ITIL's concepts carry over, as ITIL without the paperwork explains, and the SLA still belongs in your agreement with the business.

What changes is what sits next to it. STLabs runs alongside the service desk you already have with bidirectional sync, and teams go from integration to results in five days, so you can measure the old way and the new way against the same requests. The plan is in Moving to STLabs from your current service desk. That comparison is what AI-native service management looks like on a report.

A ticket can close on time while the person behind it is still waiting.

Frequently asked questions

Are SLAs still relevant in ITSM when AI agents do the work?

Yes, as an agreement with the business about response and resolution targets. But SLA clocks pause for approvals and waiting, so report how long people actually waited for a working fix alongside them.

What should replace ticket volume as an ITSM metric?

Keep volume for demand planning, but add which requests still needed a person and why: no policy, a required approval, missing or stale facts, or a judgment call. Each reason points to a different fix.

What is data freshness in IT service management?

Data freshness is how long before a decision each fact behind it was last observed at its source. Measuring it requires every fact to carry its source system and observation time.

How do you measure AI agent performance in ITSM?

Measure time from first ask to working fix, the reasons requests still reached a person, and the age of the facts behind each automated decision. Ticket counts alone can't separate a resolved request from an abandoned one.

See it on your tools.