# Erlang B vs Erlang C: How Many Lines vs How Many Agents

> Erlang B tells you how many phone lines or SIP channels you need; Erlang C tells you how many agents. A worked example from 200 busy-hour calls to lines and agents.

Source: https://edesy.in/blog/erlang-b-vs-erlang-c-lines-vs-agents-2026

**Erlang B tells you how many lines you need; Erlang C tells you how many agents you need.** Use Erlang B
when a call that finds everything busy is lost (busy tone, failed connect), which is how phone lines, SIP
trunk channels and IVR ports behave. Use Erlang C when callers wait in a queue for the next free person,
which is how an agent team behaves. Most contact centers need both, in that order: agents first, then lines.

> **Run the numbers:** [Erlang B calculator](https://edesy.in/tools/erlang-b-calculator) for lines and trunks,
> [Erlang C calculator](https://edesy.in/tools/erlang-c-calculator) for agents. Both run in your browser, no signup.

## Same input, two different questions

Both formulas start from the same number: **busy-hour traffic in erlangs**.

```
Traffic (erlangs) = calls in the busiest hour x average call minutes / 60
```

One erlang is one line (or one agent) busy for a full hour. Then the two models split:

| | Erlang B | Erlang C |
|---|---|---|
| What happens when all are busy | Call is blocked and lost | Caller waits in a queue |
| What it sizes | Lines, SIP channels, IVR ports, concurrent calls | Agents |
| Main target | Blocking (grade of service), e.g. 1% | Service level, e.g. 80% answered in 20 s |
| Other outputs | Blocked calls per hour | Average speed of answer, occupancy |
| Typical use | Ordering trunks, sizing an IVR or voice bot | Rostering a support or sales team |

## Worked example: 200 calls an hour, 3 minutes each

A support line takes **200 calls in its busiest hour**, and each call lasts **3 minutes** on average.

```
Traffic = 200 x 3 / 60 = 10 erlangs
```

### Step 1: lines with Erlang B

Open the [Erlang B calculator](https://edesy.in/tools/erlang-b-calculator), leave **Calls and duration** selected, enter 200
calls and 3 minutes, and pick **1% (1 in 100 calls)** as the target blocking. It shows **18 lines needed**,
with actual blocking of about 0.71% at that count, or roughly 1.4 blocked calls in the busy hour.

Why 18 and not 10? Because ten erlangs is the average. Calls arrive at random, so some minutes have 13, 15
or more calls in progress at once. The table in the tool shows the same traffic at every blocking target:

| Target blocking | Lines needed | Actual blocking |
|---|---|---|
| 0.1% | 21 | 0.09% |
| 0.5% | 19 | 0.37% |
| 1% | 18 | 0.71% |
| 2% | 17 | 1.29% |
| 5% | 15 | 3.65% |

If you type **15** into **Lines you have now (optional)**, the tool reports you are 3 lines short, with about
3.65% of calls blocked, which is around 7 callers in that hour getting a busy signal.

### Step 2: agents with Erlang C

Now assume those calls go to people, and callers wait in a queue rather than hearing a busy tone. In the
[Erlang C calculator](https://edesy.in/tools/erlang-c-calculator) the default inputs describe the same traffic in a
30-minute interval: **100 calls per period**, **30 minutes**, an **Average Handle Time** of 180 seconds.
100 x 180 / 1,800 = 10 erlangs, exactly as above.

With the other defaults (target answer time 20 seconds, target service level 80%, maximum occupancy 85%),
the Erlang C formula works out like this. We computed it with the same recursive formula the tool uses:

| Agents on calls | Chance a caller waits | Answered within 20 s | Average wait | Occupancy |
|---|---|---|---|---|
| 12 | 44.9% | 64.0% | 40.4 s | 83.3% |
| 13 | 28.5% | 79.6% | 17.1 s | 76.9% |
| **14** | **17.4%** | **88.8%** | **7.8 s** | **71.4%** |
| 15 | 10.2% | 94.1% | 3.7 s | 66.7% |

Thirteen agents misses 80% in 20 seconds by a fraction, so the answer is **14 agents on the phones**. Those
are productive agents. With the default shrinkage of 30% (breaks, training, absence), the roster is
14 / (1 - 0.30) = 20, rounded up, so **20 agents scheduled**. The tool reports this as Agents required: 20,
with "14 productive + shrinkage". For how to work out your own shrinkage, see
[call center KPI formulas](https://edesy.in/blog/call-center-kpi-formulas-aht-fcr-abandonment-shrinkage-2026).

### Step 3: back to lines, including the queue

A caller who is waiting in a queue is still holding a line. So the lines behind an agent team carry
handle time plus wait time. In this example the average wait is 7.8 seconds:

```
Line traffic = 200 x (180 + 7.8) / 3,600 = 10.43 erlangs
```

At 1% blocking that is still 18 lines, right at the edge. If your service level slips and average waits grow
to a minute or more, line traffic rises with it, so leave a few spare lines rather than ordering exactly
the minimum. The Erlang C tool's "Trunks needed" figure uses handle time only, so treat it as a floor.

## Which one should you use?

- **Ordering SIP trunk channels or PRI lines:** Erlang B.
- **Sizing an IVR or AI voice bot:** Erlang B. The bot answers every call itself, so the line count is the
  concurrency it must support.
- **Rostering human agents:** Erlang C, then add shrinkage.
- **A contact center with a queue:** Erlang C for agents, then Erlang B (with wait time added) for lines.

## Common mistakes

1. **Using a daily average.** 2,000 calls a day is not 200 an hour if half of them land between 10 and 1.
   Always use the busiest hour from an hourly report.
2. **Using Erlang B for agents.** It assumes blocked callers vanish, so it under-staffs a queue.
3. **Forgetting redials.** Both models assume a blocked or abandoned caller does not call straight back.
   If many do, real traffic is higher than you entered.
4. **Skipping shrinkage.** Erlang C gives agents logged in and taking calls, not headcount.

## Put the lines to work

If the busy-hour peak is mostly routine (order status, hours, balance, appointment changes), an IVR can
answer every one of those 18 concurrent calls with menus and routing, and only pass the rest to agents.
For running costs, see the [IVR cost calculator](https://edesy.in/tools/ivr-cost-calculator) and the
[IVR setup guide for India](https://edesy.in/blog/how-to-set-up-ivr-system-india-2026). Bringing your own trunk? Compare
options in [SIP trunk providers in India for AI calling](https://edesy.in/blog/sip-trunk-providers-india-ai-calling-2026).

- **IVR:** [Set up an Edesy IVR](https://ivr.edesy.in/?utm_source=edesy.in&utm_medium=blog&utm_campaign=erlang-b-vs-erlang-c-lines-vs-agents-2026).
  Start free: INR 20 credit on sign-up, no card needed.
- **AI voice agent:** an agent that talks callers through routine requests can take many calls at once, so
  the Erlang B line count is the concurrency to plan for.
  [Try Edesy Voice Agent](https://voice-agent.edesy.in/?utm_source=edesy.in&utm_medium=blog&utm_campaign=erlang-b-vs-erlang-c-lines-vs-agents-2026).

## Frequently Asked Questions

### What is the difference between Erlang B and Erlang C?

Erlang B assumes a call that finds every line busy is lost (the caller hears a busy tone), so it sizes lines, SIP trunk channels and IVR ports. Erlang C assumes the caller waits in a queue for the next free agent, so it sizes agents against a service level target.

### How many lines do I need for 200 calls an hour of 3 minutes each?

200 calls x 3 minutes / 60 = 10 erlangs. At 1% blocking, Erlang B gives 18 lines. With 15 lines, about 3.65% of busy-hour calls would be blocked.

### Why do I need more lines than my average traffic?

Calls arrive at random, not evenly. Ten erlangs means ten lines busy on average, but in many minutes of the hour more than ten calls overlap. The extra lines cover those peaks.

### Should I use Erlang B or Erlang C for an IVR?

Erlang B. An IVR or voice bot answers calls itself, so the question is how many calls it must handle at the same time. If calls are later handed to agents who have a queue, size those agents with Erlang C.

### Does Erlang C include shrinkage?

The formula itself does not. It gives the agents who must be logged in and taking calls. Divide by (1 - shrinkage) to get the number to roster, which the Edesy Erlang C calculator does for you.
