Skip to content
Tutorials Center
My learning

Topics

Lesson 32 of 49 Ā· Queueing and Simulation

Several Servers: The Erlang C Model

Staff a call center or checkout bank with the M/M/c queue: compute the Erlang C probability of waiting, average wait, service levels and the gain from pooling.

Real service rarely has one server. A call center has dozens of agents, an airport has rows of check-in desks, a hospital has several operating rooms. If all servers draw from one shared line, the system is an M/M/c queue, and its main formula is named after Agner Krarup Erlang, the Danish engineer who studied telephone exchanges in Copenhagen in the early 1900s. His work is still the foundation of call-center staffing today.

This lesson gives you the Erlang C formula, shows how to use it to pick the number of agents, and explains a surprising effect: pooling servers into one line shortens waits dramatically.

Three staffing levels compared for a help line
Caption: With 10 calls an hour and agents who handle 4 calls an hour, going from 3 to 4 agents cuts the average wait from over 21 minutes to about 3, and a fifth agent brings it below a minute.

What you will learn

  • What the M/M/c model assumes and what offered load (in Erlangs) means.
  • How to compute the Erlang C probability that an arriving customer must wait.
  • How to find the average wait and the chance of waiting longer than a target time.
  • Why one shared line beats several separate lines.

Key terms

Offered load (a): a = λ/μ, the average amount of work arriving, measured in Erlangs (the number of servers that would be kept exactly busy).

Utilization: ρ = a / c, the fraction of time each server is busy; the system is stable only when ρ < 1.

Erlang C, C(c, a): the probability that an arriving customer finds all c servers busy and must wait.

Service level: a target such as "80 percent of calls answered within 20 seconds".

Pooling: serving everyone from one shared queue instead of separate queues.

The model

Arrivals are Poisson with rate λ. There are c identical servers, each with exponential service at rate μ, and one shared line served first come first served. Let a = λ/μ and ρ = a/c < 1.

The probability that an arriving customer has to wait is the Erlang C formula:

C(c, a) = [ (aᶜ / c!) Ā· 1/(1 āˆ’ ρ) ] / [ Ī£_{k=0}^{cāˆ’1} aįµ/k! + (aᶜ / c!) Ā· 1/(1 āˆ’ ρ) ]

It looks intimidating, but each piece is simple. The terms aįµ/k! are the relative chances of k busy servers in a world where nobody has to wait; the last term lumps together all states with c or more customers. Once you have C(c, a):

Measure Formula
Average wait in line Wq = C(c, a) / (cμ āˆ’ Ī»)
Average number waiting Lq = Ī» Ā· Wq
Average time in system W = Wq + 1/μ
Chance of waiting more than t P(Wq > t) = C(c, a) Ā· e^{āˆ’(cμ āˆ’ Ī»)t}

A worked example: the help line

A help line receives λ = 10 calls per hour, and each agent handles μ = 4 calls per hour (15 minutes per call). The offered load is a = 2.5 Erlangs, so you need more than 2.5 agents just to be stable.

With c = 3 agents: ρ = 0.833. The terms are 1 + 2.5 + 3.125 = 6.625 for k = 0, 1, 2, and the last term is (2.5³/3!) / (1 āˆ’ 0.833) = 2.604 Ɨ 6 = 15.625. So C = 15.625 / (6.625 + 15.625) ā‰ˆ 0.702: seven callers in ten wait. The average wait is 0.702 / (12 āˆ’ 10) = 0.351 hour, about 21 minutes.

With c = 4, C ā‰ˆ 0.32 and the wait falls to about 3.2 minutes. With c = 5, C ā‰ˆ 0.13 and the wait is under a minute. One agent more turns a crisis into a fine service. That nonlinearity is why staffing needs calculation and not just a rule of thumb.

Try it

Compute Erlang C yourself, find the smallest staffing level that meets a service-level target, and compare with a simulation.

Python Erlang C staffing calculator

Press Run (or Ctrl + Enter) to see the result here.

Program input Ā· what you'd type while the program runs

Type the answers before you press Run, one per line. Each time the program reads a line (with input()), it gets the next line from this box.

Here the offered load is a = 6 Erlangs. You need at least 7 agents to be stable, but meeting the 80/20 target takes 9, because the target limits individual waits and not just the average.

The power of pooling

