AI agents don’t hang up. Your capacity plan assumes somebody does.

Personal AI agents are already browsing, booking and contacting businesses on behalf of their owners. Two competing protocols for how those agents identify themselves and get permission were published on the same day in October 2026. One of them, the Personal Agent Protocol, now goes by Poppy and reached version 1.0 in November, with Genesys and NiCE among the companies listed as design partners. Its version 1.0 text covers discovery, identity, account access and interactions across APIs, web browsing and conversations with a company’s own agent, carried as JSON over HTTPS.

Those routes are not the only way in, and the people building them say so. Sierra’s own argument for a direct connection is that an agent driving a website the way a person does can fail or take a long time, and that what happens next is a call or a web chat. The failure mode of the new front door is traffic in your queue, placed by software, for a customer who never dialed.

That work matters, and I’ve been thinking about a part of it that isn’t getting much attention. What happens to your capacity plan when the caller is software?

A software caller can wait without getting impatient. It can still time out, hit a spending limit or be told to stop, but those limits may look nothing like the abandonment patterns in your historical data.

Genesys put the same thing from the other side this month. Mike Szilagyi, their head of product, writing about personal AI arriving at the enterprise: “Unlike people, it doesn’t get tired or frustrated enough to abandon the task.” Note what that sentence is about. He’s describing persistence at the level of the task, not the call. An agent can time out of one call and redial a minute later without ever giving up on what it was sent to do. That isn’t infinite patience. It’s a different patience profile with a retry pattern on top, and the two need separating before either goes into a model.

That makes it a contact center capacity planning problem as much as an AI one. We’ve spent years sizing queues around how people behave, and software can wait, retry and open parallel sessions differently. The question is how much of that your current plan can absorb. The system producing this traffic also sits outside your environment. You may have little sight of how it’s configured, and little say in how it behaves. What you can do is find out what your side does when it arrives.

There are six assumptions I’d revisit before software-originated traffic becomes commonplace. None of them is a guaranteed failure, and each is worth testing.

I’ll start with queueing, because the math already has an answer.

What does a software caller change about capacity planning?

Capacity plans calibrated to observed abandonment can look very different when callers become more persistent.

Two queueing models help explain why. Erlang C, which most capacity planning grew up on, assumes a caller waits indefinitely. Erlang A gives each caller a patience, so a proportion abandon before anyone answers them. Garnett, Mandelbaum and Reiman illustrated the difference with a worked example, in a 1999 manuscript later published in 2002.

Their worked example runs fifty agents against forty-eight calls a minute, with a one-minute average service time and two minutes of average patience. Then it runs the same traffic twice, once with patience in the model and once without.

Measure Without abandonment With abandonment
Average speed of answer20.8 seconds3.6 seconds
Ninetieth-percentile wait58.1 seconds12.5 seconds
Calls waiting173
Agent utilization96%93%
Abandonment0%3.1%

It cuts both ways. A model that ignores abandonment predicts longer waits than you’ll see, so it sizes up. The authors put that in terms of our own tooling: “using workforce management tools that ignore abandonment would result in over-staffing”, “as actually fewer agents are needed in order to meet most abandonment-ignorant service goals”. If you sized on Erlang C, you’re carrying some cushion.

There’s another distinction behind those numbers. In their model the version with abandonment is “stable for all parameter combinations”, while “the classical model achieves statistical equilibrium if and only if R < N”, meaning offered load below the number of agents. So patience in the model lets a queue settle even when arrivals exceed the rate you can serve. That isn’t good news. It settles because some of the demand leaves without being served.

Abandonment acts as the pressure relief, and your service levels, your occupancy targets and your forecasts are calibrated against history in which a share of callers walked away. Change the patience profile and you change the queue, even when the arrival rate and the staffing stay exactly where they are. Whether an agent-driven queue gives that relief back is a property of the agent rather than of your platform, which is why it wants testing rather than assuming.

What happens when software retries instead of redialing?

Software can retry on a common schedule, and without randomized delays those retries can arrive in clusters.

AWS has documented the problem in distributed systems. Clients backing off on the same schedule keep colliding, and adding jitter, meaning randomness in the retry delay, spreads the attempts out. In Marc Brooker’s simulation with a hundred contending clients it cut the call count by more than half. That simulation is clients contending to update shared state rather than a contact center queue, so take the mechanism from it and not a number. A well-built agent will add jitter, and plenty will. Nobody writing one is obliged to, though, and you don’t get to inspect it from your side of the call.

The behavior itself isn’t hypothetical. Szilagyi again, in the same piece: personal AI agents “can research options, negotiate and return until they complete the task.” Returning until the task is done is a retry pattern, described by a company building the front door for it.

Which leaves two questions for your own path. Can you recognize the repeated request, and can the system stop it creating two callbacks, two cancellations or two payments?

Why can agent traffic arrive as a step?

Agent traffic can be triggered rather than decided, so it can arrive as a step where a human peak traces a curve.

People arrive in sharp bursts too, and anybody who has watched a product recall land knows it. What software adds is the possibility that a large number of callers respond to the same event with almost no human delay between the notification and the action. One delay notice, one price change, one outage message, and agents could act on behalf of owners who are asleep.

