Hamming Is Building the QA Layer for the Voice-Agent Era
A year ago, an AI on the phone was a novelty you tolerated until you could mash zero and reach a human.
That's no longer true. AI voice agents are now booking appointments, taking drive-through orders, qualifying insurance claims, screening loan applications, and handling first-line support for banks and hospitals. The models got good enough—fast enough, natural enough, cheap enough—that companies stopped piloting them and started routing real customers through them. Millions of live conversations a day now happen between a person and a piece of software that talks back.
Which raises a question most teams are not equipped to answer: how do you know the agent actually works?
Not "did it work in the demo." Works when the caller has a thick accent. Works when a toddler is screaming in the background. Works when someone interrupts mid-sentence, changes their mind twice, and then asks a question the prompt never anticipated. Works when a bad actor tries to talk it into waiving a fee or leaking another customer's data. Works at 2 a.m. across ten thousand simultaneous calls without quietly degrading.
For traditional software, we have an entire discipline for this. Unit tests, integration tests, load tests, CI pipelines, monitoring, alerting. For voice agents, most teams have a founder calling their own phone number a few times before shipping and hoping for the best.
That gap is exactly what Hamming is built to close.
Hamming is the complete QA platform for voice agents—from pre-deployment testing to production monitoring. It automatically generates hundreds of realistic test scenarios from your agent's own prompt, runs them as simulated phone calls in parallel, scores what happened, and then keeps watching every real call once you're live. To date the platform has tested more than four million calls and monitors over ten thousand agents in production.
The Name Is the Thesis
It's worth pausing on where the name comes from, because it's not decoration.
The company is named after Richard W. Hamming, the Bell Labs mathematician who in 1950 invented Hamming codes—a family of linear error-correcting codes that let a system detect and fix bit errors as data moves through a noisy channel. Hamming's insight was that reliability in a messy, lossy medium isn't a matter of hoping the signal comes through clean. You engineer for the errors. You build detection and correction into the system itself.
A phone call is about as noisy a channel as exists—literally and figuratively. Accents, cross-talk, latency, hallucinations, ambiguous intent, adversarial callers. Hamming AI takes its namesake's premise and applies it to voice agents: don't hope the agent behaves. Systematically surface where it breaks, and correct it before it reaches a customer. The name tells you what the company thinks it's building—not a nicer test dashboard, but the error-correction layer for a new class of software.
Why Voice Agents Resist the Testing You Already Know
If testing voice agents were the same as testing a web app, someone would have bolted it onto an existing framework and moved on. It isn't, for a few structural reasons.
The output is non-deterministic. A traditional function returns the same value for the same input. A voice agent, powered by an LLM, can say the same thing three different ways—or three different things—for the same prompt. You can't assert output === expected. You have to evaluate whether a fluid, natural-language response accomplished the goal, stayed compliant, and didn't wander off. That's a judgment problem, not a string-comparison problem.
The input space is enormous and human. Text has edge cases; speech has an entire universe of them. Regional accents, code-switching, background noise, people talking over the agent, long silences, emotional callers, fast talkers, elderly callers who need a beat. Each of these can quietly wreck an agent that aced a clean scripted demo. You cannot enumerate these by hand.
Manual testing doesn't scale past a toy. Calling your own agent to check it is fine for the first week. It falls apart the moment you have several agents, frequent prompt changes, and a real customer base. Every prompt tweak silently risks regressing behavior you validated last month, and no human is going to re-run five hundred phone calls by hand after each change.
The stakes are real and often regulated. These agents operate in finance, healthcare, insurance, and retail. A misstatement isn't an embarrassing typo—it can be a compliance violation, a HIPAA-sensitive slip, or a wrong number quoted on a claim. The cost of a bad call is measured in trust and liability, not just a support ticket.
Put together, voice agents combine the openness of natural language, the messiness of live audio, and the accountability of regulated work. That's a testing problem that genuinely needed its own tool.
What Hamming Actually Does
Hamming's core loop is simulation plus evaluation, and it's designed to feel familiar to an engineer even though the medium is voice.
It generates the tests for you. Point Hamming at your agent and it reads the system prompt to auto-generate a suite of test scenarios—happy paths, edge cases, and the adversarial situations teams forget. The simulated callers aren't scripts reading lines; they behave like real people. They interrupt, barge in mid-sentence, go quiet, get frustrated, mishear, and change their minds. Hamming can layer in background noise, simulate elderly or fast or slow speakers, and run conversations across 65+ languages and regional accents—South Indian English, Gulf Arabic, Australian, Latin American Spanish, and many more. This is the part that's nearly impossible to reproduce by hand, and it's where agents actually fail.
It runs them in parallel, at load. You connect your voice stack with an API key—dial in a SIP number, or point Hamming at LiveKit or Pipecat for direct WebRTC—pick an agent, and click run. Instead of one call at a time, you watch dozens or hundreds of simulated conversations execute simultaneously. That same machinery doubles as concurrency load testing: one Hamming customer, an AI drive-through startup, simulates thousands of simultaneous phone calls to push its agent toward 99.99% order accuracy before real customers ever pull up to the speaker.
It scores what happened. After the calls run, Hamming evaluates them against the outcomes you care about and produces call-quality reports—did the agent complete the task, stay on policy, handle the interruption, avoid hallucinating a fact. Because the evaluation is automated and repeatable, you can run the whole suite again after every prompt change and diff the results, the way you'd read a CI report.
The company's claim for this loop is blunt and, for anyone who has tried to QA an agent by hand, believable: automated testing that's on the order of a hundred times faster, cheaper, and more thorough than doing it manually.
From First Call to Production Monitoring
Two things make Hamming feel less like a testing library and more like infrastructure: how fast you get value, and how far it follows you into production.
On the front end, the time-to-first-test is deliberately short. Connect a voice platform, and you can have your first simulated test call running in under ten minutes. There's no elaborate harness to build; the platform generates the scenarios and drives the calls.
On the back end, testing doesn't stop at deployment—which is the part teams underestimate. Pre-launch tests tell you the agent works against the cases you imagined. Production is where the cases you didn't imagine show up. So Hamming monitors every live call with more than fifty built-in metrics, flags anomalies, and is designed to alert you before your customers are the ones noticing something's wrong. The full arc—test suite generation, voice-agent testing, concurrency and load testing, IVR testing, A/B testing between agent versions, red-teaming, compliance reporting, real-time monitoring, and end-to-end observability—covers the entire lifecycle of an agent rather than a single checkpoint in it.
That lifecycle framing matters. A voice agent isn't shipped once; it's a living system whose behavior drifts every time the prompt, the model, or the world changes. Treating QA as a continuous property of the system rather than a launch gate is the difference between catching a regression in staging and reading about it in an angry customer's tweet.
Testing as an Engineering Discipline, Not a Vibe Check
The deeper thing Hamming is doing is importing the norms of serious software engineering into a field that, for now, largely lacks them.
The platform is built to sit inside the workflows engineers already trust: a full REST API, CI/CD-native integration, and webhooks, so agent tests can run automatically on every change the way unit tests do. At the same time, it's legible to the non-engineers who own the customer experience—dashboards, human-readable reports, and audio playback so a compliance officer or a support lead can literally listen to how the agent handled a call. That dual audience is intentional. Voice agents are built by engineers but judged by the business, and quality has to be a shared language between them.
Then there's red-teaming and compliance, which is where this stops being a nice-to-have. Banks use Hamming for compliance testing. Healthcare organizations validate HIPAA-sensitive interactions. Insurance companies stress-test claims workflows. These aren't teams looking for a prettier test report—they're teams that cannot ship an agent they can't prove is safe, and Hamming gives them the receipts.
There's a useful historical rhyme here. Every maturing category of software eventually grows a testing discipline and the tooling to support it—web apps got Selenium and its descendants, APIs got contract testing, data pipelines got observability. The tooling arrives once the software becomes load-bearing enough that failure is expensive. Voice agents crossed that line fast, and the QA layer is arriving right behind them.
The Category Bet
Step back and Hamming is a wager on a specific shape of the AI buildout.
The bet is that voice agents don't stay a niche. They become one of the default interfaces between companies and their customers—phone support, scheduling, sales, collections, triage—across every industry that runs on conversations. If that's right, then the number of production voice agents goes from thousands to millions, each one a piece of customer-facing software that can fail in a hundred human ways.
When that happens, QA stops being optional and becomes infrastructure. You can't run regulated, revenue-critical agents at scale on hope. You need the equivalent of a test suite, a load test, and a monitoring stack—purpose-built for voice. Hamming is positioning itself as that layer: the place teams go to trust their agents before and after they ship.
The strategic elegance is that Hamming is agent-agnostic and model-agnostic. It doesn't matter whose LLM powers the agent or which voice platform serves it—Hamming tests the behavior, not the plumbing. As the underlying models improve and the agents take on harder tasks, the need to verify them only grows. Better agents attempt more consequential work, and more consequential work demands more rigorous proof that it's correct. The testing layer compounds in value precisely as the thing it tests gets more capable.
Founders Who Come From Reliability
Hamming was founded in San Francisco in 2024 by Sumanyu Sharma and Marius Buleandra, who met building trust-and-safety infrastructure together at Citizen. Sharma, the CEO, was previously Head of Data at Citizen and a senior staff data scientist at Tesla, with an engineering degree from the University of Waterloo—a background steeped in exactly the kind of large-scale, high-stakes systems where "mostly works" isn't good enough.
That lineage shows up in the product. Reliability infrastructure is a specific instinct: you assume things will fail, you instrument everything, and you build the machinery to catch problems before they reach a person. Applying that instinct to voice AI—a technology that got deployed into the real world faster than the tooling to keep it honest could catch up—is a natural and well-timed move.
The company went through Y Combinator in the Summer 2024 batch and raised a seed round announced in late 2024, led by Mischief with Y Combinator participating. Its investor base now includes Orange Collective, the fund made up of YC alumni that backs YC founders building the next layer of the AI stack—developer tools, evals, and the infrastructure that makes AI usable in production. A QA platform for voice agents sits squarely in that thesis: unglamorous, foundational, and increasingly hard to operate without.
The Quiet Layer That Makes the Loud One Trustworthy
Voice AI is the flashy part—the natural-sounding agent that books your appointment or answers your billing question. Hamming is the quiet part that makes the flashy part safe to deploy.
That's usually where the durable companies get built. The agents themselves will keep improving, and plenty of teams will build them. But every one of those teams eventually hits the same wall: they've shipped software that talks to customers about money, health, and claims, and they have no rigorous way to know it behaves. The tool that answers that question—systematically, continuously, and in a language both engineers and regulators trust—becomes something they can't run without.
Richard Hamming built error correction because he understood that reliability in a noisy channel has to be engineered, not wished for. Six decades later, the noisiest channel we've got is a live phone call handled by a machine—and the company carrying his name is betting that the same principle holds. Don't hope your voice agent is right.
Prove it.