Imagine a store with two checkouts. In design A, each checkout has its own line, and arrivals pick one at random: that is two M/M/1 queues, each with λ = 4 and μ = 5 per hour. In design B, both checkouts take customers from a single line: an M/M/2 queue with λ = 8 and μ = 5.

  • Design A: ρ = 0.8, and Wq = ρ/(μ āˆ’ Ī») = 0.8/(5 āˆ’ 4) = 0.8 hour, i.e. 48 minutes.
  • Design B: a = 1.6, C(2, 1.6) = 0.711, and Wq = 0.711 / (10 āˆ’ 8) = 0.356 hour, about 21 minutes.

Same staff, same customers, same speed, and less than half the wait. In design A, one checkout can sit idle while customers stand in the other line. Sharing the line prevents that waste. That is why banks and airports use a single serpentine line.

Pooled line versus separate lines

Set c = 1 and you will see the two numbers agree, since one server has nothing to pool. As c grows, the gap widens. The benefit of pooling is largest when the system is heavily loaded.

What Erlang C leaves out

Erlang C assumes that customers never give up. Real callers hang up after a while, which is why call centers also use Erlang A (with abandonment) or simulation. The model also assumes exponential talk times and a constant arrival rate; real arrival rates change by the hour, so staffing is computed for each half-hour. Use Erlang C as the starting point and the fast check, then use simulation for details like breaks, skills and priorities.

The square-root staffing rule

Staffing teams use a handy approximation for large call centers. If the offered load is a Erlangs, the number of agents needed to keep waiting small is about c ā‰ˆ a + β√a, where β is a constant, usually between 0.5 and 2, that grows with the service level you want. The extra agents beyond the load, β√a, grow only with the square root of the load. A center with 4 Erlangs of load needs perhaps 2 extra agents (50 percent more); a center with 100 Erlangs needs about 10 extra (10 percent more). This is the pooling effect again: big centers run at higher utilization while keeping the same service level.

Check it on the help-desk numbers: for a = 6 Erlangs (120 calls an hour with 3-minute calls), the 80/20 target needed 9 agents, which is 6 + 1.2 Ɨ √6 ā‰ˆ 8.9. The rule is only an approximation, but it explains why a merger of two call centers can handle the same traffic with fewer agents, and why splitting one center into regional teams without sharing calls raises costs.

Practical advice

  • Compute staffing per interval (often 15 or 30 minutes) because arrival rates change through the day. Averages over the whole day mislead.
  • Use Erlang C as a first estimate; then adjust for abandonment, breaks, training and skills by simulation.
  • State the service-level target precisely. "80 percent in 20 seconds" and "average wait under 20 seconds" are different promises and need different staffing.

Common misconceptions

"Adding one server always helps by the same amount." The first server beyond the offered load helps enormously; later ones give diminishing returns.

"Separate lines are fine if the servers are the same." Pooling lowers waits at the same cost. Separate lines can leave a server idle while others have a queue.

"Utilization of 90 percent in a big center is as bad as in a small one." Large pools tolerate higher utilization (the square-root staffing rule: spare capacity needed grows like √a, not like a). This is a pooling benefit.

Check your understanding

Quick check Ā· 5 questions

of 5 answered You scored / 5 Ā· perfect!

  1. 1. λ = 18 per hour and μ = 6 per hour. What is the offered load in Erlangs?

    a = λ/μ = 18/6 = 3 Erlangs, so more than 3 servers are needed for stability.
  2. 2. What does the Erlang C formula give?

    C(c, a) is the probability that all c servers are busy when a customer arrives.
  3. 3. C(c, a) = 0.4 and cμ āˆ’ Ī» = 8 per hour. What is Wq?

    Wq = 0.4/8 = 0.05 hour, which is 3 minutes.
  4. 4. Why does a single shared line beat separate lines with the same servers?

    Pooling lets any free server take the next customer, which wastes less capacity.
  5. 5. Which assumption of Erlang C is often unrealistic for call centers?

    Real callers hang up when they wait too long; Erlang A and simulation include that.

Summary

  • M/M/c has c servers sharing one line; offered load a = Ī»/μ must be below c.
  • Erlang C gives the waiting probability; Wq = C/(cμ āˆ’ Ī») and P(Wq > t) = CĀ·e^{āˆ’(cĪ¼āˆ’Ī»)t}.
  • Staffing targets are set by service levels, and one extra agent can change waits drastically.
  • Pooling servers into one line cuts waiting at no extra cost.

Next: Discrete-event simulation