Illustration showing the difference between human response and software response in the contact center

Illustrative only, not measured volumes.

If you already model your arrival curve properly for IVR load testing, you have the machinery for this. What changes is the shape you feed it, and the fact that somebody else’s scheduler now sets that shape.

Can one customer be several sessions at once?

One customer can create several concurrent sessions if their agent is allowed to try more than one channel at a time.

A person usually picks the phone or the chat. A software caller could open the web session, the chat and the call together, use whichever answers first and drop the others. The number of customer intents hasn’t changed. The number of active sessions has, and so has the work your environment is holding open while it waits.

What happens to the timing thresholds?

Machine-paced speech can expose timing thresholds that worked for human callers.

Barge-in, inter-digit timeout, prompt timeout, silence detection and end-of-speech detection were all set by watching how long a person pauses. So test both ends: an immediate response that overlaps the prompt, and a delayed response that trips a silence timeout. A threshold that’s wrong doesn’t only produce a bad call. The interaction fails, repeats or runs long, and that changes both the traffic you get and how much of your environment each one ties up.

Does a software caller change your average handle time?

Average handle time is the other number your capacity model runs on, and a software caller can move it in either direction.

Everything above is about how calls arrive. Handle time is about what happens once they are connected, and it feeds the same model. Erlang takes an arrival rate, a service time and a number of agents, and we have looked at two of the three.

A software caller might be quicker. No hesitation, no hunting for an account number, no small talk, and it answers a prompt the moment the prompt finishes. It might also be slower, if it reads values back to confirm them, works through options a person would have skipped, or waits while it checks something with whoever sent it.

I don’t know which way it goes, and I’d be wary of anyone who says they do. Your current average handle time was measured on human callers, and your occupancy and your staffing are both derived from it. If the mean moves, or if the shape of the distribution moves while the mean stays where it is, the queue behaves differently at the same arrival rate. The basic Erlang calculation assumes a particular shape for service times, so that second case is one you answer by simulating or measuring it. Running the same formula with a new average won’t show it.

This is the same machine pacing as the timing thresholds above, measured for a different consequence. A threshold either breaks or it doesn’t. Handle time changes the arithmetic without breaking anything.

So what do you actually do?

Size for the peak you could be given and for the behaviors that come with it, then test both before the traffic arrives.

We’ve done exactly that. Ahead of a migration for a large government agency, the forecast peak was 41,000 concurrent inbound calls, and we ran 41,000 concurrent calls against it before go-live, at 100 call attempts a second. Nobody had seen that number on a live day. That was the point. You want to know the system holds at the number you could be given, while there is still time to do something about it. That was our customer’s working number, not our limit. We scale to the number you need.

One action for each assumption.

Recalculate caller patience. Work across several assumptions, including much lower abandonment, with zero as the stress case rather than the forecast. Hold arrivals and service times constant first, so you can isolate the effect.

Define what a repeat attempt means. Write down, per interaction type, whether a second arrival inside a minute is the same intent or a new one, and what the system should do about it. Then test that it does.

Test a sudden arrival spike. Add a step-load scenario to your existing ramp tests. A profile that goes from quiet to peak in a minute is what a triggered event looks like, and it belongs alongside the realistic ramp rather than in place of it. A common finding when we run these is that what gives way is a configured limit and not a saturated resource: a carrier channel or calls-per-second cap, an IVR concurrent session cap, a bot concurrency ceiling set during the pilot and never revisited, or a text-to-speech quota shared across environments. A configured limit refuses cleanly at exactly the number it was given, while the platform reports itself healthy, because it’s doing what it was told to do. A ramp that stops short of that number never meets it.

Test parallel sessions from one customer. Open several at once for a single test customer and check the resource cost, whether the repeats are correlated, and whether the unused sessions get cleaned up once one route succeeds.

Re-measure the timing thresholds. Run them under machine pacing, against a caller that answers instantly and one that pauses twice as long as a person.

Re-measure handle time under machine pacing. Run the same interactions against a caller that answers instantly and never hesitates, and compare the distribution rather than only the mean. Then put what you find back into the capacity model, rather than leaving the human average sitting in it.

One practical note before you book any of it. Automated load testing against a live platform normally needs your vendor’s approval first, so check what they require and get the request in ahead of the window. Some platforms want a couple of weeks, and the window you’re offered may be out of hours in the region. Unannounced load traffic can read as an attack from the platform’s side, with the response an attack gets.

These are all scenarios you can run before the traffic arrives. Generate the calls, vary their patience and their timing, and keep a record of what happened through the environment rather than a summary of it. That’s what synthetic testing is for. The caller is synthetic. The test is real. The evidence is independent.

I’m a car person, so I think about it as traffic. You don’t need to reach a road’s theoretical capacity to jam it, because how the drivers behave changes what the road can carry. Nobody has changed the number of lanes.

What share of your service level is currently being paid for by callers who hang up?

Frequently Asked Questions

Next
Next

How to Choose a Platform for Testing Conversational AI in Customer Service