Every year for about a decade somebody has announced that voice is dead.
- “Kids do not answer the phone.”
- “Chat is asynchronous and voice is not.”
- “Nobody wants to call a business when they could tap four times in an app.”
Yet contact centers still take an absurd number of calls every year. Turns out, when something has actually gone wrong with your money, your flight, or your kid’s prescription, you usually do not want to fill out a form. You want a PERSON. If you cannot get one, you at least want something that understands why you called.
I have spent most of my career around this stuff. I have built call flows, worked through contact center deployments, and configured more IVR trees than I care to remember. So when somebody tells me voice is dead, I have a hard time buying it.
People do not hate talking to machines on the phone. They hate talking to bad ones. And for most of the history of automated voice, the machine on the other end was pretty bad.
The Machine That Never Understood Anything
In 1966, Joseph Weizenbaum at MIT wrote a program called ELIZA. Its most famous script, DOCTOR, imitated a Rogerian psychotherapist. The trick was simple. A Rogerian therapist often reflects what you say back at you. You say you are unhappy at work. It says, “Tell me more about being unhappy at work.” You say your father never listened. It asks why you think your father never listened.
ELIZA did not understand any of it. It looked for keywords and used templates to turn the conversation back around. Weizenbaum built it partly to show just how shallow that kind of interaction could be.
Then people started confiding in it. His own secretary knew exactly what ELIZA was and had watched him build it. She still asked him to leave the room so she could talk to it privately. Weizenbaum would spend much of the rest of his career pushing back on the field he helped create.
That eventually became known as the ELIZA effect: people seeing understanding where there really is not any. Apparently we have been doing that for a while.
Hearing And Understanding Are Different Problems
When people talk about “voice,” they usually lump two different problems together.
The first one is hearing. Turning sound into words. In 1952, Bell Labs built Audrey, which could recognize spoken digits from one speaker as long as that person paused between each number. Ten years later IBM showed off the Shoebox at the 1962 World’s Fair. It understood sixteen words plus the digits. In the 1970s DARPA funded a large speech understanding effort, and Carnegie Mellon’s Harpy came out of that work in 1976 with a vocabulary of a little over a thousand words.
Then things started moving faster. James and Janet Baker began applying hidden Markov models to speech in the mid-1970s. Instead of trying to write rules for how speech sounded, they treated recognition as a statistical problem. That approach carried the industry for decades. Their company eventually shipped Dragon NaturallySpeaking in 1997, the first continuous-speech dictation product a normal person could buy. It handled around a hundred words per minute, although you had to sit there and read a script first so it could learn your voice.
The second problem was understanding. Once the system had the words, what did you actually want? That part moved a lot slower because the answer, for a very long time, was basically: write more rules.
By the late 1990s, we were getting pretty decent at hearing you. Understanding you was another story.
Press One
Meanwhile, the phone system solved a different problem.
Touch-tone arrived on the Bell System in November 1963. Now the handset could send data instead of just carrying voice. IBM shipped the 7770 and 7772 Audio Response Units in January 1964, which let callers interact with a mainframe using the telephone keypad. By 1973, commercial IVR systems were being used for things like order and inventory control.
Then somebody in accounting figured out what a human minute cost compared with a machine minute.
The phone tree was born.
It is easy to make fun of phone trees now, but at the time they solved a very real problem. If you were a bank in 1985 and wanted a million customers to check balances without hiring a small army of people to answer the phone, “press 1 for checking, press 2 for savings” made a lot of sense. It worked. It was reliable. It never called out sick. The problem is what happened after that. Every branch in the tree exists because the system cannot understand what you are saying. So it makes you break your problem down into a hierarchy that usually looks a lot more like the company’s org chart than the way a customer actually thinks. You do not have a “level two billing inquiry.” You have a problem. But before the system will help, it makes you translate that problem into its routing logic.
Enter the translation tax.
The First System That Asked An Open Question
In 1997, Allen Gorin and colleagues at AT&T published a paper called “How May I Help You?” and deployed the system nationally. Instead of reading callers a menu, it asked an open question and let them answer normally. From there, it tried to figure out what kind of call it was and route it.
What I like about the system is how they built it. They used roughly ten thousand real conversations between customers and operators instead of sitting in a room guessing what callers might say. Seems obvious. The industry then spent a lot of time forgetting and relearning that lesson.
For 1997, it worked surprisingly well. But it was still a router. It could put your call into one of a set of buckets. It could not really have a conversation. It could not remember much. It could not deal very well with you changing your mind halfway through a sentence.
For the next fifteen years, a lot of what we called conversational technology was basically that same idea with more expensive equipment wrapped around it.
The Industrialization Of The Tree
Around 2000, VoiceXML gave the industry a standard way to describe voice dialogs. Vendors could build platforms around it. Enterprises could buy them. This is roughly when the modern contact center voice stack started looking familiar, and it is the world I came into. People outside the industry sometimes imagine these systems were smarter than they were. They were not.
You started by listing every intent the system needed to support. Check balance. Report lost card. Make payment. Speak to an agent. Then you wrote all the different ways somebody might ask for those things. We called those utterances. “I need to pay my bill,” “I want to make a payment,” and “gotta get this bill paid” all mean the same thing to a person. To the system, they were different strings somebody had to account for. Then you defined the information you needed to collect, called slots or entities. Then prompts. Reprompts. Confirmation prompts. Disambiguation prompts. A fallback. Another fallback. And finally the path that sent the caller to a human when the whole thing gave up.
Then you tuned confidence thresholds. Set them too high and the system constantly says, “I’m sorry, I didn’t get that” to people who spoke perfectly clearly. Set them too low and somebody calling about a lost credit card ends up talking to the mortgage department. There was never a magic setting. You tuned it against the calls you had and hoped it behaved when the next batch showed up.
A ridiculous amount of work went into manually building these things. We were trying to map out the customer’s world one utterance at a time. And no matter how much tuning you did, there were always edges you missed. Those edges also happened to be where the angry callers lived.
The Tell From 2001
While the phone people were doing all of that, something weird was happening on desktop computers.
In 2001, a company called ActiveBuddy put a bot named SmarterChild on AIM. Over its life it picked up something like thirty million buddies across AIM, MSN, and Yahoo. At its peak it was handling around a billion messages a month from roughly seventeen million people.
SmarterChild was not especially smart. Most of its answers had been written by humans ahead of time. It was basically a giant lookup table with a personality. But something like 97 percent of the interaction was not people asking for stock prices or movie times. It was teenagers messing with it. Talking to it. Trying to get it to say stupid things.
Thirty million people voluntarily talked to a lookup table for fun. People wanting to talk to machines was clearly not the issue.
The machines were.
The Assistants, And The Command Line With A Microphone
Siri shipped on the iPhone in 2011. Google’s assistant work followed. Alexa showed up in 2014 and put a microphone in tens of millions of kitchens. At the time, it really did feel like the future had arrived.
What we actually got was a command line with a microphone on it.
Think about what worked reliably for most of the next decade. Set a timer. Play music. What’s the weather? Call Mom. Those are simple commands with predictable shapes. You do not need much understanding for that. You need matching. The second you wandered outside that little box, things fell apart. The assistant hit its fallback, told you it did not know how to do that, and eventually you learned what not to ask.
We all figured out the handful of things voice assistants were good at and stayed inside those boundaries. Then we took that experience as evidence that people did not really want voice assistants.
Amazon has been very public about what came next. Satya Nadella called the old Alexa “dumb as a rock” in 2023, which was harsh but not completely wrong, and Amazon then spent years rebuilding Alexa around large language models. The problems were not mysterious. Latency. Old integrations. Teams tuning one piece and hurting another. And a decade of intent-based plumbing that suddenly had to connect to something built in a completely different way. Alexa+ eventually shipped in 2025. Getting there was messy because the old system and the new one were never designed to fit together.
2016, When Everyone Lost Their Minds About Chatbots
If you were anywhere near this industry in 2016, you remember this nonsense.
Facebook opened Messenger to bots in April. By November, there were more than 34,000 of them. Every conference suddenly had a conversational commerce track. Every company needed a bot. Apparently we were all going to order pizza, book flights, buy shoes, and handle the rest of our lives by chatting with brands. Apps were finished.
It took about a year and a half for everybody to figure out that this was not going especially well. Reporting in early 2017 put Facebook’s bot platform at around a 70 percent failure rate on user requests. Most things people asked still needed a human.
Facebook’s own assistant, M, was probably the cleanest example. M launched in 2015 as a hybrid. AI handled what it could and humans quietly stepped in when it could not. In practice, the humans did a lot of the work. M was shut down in January 2018.
That is probably the most honest artifact from the whole chatbot era. When the “AI” got confused, there was a person hiding behind the curtain fixing it. That works right up until you have to do it at scale.
Everybody came away saying chatbots did not work. The actual problem was simpler. Rule systems pretending to have conversations did not work. And in 2016, that was basically what everybody had.
Why The Intent Paradigm Was Never Going To Get There
The old architecture explains a lot of why these systems felt so bad.
The basic flow was simple enough. Recognize the speech. Turn it into text. Classify that text into one of a predefined set of intents. Extract some entities. Run business logic. Read a response back from a template. Most of those steps were separate components, often from different vendors. Every handoff was another chance to screw something up.
Start with recognition. Telephone audio is not great. It is compressed, narrowband audio coming from somebody who might be driving down the highway with the window open. Get one important word wrong and now the classifier is making a decision based on the wrong sentence. The speech recognizer might know it was not very confident. The rest of the system usually had no idea.
Then classification. The system only knew about intents somebody had defined ahead of time. If your problem was not on the list, the system basically could not see it. Maybe you got a fallback. Maybe it confidently sent you to the wrong place. Adding more intents did not always make things better either. Eventually they started stepping on each other and you spent your time trying to teach the system the difference between two things a human would never confuse.
Then there was state. These systems had very little memory outside whatever path somebody had designed. “Actually, go back.” “No, the other card.” “Like I said earlier.” Those are normal things to say to a person. They were not normal things to say to an IVR.
And then there is repair. Human conversations are messy. We mishear things. We correct ourselves. We change our minds. We say, “Sorry, I meant the blue one,” or, “No, next Thursday.” We infer context without thinking about it. If I say “the fifteenth” after we have been talking about October, you know what I mean. An intent system was terrible at this because it did not really have a conversation in its head. It had a current node and a confidence score.
You could tune that system forever. You were still tuning around the limits of the architecture.
Three Things Changed, And Only One Of Them Gets Talked About
What we have now did not happen because of one breakthrough. Three major things changed.
Hearing got solved, more or less. Microsoft hit a 5.9 percent word error rate on the Switchboard conversational-telephone benchmark in 2016 and called it human parity. It reached 5.1 percent in 2017. You can argue about the benchmark if you want. The important part was what happened afterward. Models trained on huge amounts of messy real-world audio started handling accents, noise, and different domains without every deployment turning into another tuning exercise.
Understanding stopped requiring an ontology. This is the part I think matters most. A language model does not need somebody to sit down and write every possible way a caller might ask for something. You tell it what job it has, what tools it can use, and what rules it needs to follow. The caller can then say something nobody explicitly wrote down ahead of time and the system still has a shot at understanding it. You still have to design the experience. You just do not have to guess every sentence a human might say.
Speaking stopped sounding like a robot. Older text-to-speech sounded synthetic because it was. You could hear the seams. Modern neural speech is dramatically better. That matters more than it sounds like it should because tone changes meaning. “Okay.” “Okay?” “Okay…” Those are three different responses even though the word is identical.
There is another part of this that matters just as much: latency.
The traditional pipeline is speech to text, text to model, model back to speech. Every one of those steps takes time. You might spend 100 to 300 milliseconds recognizing speech, another few hundred milliseconds or more waiting on the model, then more time generating speech, plus whatever the network adds. Now the caller has stopped talking and a second or more has gone by.
On paper, that does not sound terrible. On a phone call, it feels weird.
People start talking over the system because they think nothing is happening.
Modern speech-to-speech models can cut some of that delay by working with audio more directly. Get response time under roughly 400 milliseconds and the whole thing starts feeling a lot less like a walkie-talkie.
The Demo Everyone Was Mad About
In May 2018, Google demoed Duplex at I/O. It called a restaurant and a hair salon to make appointments. The system paused. It said “mm-hmm.” It sounded human enough that the audience treated it like a magic trick. Then everybody realized the person answering the phone did not seem to know they were talking to a computer, and the conversation changed very quickly. Google later added disclosure to the product.
The ethics argument was absolutely worth having. But there was another part of that demo that did not get nearly as much attention: it made the voice systems most companies were deploying at the time look ancient.
What Is Actually Different, In Practice
Forget the demos for a second. The difference shows up in pretty normal calls.
You can tell the system something once and have it use that information later. If you give it your account number at the start of the call and then get transferred, that information can go with you. Spending twenty years making customers enter the same account number three times in one call was not some brilliant policy decision. The systems were just bad at carrying context.
You can also say two things in one sentence. “I need to move my Thursday appointment and my card on file expired.” An old IVR wants you to pick one. Finish that. Start over. A modern system has a much better chance of understanding that you have two things you need help with.
You can correct it. “No, the other Thursday.” “Actually make it afternoon.” “Sorry, I gave you the wrong number.” These are tiny things, but they are a huge part of what makes talking to another person feel easy.
It can also admit when it is stuck. A good deployment hands the call to a person along with the information it already collected. That sounds basic until you remember how many years we spent transferring callers to an agent who immediately asked them to start over.
And you do not necessarily need a release cycle every time customers start asking about something new. If the agent has access to the information and the right tools, it has a much better chance of handling something nobody explicitly built a flow for six months ago.
Why It Is Voice Specifically That Survives
So why does any of this matter specifically for the phone?
Speech is fast. Most people can talk much faster than they can type on a phone, and they can definitely talk faster than they can hunt around an unfamiliar app looking for the right menu.
Speech also works when your hands and eyes are busy. Driving. Cooking. Carrying a kid. Standing in front of a piece of equipment with both hands occupied. You get the idea.
And the phone number may still be the most universal API we have. No app to install. No account to create. No password reset. No onboarding flow. You dial a number and somebody, or something, answers.
A lot of the economy still works this way. Home services. Healthcare scheduling. Logistics. Restaurants. Property management. Insurance claims. Government offices. In plenty of those businesses, the call is the transaction. Miss the call and you may have just lost the customer. Gartner has forecast conversational AI cutting around $80 billion from contact center labor costs by the end of this year. Forecasts are forecasts, but there is clearly a lot of money betting that this matters.
What Still Does Not Work
None of this means voice AI is suddenly perfect.
Latency is still a real problem once the agent has to touch other systems. Getting a fast model response is one thing. Then you ask it to look something up in a CRM that takes 900 milliseconds on a good day and now you are back to dead air. On a website, at least you get a spinner. On a phone call, silence makes people think something broke.
Barge-in is still hard too. People interrupt constantly. Sometimes “mm-hmm” means keep going. Sometimes it means stop because I need to say something. Humans deal with that naturally. Machines still get weird about it.
High-stakes accuracy is an even bigger issue. A system that confidently gives you the wrong balance, dosage, or policy information is worse than a dumb menu. “Usually right” is not good enough in those situations. That is why the good systems use real tools and tightly control what the model is allowed to answer.
Recording, consent, and disclosure rules vary by state and country and keep changing, for good reason.
Accents, code-switching, speech differences, and background noise are all better than they were. None of them are solved. If your entire test set is people sitting in a quiet conference room who sound exactly like the product team, you did not test much.
Where I Think This Goes
I think the phone tree is going to die. Maybe not tomorrow, but I do not see much of a reason for it to survive long term. It was built around a machine that could not understand a normal sentence. That limitation is going away. Once that happens, “press 1 for this, press 2 for that” starts looking pretty ridiculous.
The hard part moves somewhere else. What is the agent allowed to do? What systems can it access? What requires verification? When should it stop and send the call to a human? How do you know it actually did what it said it did? Those are operations questions more than IVR questions.
The people who will be good at this are not necessarily the people who were best at tuning grammars. They are the people who understand what should actually happen when somebody calls at 2 a.m. because the furnace is broken.
I have been in this industry long enough to ship things I was not especially proud of because the tools available made a bad experience the only affordable one.
That excuse is getting harder to use.
The technology is finally good enough that a terrible voice experience is starting to look less like a technical limitation and more like a decision somebody made.