How to improve first call resolution for your MSP help desk

TL;DR
First call resolution (FCR) = resolved on first contact ÷ total contacts × 100. The industry average sits around 70-75%, but that's contact-centre data, not MSP data. Most MSP desks run lower because: (1) they measure it wrong and inflate the number, (2) tickets hit the wrong tier and bounce, and (3) even when a tech knows the fix, they don't have the system access to run it. The highest-leverage moves are fixing triage routing first, building runbooks for the top repeat tickets, giving L1 real execution authority, and - increasingly - deploying an AI technician that closes tickets without waiting for a human to execute. Improving FCR by even a few points typically adds up to hours of billable capacity recovered per week. Rallied is built specifically for that last lever: AI that executes, not just suggests.
What first call resolution actually measures
FCR is the share of support contacts your team fully resolves the first time, with no callback, escalation, transfer, or reopened ticket. The formula is:
FCR (%) = issues resolved on first contact ÷ total issues × 100
Simple math. The hard part is deciding what "resolved on first contact" means - and most teams get this wrong in ways that flatter the number.

Tollanis research identifies four measurement approaches - and the gaps between them are significant:
| Method | How it works | The catch |
|---|---|---|
| Agent-determined | Agent marks resolved at close | Overstates FCR by 8-12 points vs customer-reported, per Tollanis |
| Customer survey | Post-contact question asks if the issue was fully resolved | Most accurate - but needs survey infrastructure |
| Repeat-contact proxy | No reopen or follow-up contact within 7 days | Objective and automatable; Tollanis calls 7 days the standard window |
| AI-detected | Speech or text analytics flag repeat contacts | Covers all channels; requires tooling |
If you're using agent-determined resolution today, your FCR number is probably 8-12 points higher than reality. Atlassian puts it bluntly: "a ticket isn't resolved until your customer says it is." A 24-48 hour window before counting a close as a first-contact success is the minimum to catch quick reopens.
The practical fix: shift to a repeat-contact proxy (no reopen in 7 days) for the measurement, then layer in a short post-resolution survey for a reality check. That's the approach most honest desks end up at.
Why MSPs struggle with FCR specifically
The 70-75% average comes from voice-based contact centres. MSP service desks look different in ways that push the number down structurally:
Ticket channels run lower than phone. Tollanis's channel data shows email at ~62% FCR and portal/self-service at ~55%, vs voice at ~74%. If most of your tickets come in via portal or email - which is true for most MSPs - you're competing against a lower baseline than the headline number.
Escalation norms create the problem. There's a real tension in r/msp discussions between FCR desks (which attempt resolution before escalating) and standard desks (where a 4-hour SLA shapes what happens to a ticket). One practitioner summarised it: "Having a 1 hour response on all tickets is where you can start to fix this behavior - Plan → Resolve - unless you're running a FCR desk." An FCR desk is a specific operating model, not just a metric.
L1 techs often lack execution authority. The most common MSP FCR failure isn't a knowledge gap - it's an execution gap. The tech knows what to do. They just don't have the system access, or the runbook permission, to do it without escalating. This is the lever most FCR advice misses entirely.
The L1 ticket volume problem is real. Password resets, account unlocks, MFA re-enrolments, and printer spooler restarts make up roughly 40-50% of L1 volume on a typical MSP desk, per Rallied's data on agentic AI for MSPs. These are exactly the tickets that should resolve on first contact - they're simple, well-understood, and repeatable. When they don't, it's almost always an execution authority problem.
The 6 ways to improve first call resolution

