Erlang A: What Erlang C Misses When Callers Hang Up

A woman in a headset watching a queue of waiting caller icons with a few drifting away through a window

Erlang C overstates the agents you need whenever customers hang up, because it assumes every caller waits as long as it takes. Real callers don’t. They abandon, and the model that accounts for that is called Erlang A. If you only use the Excel version of Erlang C, you should know what it leaves out, because in the worked example below it’s the difference between 25 agents and 22.

I built the Erlang C version in my Excel post on the Erlang C calculator and flagged the weakness there in one paragraph. Here’s the longer answer, with a second sheet you can build yourself, because the weakness changes real decisions. It changes how many people you hire, and it changes what you tell your boss about the customers you lost.

What does Erlang C assume about the caller?

That nobody ever gives up. Every call joins the queue and stays there until an agent picks up. That’s the maths of the 1917 formula, written for telephone exchanges where the operator was the only way through. Nothing in it describes a customer who’s been listening to a recorded message for four minutes and has a train to catch.

Take the worked example from the calculator post: 120 calls in a half hour, 300 seconds average handle time, 24 agents. The first number the sheet works out is traffic intensity, the amount of work arriving in agent-hours per hour. It’s calls times handle time divided by the length of the interval: 120 × 300 = 36,000 seconds of talk, divided by 1,800 seconds in a half hour, gives 20. So 20 agents’ worth of work is landing every second of that half hour, and you’ve got 24 people to absorb it.

From there the sheet says 29.8% of calls have to wait. The average speed of answer follows from that in one line: probability of waiting × handle time ÷ (agents − traffic), so 0.298 × 300 ÷ (24 − 20) = 89.4 ÷ 4 = 22.4 seconds. Service level, the share answered inside 20 seconds, is 1 − 0.298 × e−(24 − 20) × 20 ÷ 300. The exponent is −4 × 20 ÷ 300 = −0.267, e to that power is 0.766, and 0.298 × 0.766 = 0.228, so service level is 1 − 0.228 = 77.2%. That misses 80/20. Add a 25th agent and the same steps give 85.0%, so Erlang C tells you to roster 25.

Now look at what 29.8% means in calls: 0.298 × 120 is about 36 people waiting in that half hour. Erlang C plans for every one of them to hold until they’re answered. If even a handful hang up, the sheet is planning staff to answer calls that are no longer there. The result is a requirement that’s too high, and the only question is by how much.

What is Erlang A?

Erlang A adds one input to the calculator’s list: how long callers are willing to wait before they give up. The model treats patience as a random figure with an average, the same way Erlang C treats handle time. Feed it that average and it returns the abandonment rate alongside the waiting probability and service level. The “A” stands for abandonment, which tells you everything about why it exists.

The standard reference is the 2002 paper by Garnett, Mandelbaum and Reiman, Designing a Call Center with Impatient Customers, which studies queues where customers leave and gives rules of thumb for sizing them. A draft is hosted by the Technion’s service engineering group. You don’t need to follow every proof in it. The point comes through in the abstract and the introduction: the Erlang C formula you’ve been using is the special case where patience is infinite.

That’s a better way to say it than “Erlang C is wrong.” It isn’t wrong. It’s the case where nobody leaves, and for a real queue that case doesn’t exist. Shorten the patience and the two models drift apart. Lengthen it towards forever and Erlang A collapses back into Erlang C, number for number.

If you’d rather read the practitioner version than the academic one, Ger Koole’s Call Center Optimization covers the same ground for workforce planners and carries free online calculators that include abandonment. I’d still build the sheet below once. Building it is how you learn what the model is actually doing with your numbers, and it’s how you spot the day a vendor’s tool is quietly running plain Erlang C behind a nicer screen.

A customer on a sofa holding a phone to their ear with an hourglass on the side table

How do you build an Erlang A sheet in Excel?

Add a new sheet to the same workbook as your Erlang C calculator. I call mine ErlangA. Put the inputs at the top in column B, with labels beside them in column A: B1 is calls per half hour (120), B2 is average handle time in seconds (300), B3 is average patience in seconds (120, a hypothetical two minutes, not a benchmark), B4 is agents (24) and B5 is the interval length in seconds (1,800).

Row 7 holds four headings: “Calls in system” in A7, “Weight” in B7, “Probability” in C7 and “Queue length” in D7. Fill A8 down to A208 with 0, 1, 2 and so on up to 200. Each row is one possible state of the phone line: nobody on, one caller on, two, and onwards. Row 8 is zero callers, so the row for n callers is row 8 + n. Two hundred is far more than this queue will ever hold, which is the point. The rows past about 60 are so unlikely they round to nothing.

