Erlang C Calculator: Call Center Staffing
Jaseem Abbas
- Published

An Erlang C calculator answers one question: how many agents does a call center need so that callers wait only as long as you decided they may? You give it the calls that arrive, how long each one takes and your service level target. It gives back a headcount. This guide works the formula by hand, so you can check any calculator against it, then carries the answer to a full day, shrinkage and shifts.
Here is where the simple method fails. In our AHT guide, a team lead at an insurance renewal helpdesk in Pune had 2,400 calls a day at 6.0 minutes each, and the average method gave her 40 agents. She staffed 40. At 11:00, when 150 calls land in half an hour, the queue still runs past a minute. The average hides the peak, and callers live in the peak. One way to cover a peak without hiring for it is overflow calls, where an agent takes calls your seats cannot answer.
The Pune numbers are made up so the arithmetic can be checked. They are not customer data, and we label each assumption of ours.
What is Erlang C?
Erlang C is a formula that gives the probability that a caller has to wait, given how many calls arrive, how long each takes and how many agents answer. A staffing calculator runs it in reverse: it tries more and more agents until the waiting falls to your target.
The name comes from A. K. Erlang, a Danish engineer who worked on telephone exchanges. His 1917 paper, written in Danish, contains the classic formulae (Wikipedia on Agner Krarup Erlang has the reference). The standard modern source is the ITU-D Teletraffic Engineering Handbook, where Erlang's delay system, called M/M/n, is Chapter 12 and "Erlang's C-formula" is equation 12.6 (ITU teletraffic handbook).
What is one Erlang?
One Erlang is one line or one agent kept busy for the whole interval, whether that is an hour or half an hour. If calls bring 900 minutes of talk into a 30-minute window, that is 900 ÷ 30 = 30 Erlangs, which is the work of 30 agents who never pause. The Erlang is a unit of load, not of people. With 30 Erlangs, 30 agents is not enough: the queue grows without end, so the floor is 31.
What inputs does an Erlang calculator need?
An Erlang calculator needs four inputs: the calls in the interval, the average handle time, the service level target and the shrinkage. The first three feed the formula. The fourth turns agents on the phones into people on the roster.
Input: Calls in the interval
- What it is
- Calls that arrive in one half hour or one hour
- Pune value
- 150 calls, 11:00 to 11:30
Input: Average handle time (AHT)
- What it is
- Talk, hold and after-call work per call, in seconds
- Pune value
- 360 seconds
Input: Service level target
- What it is
- Share of calls answered within a set time
- Pune value
- 80% within 20 seconds
Input: Shrinkage
- What it is
- Paid time agents are not available for calls
- Pune value
- 30% (our assumption)
The AHT of 360 seconds is the 6.0 minutes from how to calculate AHT. The 150 calls, the 11:00 peak, the 80/20 target and the 30% shrinkage are ours, added to the Pune day. The calls come from a forecast, which is a subject of its own. Here it is simply given.
What is the 80/20 service level?
An 80/20 service level means 80% of calls are answered within 20 seconds. It is a common target in call centers, but it is a convention, not a rule set by any standards body, and we found no primary source that fixes it. The two numbers are yours to choose. A stricter target costs agents: at the Pune peak, 90% within 20 seconds needs 38 on the phones, and a looser 80% within 60 seconds needs 34. The call center metrics guide covers service level beside abandonment and the other measures.
What is the Erlang C formula?
The Erlang C formula has four parts: traffic intensity, the probability of waiting, the service level and the average speed of answer. They come from the ITU handbook (equation 12.6 for the waiting probability, 12.33 for how long delayed calls wait). Every symbol is defined below.
- Traffic intensity: A = calls in the interval × AHT in seconds ÷ interval length in seconds. A is the load in Erlangs.
- Probability a call waits: Pw = [ A^N ÷ N! × N ÷ (N − A) ] ÷ [ the sum of A^k ÷ k! for k = 0 to N − 1, plus A^N ÷ N! × N ÷ (N − A) ].
- Service level: SL = 1 − Pw × e^(−(N − A) × T ÷ AHT).
- Average speed of answer: ASA = Pw × AHT ÷ (N − A).
The symbols:
- A is the traffic intensity in Erlangs, from step 1.
- N is the number of agents on the phones. The formula only holds when N is greater than A.
- N! is "N factorial", N × (N − 1) × ... × 1. The sum runs k from 0 to N − 1, and k! works the same way.
- Pw is the probability that a call has to wait at all, between 0 and 1.
- T is the target wait in seconds, 20 for an 80/20 target.
- AHT is the average handle time in seconds.
- e is the constant 2.718, so e^(−x) shrinks as x grows.
- SL is the share of calls answered within T seconds. ASA is the average speed of answer in seconds, counting every caller.
In plain English: a call that waits at all waits a random time, and the ITU handbook shows delayed calls wait on an exponential curve with rate (N − A) ÷ AHT. More spare agents (N − A) means the wait dies away faster. So SL is 1 minus the chance of waiting longer than T. Occupancy is simply A ÷ N, the share of agent time spent on calls.
How many agents do I need for one busy half hour?
Pune's peak half hour needs 36 agents on the phones to answer 80% of calls within 20 seconds. Here is the working, so you can check it.
Step 1: traffic. A = 150 × 360 ÷ 1,800 = 54,000 ÷ 1,800 = 30 Erlangs. The least that can work is 31 agents.
Step 2: try N = 36. The factorials are huge, so we show the results, which a spreadsheet reproduces (next section).
- Pw = 0.2119. About 21% of callers have to wait.
- Exponent: (36 − 30) × 20 ÷ 360 = 0.3333, and e^(−0.3333) = 0.7165.
- SL = 1 − 0.2119 × 0.7165 = 1 − 0.1518 = 84.8%. That meets 80%.
- ASA = 0.2119 × 360 ÷ 6 = 12.7 seconds.
- Occupancy = 30 ÷ 36 = 83.3%.
Step 3: check that 35 fails. With N = 35, Pw = 0.2846, the exponent is 5 × 20 ÷ 360 = 0.2778 and e^(−0.2778) = 0.7575. SL = 1 − 0.2846 × 0.7575 = 78.4%. That is below 80%, so 35 is not enough. One agent is the gap between a pass and a miss.
Agents on phones (N): 34
- Callers who wait (Pw)
- 37.6%
- Answered in 20 s (SL)
- 69.9%
- Average speed of answer
- 33.9 s
- Occupancy
- 88.2%
Agents on phones (N): 35
- Callers who wait (Pw)
- 28.5%
- Answered in 20 s (SL)
- 78.4%
- Average speed of answer
- 20.5 s
- Occupancy
- 85.7%
Agents on phones (N): 36
- Callers who wait (Pw)
- 21.2%
- Answered in 20 s (SL)
- 84.8%
- Average speed of answer
- 12.7 s
- Occupancy
- 83.3%
Agents on phones (N): 37
- Callers who wait (Pw)
- 15.5%
- Answered in 20 s (SL)
- 89.5%
- Average speed of answer
- 8.0 s
- Occupancy
- 81.1%
Each added agent buys less. The agents just above 30 cut the wait most, and later ones mostly lower occupancy.
Why does occupancy fall out of the answer?
Occupancy here is a result, not a target you set. Pune at 36 agents runs at 30 ÷ 36 = 83.3% at the peak. The AHT guide assumed a flat 75% across the day and got 40 agents, which hides that the peak needs a different number from the quiet hours. See what occupancy means for the definition.
How do you build an Erlang C calculator in a spreadsheet?
You can build one with a table where each row is a trial headcount, then copy down until the service level passes. Factorials overflow for big N, so a spreadsheet works better with the Poisson function, which is mathematically the same. Multiplying the top and the bottom of Pw by e^(−A) turns A^k ÷ k! into Poisson probabilities.
This is our own derivation, and we have not checked it in a real spreadsheet. Check it in your own sheet against the Pune numbers before you trust it. In Excel and Google Sheets the idea looks like this, with A in cell B1 and the trial N in A5:
=POISSON.DIST(A5,$B$1,FALSE)*A5/(A5-$B$1) / (POISSON.DIST(A5-1,$B$1,TRUE) + POISSON.DIST(A5,$B$1,FALSE)*A5/(A5-$B$1))
Put that in the Pw column. Then add columns for SL, ASA and occupancy from the formulas above. The test: with A = 30, the row N = 36 should show Pw near 0.2119 and SL near 84.8%. If it does not, the formula is wrong somewhere, and the table above is the check.
The first N where SL reaches your target is the headcount on the phones. Building one yourself once means you know what a calculator is doing when its answer looks odd.
What is shrinkage, and how does it change the roster?
Shrinkage is the share of paid time when an agent is not available to take calls: breaks, training, meetings, leave and absence. Erlang C gives agents on the phones. Shrinkage turns that into people you must schedule, with the formula: scheduled = agents on the phones ÷ (1 − shrinkage).
For Pune at 11:00: 36 ÷ (1 − 0.30) = 36 ÷ 0.70 = 51.4, rounded up to 52 people scheduled. The 30% is our assumption, not a benchmark, and we found no verified shrinkage figure for Indian call floors. Measure yours over a few weeks of paid hours.
Planned shrinkage (breaks, training, meetings, approved leave) can be steered away from peaks. Unplanned shrinkage (sickness, late logins, system faults) you plan as an average and watch. We treat breaks as inside the 30%, so a 9-hour paid shift in the next section needs no separate break cover.
How do you go from one half hour to a full day and shifts?
Run the same steps for every half hour, then add them up. We spread the 2,400 calls over 24 half hours, open 9:00 to 21:00. The profile is ours: calls peak near 11:00 and ease through the evening. Here A = calls × 360 ÷ 1,800 = calls ÷ 5.
Half hour: 09:00
- Calls
- 50
- Erlangs (A)
- 10
- On phones (N)
- 14
- Scheduled
- 20
Half hour: 09:30
- Calls
- 70
- Erlangs (A)
- 14
- On phones (N)
- 18
- Scheduled
- 26
Half hour: 10:00
- Calls
- 110
- Erlangs (A)
- 22
- On phones (N)
- 27
- Scheduled
- 39
Half hour: 10:30
- Calls
- 140
- Erlangs (A)
- 28
- On phones (N)
- 34
- Scheduled
- 49
Half hour: 11:00
- Calls
- 150
- Erlangs (A)
- 30
- On phones (N)
- 36
- Scheduled
- 52
Half hour: 11:30
- Calls
- 145
- Erlangs (A)
- 29
- On phones (N)
- 35
- Scheduled
- 50
Half hour: 12:00
- Calls
- 130
- Erlangs (A)
- 26
- On phones (N)
- 31
- Scheduled
- 45
Half hour: 12:30
- Calls
- 115
- Erlangs (A)
- 23
- On phones (N)
- 28
- Scheduled
- 40
Half hour: 13:00
- Calls
- 100
- Erlangs (A)
- 20
- On phones (N)
- 25
- Scheduled
- 36
Half hour: 13:30
- Calls
- 105
- Erlangs (A)
- 21
- On phones (N)
- 26
- Scheduled
- 38
Half hour: 14:00
- Calls
- 105
- Erlangs (A)
- 21
- On phones (N)
- 26
- Scheduled
- 38
Half hour: 14:30
- Calls
- 110
- Erlangs (A)
- 22
- On phones (N)
- 27
- Scheduled
- 39
Half hour: 15:00
- Calls
- 115
- Erlangs (A)
- 23
- On phones (N)
- 28
- Scheduled
- 40
Half hour: 15:30
- Calls
- 120
- Erlangs (A)
- 24
- On phones (N)
- 29
- Scheduled
- 42
Half hour: 16:00
- Calls
- 110
- Erlangs (A)
- 22
- On phones (N)
- 27
- Scheduled
- 39
Half hour: 16:30
- Calls
- 100
- Erlangs (A)
- 20
- On phones (N)
- 25
- Scheduled
- 36
Half hour: 17:00
- Calls
- 105
- Erlangs (A)
- 21
- On phones (N)
- 26
- Scheduled
- 38
Half hour: 17:30
- Calls
- 90
- Erlangs (A)
- 18
- On phones (N)
- 23
- Scheduled
- 33
Half hour: 18:00
- Calls
- 85
- Erlangs (A)
- 17
- On phones (N)
- 22
- Scheduled
- 32
Half hour: 18:30
- Calls
- 80
- Erlangs (A)
- 16
- On phones (N)
- 21
- Scheduled
- 30
Half hour: 19:00
- Calls
- 85
- Erlangs (A)
- 17
- On phones (N)
- 22
- Scheduled
- 32
Half hour: 19:30
- Calls
- 65
- Erlangs (A)
- 13
- On phones (N)
- 17
- Scheduled
- 25
Half hour: 20:00
- Calls
- 55
- Erlangs (A)
- 11
- On phones (N)
- 15
- Scheduled
- 22
Half hour: 20:30
- Calls
- 60
- Erlangs (A)
- 12
- On phones (N)
- 16
- Scheduled
- 23
Half hour: Total
- Calls
- 2,400
- Erlangs (A)
- On phones (N)
- 598
- Scheduled
- 864
The "on phones" column adds up to 598 agent-half-hours, which is 299 agent-hours. The raw work is 14,400 ÷ 60 = 240 hours, so meeting 80/20 in every half hour needs 299 ÷ 240 = 1.246, about 25% more. Across the day agents are busy 240 ÷ 299 = 80% of the time. The extra hours are the cost of short waits. The 40 agents in the AHT guide was the base load, as it said.
The scheduled column adds up to 864 half hours, which is 432 hours. Divided by a 9-hour paid shift, 432 ÷ 9 = 48. So 48 people is the floor, reached only if shifts could match the curve exactly.
Real floors cannot. Say there are only three fixed 9-hour shifts, starting at 9:00, 10:00 and 12:00 and ending at 18:00, 19:00 and 21:00. The smallest roster that covers every half hour is 84 people: 26, 26 and 32. We found it by checking every combination. Here is why. The 9:30 slot needs 26 and only the 9:00 shift is in, so 26 start at 9:00. At 11:00 the floor needs 52 and the 9:00 and 10:00 shifts are both in, so 26 start at 10:00. At 19:00 the floor needs 32, but the 9:00 shift has gone home at 18:00 and the 10:00 shift leaves at 19:00. Only the 12:00 shift is left, so 32 people start at noon. From 12:00 to 18:00 all three shifts overlap, so 84 people are in while the table asks for at most 49. That is 84 × 9 = 756 paid hours to cover 432 hours of need.
So Erlang C gives the target for each half hour, and the roster is a separate puzzle. Staggered starts and part-time peak cover close the gap. For the money side, see our guide to call center cost per call in India.
What does Erlang C get wrong?
Erlang C gets five things wrong or leaves them out. It was built for telephone exchanges, not for a team with language skills, abandons and a mix of human and automated answers.
Assumption: Callers never hang up
- Reality
- They do, and long waits make them hang up sooner
- Effect on your headcount
- Overstaffs. Use Erlang A
- Source
- Wikipedia on the Erlang unit; Garnett, Mandelbaum and Reiman 2002
Assumption: Arrivals are random and steady within the interval
- Reality
- Spikes after an SMS blast or an outage; callbacks come back in
- Effect on your headcount
- Understaffs in a surge
- Source
- Wikipedia on limits of the model
Assumption: Every agent takes every call
- Reality
- Language and skill queues
- Effect on your headcount
- Pooling loss: see below
- Source
- Gans, Koole and Mandelbaum 2003
Assumption: Handle times are exponential and the same for all calls
- Reality
- A mix of quick and long calls
- Effect on your headcount
- Can go either way. Re-measure AHT after any change
- Source
- ITU teletraffic handbook, Chapter 12
Assumption: The queue has no limit
- Reality
- Carriers and IVRs cap queues
- Effect on your headcount
- Some calls are blocked, which Erlang B models
- Source
- ITU teletraffic handbook, equation 12.9
On the first row, Wikipedia says the formula "assumes that callers never hang up while in queue, which makes the formula predict that more agents should be used than are really needed" (Wikipedia on the Erlang unit). Garnett, Mandelbaum and Reiman make the same point in research on call centers with impatient customers: the plain models lack the fact that callers may leave before service begins, so they study Erlang A, which adds it (Garnett, Mandelbaum and Reiman 2002). For how abandonment is measured, see what is abandonment rate.
Erlang B, C and A: which one do you need?
Use Erlang C for agents in a single queue, Erlang B for lines, and Erlang A when abandonment is big enough to matter. The difference is what a caller does when everyone is busy.
- Erlang B: the caller is lost. Use it to size lines or trunks.
- Erlang C: the caller waits as long as needed. Use it to size agents.
- Erlang A: the caller waits, but some hang up. Use it to size agents when long waits make people leave.
The ITU handbook links B and C in equation 12.9. The review of call center models by Gans, Koole and Mandelbaum covers Erlang A, pooling and skills-based routing (Gans, Koole and Mandelbaum 2003).
Why do language queues need more agents?
Splitting one queue into language queues needs more agents for the same service level, because a free agent in one queue cannot help a waiting caller in another. We assume the 30 Erlangs of the Pune peak are split by language. The splits below are our assumptions.
Queue structure: One pooled queue
- Load per queue (Erlangs)
- 30
- Agents per queue
- 36
- Total on phones
- 36
Queue structure: Two language queues
- Load per queue (Erlangs)
- 20 and 10
- Agents per queue
- 25 and 14
- Total on phones
- 39
Queue structure: Three language queues
- Load per queue (Erlangs)
- 15, 10 and 5
- Agents per queue
- 19, 14 and 8
- Total on phones
- 41
The split costs 3 agents with two queues and 5 with three, at the same service level. A free agent in one queue cannot fill the gaps in another. This is the pooling effect that Gans, Koole and Mandelbaum describe. The cure is cross-trained, bilingual agents, or overflow rules that let one queue lend to another. That is a multi-skill system, and Erlang C does not model it. If you add a language queue, add agents.
How does an AI voice agent change the calculation?
An automated agent changes the calculation in three ways: it removes some calls from the human queue, it can leave the harder ones behind, and it needs lines of its own. We give only arithmetic here. The inputs are made up, and we do not know any deflection rate for a real floor.
Calls moved out. Say 30 of the 150 peak calls go to an automated agent, which is our assumption. The human queue now has 120 calls at 360 seconds, so A = 120 × 360 ÷ 1,800 = 24 Erlangs, and the headcount falls from 36 to 29.
Harder calls left. The easy calls are the ones that go first. If the 120 calls left have an AHT of 400 seconds, A = 120 × 400 ÷ 1,800 = 26.67 and the headcount is 32, not 29. Moving 20% of the calls removed only 4 of 36 agents. This is the point the AHT guide made: when the mix changes, AHT per call can rise while total cost falls. Re-measure AHT after any change.
Lines. The automated agent needs lines. If it takes the 30 moved calls at 360 seconds each, that is 30 × 360 ÷ 1,800 = 6 Erlangs, so about 6 calls at once on average. Peaks need more lines than the average. If a call that finds every line busy is turned away, the right model is Erlang B, not Erlang C. At 6 Erlangs, 12 lines turn away about 1.1% of calls and 13 lines about 0.5%. We use this only to show how line counts are sized in general. What any given system does with a caller who finds every line busy is a question for that system, and we do not answer it here.
For the wider picture of moving calls to self-service or AI, see IVR vs voicebot, AI customer care in India and AI in BPO. Outbound calling is a different problem: the team chooses when to dial, so see what is an auto dialer.
How Bananaflow fits
What Bananaflow gives you is lines. A line is one call at a time, and as the pricing page shows, Pay as you go gives you 1 line, Growth 2, Scale 5, and Enterprise as many as you agree with us. In the line sums above, that is the number to compare with your Erlang B result. For outbound work, campaigns run from a CSV with a limit on calls at once, up to the limit of your plan.
After each call you get a transcript, a recording, the minutes used and the extracted variables, and the reports show KPIs and trends with CSV export. That gives you the automated side's volume and handle time to feed back into these sums.
What should you remember about Erlang C and staffing?
Work out the load in Erlangs for each half hour, find the agents that reach your service level, then divide by one minus shrinkage. For Pune that is 30 Erlangs, 36 on the phones and 52 scheduled at the peak. Treat 80/20 as a common target and set yours on purpose. Check any calculator against a hand sum like this one, and remember what the formula leaves out: callers who hang up, skills, surges and a changing mix of calls.
FAQ
Frequently asked questions
What is one Erlang equal to?
One Erlang is one line or one agent kept busy for a full hour, or for whatever interval you are measuring. If 150 calls of 6 minutes arrive in a half hour, that is 900 minutes of talk in 30 minutes, which is 30 Erlangs: the work of 30 agents who never pause.
What is the difference between Erlang B and Erlang C?
Erlang B assumes a caller who finds every line busy is lost, so it is used to size lines or trunks. Erlang C assumes that caller waits in a queue for as long as it takes, so it is used to size agents. Erlang A is a third model in which waiting callers may hang up.
Is Erlang C accurate?
It is a good first estimate and a poor last word. It assumes callers never hang up, which makes it predict more agents than a real queue needs. It also assumes steady, random arrivals, so it can undercount a surge after an SMS blast or an outage. Use it for a baseline, then compare with your real service level.
What is a good service level in a call center?
80% of calls answered within 20 seconds is a common target, but it is a convention, not a rule from any standard body. We found no primary source that sets it. Pick the target from what your callers will wait for, and remember that a stricter target costs agents: in our example, 90% in 20 seconds needs 38 agents on the phones instead of 36.
Can I use Erlang C for outbound calls?
Not directly. Erlang C models callers who arrive on their own and wait for an agent. An outbound team chooses when to dial, so the question is how fast to dial, which is a dialer problem. Our guide to the auto dialer covers it.
What is a normal shrinkage figure?
We found no verified benchmark for Indian call floors, so we use 30% in this guide only as our own assumption. Measure yours: add the paid hours lost to breaks, training, meetings, leave and absence over a few weeks, and divide by total paid hours.
Is the Erlang in this guide the programming language?
No. The unit and the formulas are named after the Danish engineer A. K. Erlang, who worked on telephone exchanges. The programming language was named in his honour, but the two are otherwise unrelated, and nothing here needs it.




