TLDR
A production voice feature in 2026 typically ships with four vendor relationships: a transcription API, a PII redaction step somebody built in a sprint, an LLM provider, and a compliance review stretched across all of it.
Meanwhile the text side of the industry spent the year consolidating onto AI gateways. One endpoint fronting every model, failover handled below the application. Every one of those gateways assumes the request arrives as text.
This edition is about what consolidation looks like when the request arrives as audio. The short version: the transcript gets created at the transcription layer and consumed by every stage after it, so that layer is where the rest of the stack wants to live. AssemblyAI has quietly become the clearest example, with transcription, understanding, LLM orchestration, and safety native to one platform that Zoom and thousands of other companies already build on. One API key and one bill, with three fewer places for a retry storm to start.
Get your API key free at assemblyai.com — free credits, and the API is the right way to see the whole pipeline in one place.
🚨 How you end up with four vedors
The pipeline accretes one reasonable decision at a time.
Version one is honest work: pick a speech-to-text API and pipe transcripts into the product. Then sales starts recording customer calls, legal discovers the transcripts contain card numbers and birthdays, and an engineer writes regex redaction over a sprint with a ticket to revisit it properly later. Then product wants summaries and “who said what,” which adds an LLM contract and a prompt pipeline on top of the diarization.
A year in, a healthcare prospect sends a security questionnaire. The answer to “where does call audio rest, and for how long” involves four companies and a diagram somebody has to keep current.
Each step was the reasonable next move. The sum is a pipeline where your most sensitive data, recorded human conversation, commutes between vendors on every request.
💥 What a vendor seam costs you
A vendor boundary in a data pipeline is four things at once:
a network hop
an auth and quota domain
a retention contract
an independent retry policy
The retry one deserves respect after last week. GitHub’s August 17 outage pushed one internal token service from 9,000 requests per second to 100,000 because client retry loops activated at the exact moment the servers slowed down. Chain four vendors and you stack four uncoordinated retry policies. Three well-meaning attempts per layer, and one transient failure at the deepest hop fans out into 27 requests by the time every caller gives up. Each seam you add raises the exponent, and nobody owns the product of the whole chain.
PII has the same geometry. Redaction protects everything downstream of it and nothing upstream of it, so every hop before your redaction step is a queue or a vendor log where raw conversation sits exposed. The old answer is to redact as early as possible. In a four-vendor pipeline, “as early as possible” is inside somebody else’s infrastructure, which is why most teams end up redacting in the middle and auditing the front half every quarter.
🔍 The text stack already did this
The gateway boom is the loudest infrastructure story of the year: OpenRouter-style endpoints, per-request model routing, automatic failover, one bill. Teams stopped writing bespoke fallback code between model providers because the gateway handles it below the application, and that consolidation is why the pattern won.
All of that machinery fronts text. A voice request starts as audio, and by the time it becomes text it has already passed through the vendor holding the most sensitive copy of your data. Bolting a text gateway three hops downstream leaves every seam from the last section exactly where it was.
My position: for voice systems, the consolidation point is the transcription layer. Data gravity decides it. The transcript is born there, every later stage consumes it, and the audio itself never has to leave. Consolidate anywhere else and the transcript, sometimes the audio too, makes the commute anyway.
🏗️ The consolidated version, layer by layer
AssemblyAI is the worked example, and the reason this edition exists: most engineers still file them under “the speech-to-text company,” while the platform has grown the other three layers natively behind the same API key.
Transcription is the front door. Async for recorded audio, streaming for live agents. You know this layer already.
Speech Understanding is the part teams keep almost building themselves: PII redaction, speaker identification, entity detection, sentiment, summarization, translation. All of it lives on the transcription request instead of in vendors two through four, and most of it turns on as a one-line boolean:
speaker_labels: true
redact_pii: true
redact_pii_audio: true
entity_detection: true
sentiment_analysis: true
summarization: true
The third line is the one to notice. redact_pii_audio scrubs the source recording itself, beeping out the spans where card numbers and names were spoken. That matters because the recording is a compliance artifact too, and a redacted transcript sitting next to an unredacted recording protects nobody in an audit. The sprint-built regex layer from the accretion story never grows into this. Structurally, it also puts redaction at the earliest possible point in the pipeline, upstream of every consumer, which is the property the four-vendor version can never have.
The LLM Gateway runs Claude models from Haiku 4.5 up to Opus 4.8, plus Gemini and more, over your audio and text with that same key (if you built on LeMUR, this is its successor). The gateway conversation everywhere else leans hard on routing cheap; in front of voice, different properties carry the weight.
Automatic fallbacks mean a provider incident degrades one summary rather than stranding a live call flow, and your application code never grows the bespoke retry loops last week’s edition was a cautionary tale about. Zero data retention matters more here than almost anywhere, because conversation transcripts are among the most sensitive text a company processes. And routing over audio plus text means “summarize this call and draft the follow-up” is one request against data that never left the platform.
The endpoint itself speaks the standard chat-completions shape, so existing code calls it as-is, and swapping models on a task is a one-string change.
Guardrails is the newest layer: compliance and safety controls for voice data in regulated industries. If you handle medical or financial conversations, this is where your security-questionnaire answers will come from, and the specifics belong in their documentation rather than my paraphrase.
📌 The tradeoff, honestly
Consolidation concentrates risk. One platform in the voice path means one roadmap you depend on and one outage domain, and anyone who has lived through a single-vendor incident knows that feeling in their chest. The mitigation here is partly structural: the layer most likely to have a bad day, the LLM call, is exactly the layer with failover across providers built in.
There is also a version of your company where separate best-of-breed layers make sense, with a platform team and the headcount to own the glue. If that describes you, you already know it. For everyone else, the math favors fewer seams: the concentration risk bills you rarely, while seams bill you on every request, in latency, audit surface, retry topology, and invoices.
One boundary this consolidation leaves alone is your agent framework. LangGraph, or whatever runs your application logic, sits above all four layers and calls them the same way it did before. This consolidates the voice data plane underneath your orchestration; the framework layer keeps working unchanged.
🏁 Try this before your next voice sprint
A concrete exercise to close. Take one real call recording from your product and run it through a single transcription request with the six parameters above turned on. Diff the response against your voice-feature roadmap. There is a decent chance two or three roadmap items come back as fields in one JSON response, and the engineering question becomes whether the remaining items justify the vendors they would add.
Are you running voice in production? Hit reply and tell me how many vendors sit between the caller and the summary.
Get your API key free at assemblyai.com — free credits, and the API is the right way to see the whole pipeline in one place.
Prefer a two-minute look first? Drop your own audio into the Playground to spot-test any single feature, then hit the docs when you’re ready to build.