Type 1 in B8. In B9 type =B8*(B$1/B$5)/(MIN(A9,B$4)/B$2+MAX(A9-B$4,0)/B$3) and fill it down to B208. In words: take the row above, multiply by the arrival rate per second (calls ÷ interval), and divide by the rate at which people leave the system in this state. People leave two ways. MIN(A9,B$4) is how many are being served, capped at the number of agents, and each finishes at 1 ÷ 300 per second. MAX(A9−B$4,0) is how many are queuing, and each gives up at 1 ÷ 120 per second. The dollar signs keep the inputs fixed as you fill down.

Walk the first rows by hand and you’ll see it working. The arrival rate is 120 ÷ 1,800 = 0.0667 per second. Row 9 (one caller): 1 × 0.0667 ÷ (1 ÷ 300 = 0.00333) = 20. Row 10: 20 × 0.0667 ÷ (2 ÷ 300 = 0.00667) = 200. Row 11: 200 × 0.0667 ÷ 0.01 = 1,333. Up to row 32 (24 callers) this is exactly Erlang C’s arithmetic. Row 33 is where Erlang A differs: 25 callers means 24 being served at 24 ÷ 300 = 0.08 and one waiting at 1 ÷ 120 = 0.00833, a total of 0.0883, so the weight is the row above × 0.0667 ÷ 0.0883, about 0.755 of it.

In C8 type =B8/SUM(B$8:B$208) and fill down. That turns the weights into probabilities that add up to 1. In D8 type =MAX(A8-B$4,0) and fill down, the number of people queuing in each state. Then three results, labels in column E and values in column F. F1 is the probability of waiting, =SUMIF(A8:A208,">="&B4,C8:C208), which adds the probabilities of every row with 24 or more callers: 0.176, or 17.6%. F2 is the average queue, =SUMPRODUCT(C8:C208,D8:D208), each state’s queue length times its probability, summed: 0.279 callers. F3 is the abandonment rate, =(F2/B3)/(B1/B5). The top half is 0.279 ÷ 120 = 0.00233 callers giving up per second, the bottom half is 0.0667 arriving per second, and 0.00233 ÷ 0.0667 = 0.035. So 3.5% of calls abandon, which is 0.035 × 120 = about 4.2 calls every half hour.

Why does abandonment change the staffing answer?

Because abandoned calls shorten the queue. A caller who hangs up after 40 seconds no longer takes up an agent’s time, so the people still waiting move forward faster. A model that ignores this thinks the line is longer than it really is. Compare the two sheets at 24 agents: Erlang C says 29.8% wait, Erlang A says 17.6%. Same calls, same handle time, same people.

Service level under Erlang A doesn’t reduce to a single cell, because a fast answer only counts if the caller was still there to take it. I ran the same inputs through a full Erlang A calculation, counting a call as a success only if it was answered inside 20 seconds and treating every abandon as a miss. At 22 agents it’s 81.6% in 20 seconds with 6.5% abandoning, about 7.8 calls a half hour. At 23 it’s 86.1% and 4.8%. At 24 it’s 89.8% and 3.5%.

So Erlang C asks for 25 and Erlang A says 22 already clears 80/20. That’s three agents per half hour at the peak, and over a week of peaks that’s real money. It’s also a trap, because 22 agents is the row where you lose the most people. That gives you two practical effects.

  • Erlang C asks for too many agents. If your abandonment rate is meaningful, the true requirement for an 80/20 target is lower than the sheet says, and the gap grows as your queue gets longer and your callers get less patient.
  • Service level can look better than the customer experience. Depending on how your phone system reports it, calls that hang up quickly may not count against you at all. You can post a good number and still lose a lot of people.

That second point is the uncomfortable one. A team can run a healthy service level and a poor abandonment rate in the same half hour. I’d rather report both numbers side by side, every day, than let one of them hide behind the other.

Does this mean you should stop using the Excel sheet?

No. Keep the Erlang C sheet. Use it as an upper bound and then check it against what your own phone system shows. I thought the answer was to find the more advanced model. It’s to understand which direction the simple one errs in, and by roughly how much, for your callers. Erlang C errs high. Erlang A with a patience figure you guessed can err anywhere, which is worse.

Here’s the routine I’d run over a month:

  • Pull the abandonment rate by half hour for the last four weeks.
  • Compare it with the Erlang C waiting probability for the same intervals. In the example, 29.8% of calls wait at 24 agents, so an abandonment rate of 3% to 4% means roughly one in eight of your waiting callers is leaving.
  • Look at how long the abandoned calls waited. If most leave inside the first 10 to 20 seconds, treat them as short abandons and strip them out of the volume you plan against, as Call Centre Helper suggests.
  • If a lot leave after a minute or more, that’s a real service failure, and no staffing model will solve it on its own. Treat it as a staffing or process problem and fix the queue itself.