1. Fix routing before anything else
Misrouting accounts for about 21% of FCR failures, according to Tollanis. It's also the cheapest problem to fix.
The pattern: a password reset ticket lands in the general queue. A tier-2 tech picks it up, doesn't have direct access to the identity provider, escalates to whoever does. The ticket bounces twice before it closes.
The fix is boring but effective - build a routing matrix that maps ticket categories to tiers with actual execution authority. Password and access requests go to the tier that can action Entra ID or Okta changes. Printer and endpoint issues go to the tier with RMM access. Routing accuracy of this kind can add 3-8 FCR points on its own, per Tollanis, and it's usually a one-day configuration change in your PSA.
2. Build runbooks for the top 10 repeat tickets
Knowledge gaps account for about 32% of FCR failures - the largest single share. Atlassian notes that agents cannot resolve what they cannot find, and that a knowledge base makes repeat problems "exponentially easier to resolve."
For an MSP, this usually means a small, specific runbook library rather than a general knowledge base. The right starting point: pull the last 90 days of tickets, find the 10 ticket types that reopened most often or took the longest to close, and write a step-by-step runbook for each. Link the runbook from the ticket template so it's the first thing the tech sees when that ticket type arrives.
Hudu and IT Glue are the standard documentation tools in the MSP space for this - the key is embedding the runbook in the ticket workflow, not leaving it in a separate tab the tech has to find. See Rallied's guide to MSP documentation for a practical approach to structuring this.
3. Give L1 real execution authority
This is the most underrated lever in MSP FCR. Tollanis and Xima both name authority limits as a common FCR killer. The practical translation for an MSP: audit every common ticket type and ask which ones require an escalation that shouldn't require an escalation.
A tier-1 tech who knows the password reset procedure but doesn't have Entra ID write access is not a knowledge problem - it's a permissions problem. Pre-approved action sets (what tier-1 can do without asking) dramatically reduce the escalation rate on L1 tickets. Write those into your runbooks, enforce them through role-based access in your identity provider and RMM, and revisit the list quarterly as you add clients.
The same principle applies to documentation tools. If a tech needs to look up a client's admin credentials but IT Glue access requires escalation, you've built a bottleneck into the ticket flow. Access controls should follow execution need, not seniority.
4. Coach from real reopened tickets
Tollanis recommends building a coaching library from actual failed first-contact interactions, tagged by root cause, rather than generic scripts. The claim is 3-5 FCR points from technique alone - probing for the real issue behind the stated problem, confirming resolution explicitly before closing, using clear close language.
The MSP version of this is a monthly 30-minute review of the tickets that reopened in the last four weeks. Pull the worst three. Walk the tech through each: what did they know at close, what turned out to be missing, what would they do differently? That's it. It doesn't require a formal training programme - it requires consistency.
"first-call resolution proper documentation knowledge sharing realistic expectations: 65-75% utilization is healthy anything over 80% = burnout"
- r/msp, "Employee burnout due to metrics" (search snippet)
The r/msp thread above captures the tension worth watching: FCR and utilisation targets can pull against each other. A desk that closes tickets fast to hit an FCR number, while also demanding 80%+ utilisation, will burn out techs and create a reopen problem that cancels the FCR gain. Build the coaching loop without making FCR the only metric people are evaluated on.
5. Track why tickets come back, not just whether they do
Xima's framework makes an important distinction: tracking whether a ticket reopened tells you FCR. Tracking why it reopened tells you what to fix. The root-cause categories worth tracking for an MSP:
- Fix didn't hold - the resolution was correct but incomplete (printer restart without driver update, password reset without session revocation).
- Wrong problem diagnosed - the stated issue was a symptom; the ticket came back when the root cause resurfaced.
- Missing information at close - the tech closed without confirming the user could actually log in, run the application, or complete the original task.
- Process gap - a whole category of tickets keeps coming back because there's no permanent fix (a recurring permission error that needs a client-side policy change, not a manual fix each time).
That fourth category is where MSP service desk automation earns its keep. If a ticket type is structurally impossible to close on first contact with a manual fix, automate the fix or remove the root cause.
6. Deploy an AI technician that executes, not just suggests
Most FCR advice assumes a human resolves every ticket. The question for an MSP in 2026 is what the number looks like when the first responder is an AI technician that can actually close the ticket.
There are two distinct AI shapes here, and the difference matters:

AI assist (agent-assist tools that surface a knowledge base article) addresses the 32% knowledge-gap share. The tech still has to execute the fix, so FCR is still bounded by execution speed and authority. It's valuable - but it doesn't change the ceiling.
AI execution is different. If the first responder can reset the password, revoke sessions, unlock the account, run the RMM script, and close the ticket - all without a human in the loop - then the ticket resolves on first contact by definition. That's the only path that pushes FCR past the human-capacity ceiling.
The caveat: AI that closes tickets prematurely creates a measurement problem. Atlassian flags this as a classic gaming risk - a high-FCR metric with low CSAT underneath it. Pair execution automation with a reopen-rate check and a customer survey, and the number stays honest.
For the specific tickets where execution AI pays off most - password resets, account unlocks, MFA re-enrolments, offboarding steps - see Rallied's rundown of what agentic AI actually handles on an MSP desk. Those are the L1 tickets that are killing MSP margins when handled manually, one at a time.
The measurement trap: how to avoid inflating FCR
Before wrapping up, one thing worth saying plainly: a high FCR number built on agent-determined resolution isn't a signal your desk is performing. It's a signal your measurement is broken.
The short version of a healthy FCR measurement stack:
- Use a repeat-contact proxy (no reopen in 7 days) as your baseline metric - it's objective, automatable, and doesn't require a survey
- Run a post-resolution survey quarterly to calibrate the proxy against customer-reported resolution
- Track reopen rates separately alongside FCR - they're a check on the number, not a replacement for it
- Review FCR by ticket category, not just the blended rate - a 78% blended FCR that hides a 45% FCR on password resets is a category problem, not a desk problem
One r/msp practitioner put it well: "Instead, measure first contact time, and also 'First touch resolution', meaning no other solutions are needing to be offered." That framing - did the first touch actually close the loop - is more honest than a blanket close rate, and it's what your clients actually care about.
The MSP help desk statistics and benchmarks guide and the ticket resolution time benchmarks post on the Rallied blog have more detail on how the numbers compare across desk types.
Try Rallied

Rallied is an AI technician for MSPs that takes L1 and L2 tickets inside your PSA - ConnectWise, HaloPSA, Autotask, SuperOps - and does the work. Password resets with MFA verification, account unlocks, offboarding sequences, endpoint fixes through the RMM - the ticket goes from open to closed without waiting for a human in the queue. Pricing is $300/month for 2,000 credits (~700 standard tickets), with 1/3/8 credits per ticket depending on complexity. Diagnosis and handoffs where Rallied couldn't finish aren't charged.
If the execution gap is what's holding your FCR back, that's exactly the problem Rallied is built for. Most MSPs go live in under a week.
For the wider picture, read IT Help Desk Procedures.
Frequently Asked Questions
What is a good first call resolution rate for an MSP?
The broadly cited industry average is 70-75%, based on contact-centre benchmarks from SQM Group and ICMI. High-performing desks exceed 80%. There are no published, independent benchmarks specifically for MSP help desks, so the most useful comparison is your own trend over time and your channel mix - a portal/email-heavy desk will naturally run lower than a phone-first desk.
How do you calculate first call resolution?
FCR (%) = (issues resolved on first contact ÷ total issues) × 100. The formula is simple; the definitions are not. You need to decide what counts as 'resolved' (agent-marked vs customer-confirmed) and what window you use to catch reopens. Atlassian recommends waiting 24-48 hours before counting a closed ticket as a first-contact success, so a quick reopen gets caught.
What's the difference between first call resolution and first contact resolution?
They measure the same thing on different channels. First call resolution comes from phone-based contact centres. First contact resolution is the same metric applied to any channel - email, portal ticket, chat, or phone. For most MSPs, 'first contact' is more accurate since most tickets come in via a portal or email, not a phone call. Many MSPs use the two terms interchangeably.
Can AI improve first call resolution for an MSP help desk?
Yes - but the mechanism matters. AI that only suggests fixes (agent assist) still leaves execution to a human, which keeps FCR below the execution speed ceiling. AI that can execute the fix - reset the password, unlock the account, close the ticket - removes the execution delay entirely and can resolve common L1 tickets on first contact without a tech in the loop. Rallied is built for the execution side of this.
What causes low first call resolution rates?
The three biggest causes, per Tollanis, are knowledge gaps (no runbook or article for this ticket, 32% of FCR failures), misrouting (ticket went to the wrong tier, 21%), and lack of authority or access (the tech knows the fix but can't execute it). For MSPs, execution blocks are especially common - L1 techs often don't have the system access to close a ticket themselves, so they escalate even when the solution is straightforward.