That “one in eight” in the second step is simple arithmetic: 3.5% of all calls abandon and 29.8% of all calls wait, so 3.5 ÷ 29.8 = 0.117, close to one waiting caller in eight. Run the same division on your own numbers. If it comes out at one in three, your Erlang C sheet is a long way from your floor, and the patience figure you put in B3 needs to come from your data, not from this post.

What do you do about the callers who leave?

First, learn who they are. An abandoned call is a customer who wanted something and didn’t get it. Some will call back, which inflates your volume in the next interval and makes your forecast worse. Some won’t call back at all, and you’ll never see them again. That’s the cost no sheet can show, Erlang A included, because the model only knows they left the queue, not whether they left you.

If callbacks are a large share of your volume, you’re double counting. A caller who rings three times in ten minutes is one customer and three calls on the report. Feed those three calls into either model and it’ll staff for three customers. I covered the pressure that builds in a queue like that in my post on staffing for a launch you can’t forecast. The pattern’s the same: the queue punishes you twice, first with the wait and then with the repeat.

Second, give them a reason to stay. A message that says where they are in the queue, or how long the wait will be, changes how patient people are. That’s not a soft point. It moves the number in B3, and you’ve just seen what B3 does to the staffing answer. A callback option does more. It removes the wait and the abandonment in one move, and it’s a staffing tool as much as a courtesy, because you control when the callback gets made.

Third, separate the two kinds of leaver in your reporting. A caller who rang the wrong number and hung up in four seconds isn’t the same as a customer who held for three minutes. Lump them together and the abandonment figure stops meaning anything.

How long will your callers actually wait?

Nobody knows until they measure it. Pull the time-to-abandon for every call that hung up in a week and look at the spread. In most queues I’ve seen, the bulk of abandons happen in the first 20 to 30 seconds, from callers who were never going to wait, and then a smaller group leaves after a minute or two, which is where the real damage is. I wrote about why that number deserves a place on the main report in my post on call abandonment rate, and this is the staffing half of the same argument.

Here’s why patience matters so much, using the same hypothetical two minutes. Erlang A treats patience the way Erlang C treats handle time, so the share of callers still on the line after t seconds of waiting is e−t ÷ patience. In Excel that’s =EXP(-t/B3). At an average speed of answer of 22 seconds it’s e−22 ÷ 120 = e−0.183 = 0.83, so 83% of the people who wait that long are still there. At 90 seconds it’s e−0.75 = 0.47, so more than half have gone before anyone picks up.

Same patience, same callers, two very different experiences, and only one of them shows up as lost customers. That’s why the patience figure has to be yours. Two minutes is a number I picked to make the arithmetic clean. A queue full of business customers calling about a live outage might hold for six minutes. A retail queue at lunchtime might hold for forty seconds. Put each into B3 and watch the agent count move.

What should a service level target look like?

The 80/20 target is a convention, not a law of nature. It’s a fine start, but a target with one number invites you to optimise one number. The worked example shows how: 22 agents hits 80/20 and loses 6.5% of the callers. Pair the target with an abandonment ceiling. I use 5% as a conversation starter, not as a standard. In the example that ceiling pushes you to 23 agents, where abandonment drops to 4.8%. If you’re hitting 80/20 and abandoning 8%, the target’s being met and the customers are still leaving, so the target needs rewriting.

Twenty-three is the honest answer here. Not 25, which pays for agents to answer callers who already left. Not 22, which hits the target by losing people. The model didn’t give you 23. The second number did.

The same logic applies at the vendor level. If your outsourcer reports 80/20 monthly, ask for abandonment by half hour as well, and ask how they count a caller who hangs up inside ten seconds. An average hides the Monday mornings. It’s the half hours that fail, not the month.

How do you turn this into a budget conversation?

Log the abandonment rate against the staffing level of each half hour for a month, then plot the two. You’ll see a rough curve where each extra agent buys fewer saved callers than the last. In the example it’s 7.8 abandoned calls at 22 agents, 5.8 at 23 and 4.2 at 24. The first extra agent saves two callers a half hour. The second saves 1.6. That curve is your own, built from your own customers, and it’s a better guide to the right headcount than any textbook figure, mine included.

It also gives you something concrete to show the person who signs off the budget. Two agents more at the Monday peak saves a stated number of callers. Two agents fewer loses a stated number. Leaders argue less about a number they can see, and they argue a lot less when you can show them how you got it.

Start with the input you probably don’t track yet: average time to abandon, by half hour. It takes ten minutes to pull from most phone systems. Then put abandonment on the same page as service level in every report you share. The dashboard doesn’t tell you which callers you lost. You have to go and look.

What’s the average patience in your queue, and has it ever changed your headcount? Tell me in the comments.

Leave a Comment

Your email address will not be published. Required fields are marked *

This site uses Akismet to reduce spam. Learn how your comment data is processed.