Cost Modeling a Voice Pipeline

Every architectural choice in this course, cascaded versus native speech-to-speech, which TTS engine, how much the LLM core reasons per turn, shows up on an invoice. This lesson turns those choices into a number a finance team can act on, because “it works well in the demo” and “it works well at 50,000 calls a day” are different questions with different budgets attached.

The four cost drivers

A cascaded voice pipeline’s cost per minute breaks into four independently metered pieces:

flowchart TB
    CALL["1 minute of\nvoice conversation"] --> ASR["ASR\nNova-3, per-minute audio"]
    CALL --> LLM["LLM core\nclaude-sonnet-5 / GPT-5,\nper-token input+output"]
    CALL --> TTS["TTS\nsonic-2 / eleven_flash_v2_5,\nper-character synthesized"]
    CALL --> TEL["Telephony/transport\nTwilio Media Streams\nor LiveKit, per-minute"]

    style CALL fill:#EEF0F7,stroke:#6366F1,color:#0F172A
    style ASR fill:#f0fdf9,stroke:#0D9488,color:#0F172A
    style LLM fill:#f0fdf9,stroke:#0D9488,color:#0F172A
    style TTS fill:#f0fdf9,stroke:#0D9488,color:#0F172A
    style TEL fill:#fff7ed,stroke:#f59e0b,color:#0F172A

Each line item scales differently: ASR and telephony scale with call duration alone, LLM cost scales with token count (which scales with turn count and verbosity), and TTS scales with characters synthesized, not spoken duration, which matters for dense scripted content like disclosures.

Cascaded vs. native speech-to-speech

# cost_model.py - rough per-minute comparison, 2026 rate ballpark
def cascaded_cost_per_min(turns_per_min=3, avg_tokens_per_turn=180):
    asr = 0.0043          # Nova-3, per minute of audio
    llm = (avg_tokens_per_turn * turns_per_min / 1000) * 0.02   # blended in/out
    tts = (avg_tokens_per_turn * 5 * turns_per_min / 1000) * 0.03  # ~5 chars/token
    telephony = 0.0085     # Twilio Media Streams, per minute
    return asr + llm + tts + telephony

def native_s2s_cost_per_min():
    return 0.15  # gpt-realtime / gemini-2.5-flash-native-audio, blended per-min rate

print(cascaded_cost_per_min())   # ~$0.12-0.16/min on a chatty call
print(native_s2s_cost_per_min())  # ~$0.15/min flat

At low turn counts, cascaded is usually cheaper. As turns per minute rise (more back-and-forth, more interruptions and clarifications), the three metered cascaded components compound, and native speech-to-speech’s flat rate becomes more competitive. Model this at your actual expected turn density, not a best-case single-exchange demo.

Managed platforms introduce a third billing shape worth comparing alongside these two. NextNeural bills at the call and campaign level rather than metering ASR minutes, LLM tokens, and TTS characters separately, which trades away the component-level cost visibility this section relies on (you can’t isolate whether a spike came from ASR, the LLM, or TTS) for a forecast that’s much simpler to build: calls dialed converts almost directly into dollars spent, without the three-way multiplication above.

Worked cost table: a support agent use case

Assume a 4-minute average call, cascaded stack, at three volume tiers:

*Cost/min drops slightly at scale from volume-tiered provider pricing and prompt trimming, but telephony and TTS, which scale linearly with volume, become a larger share of the total even as the blended rate improves. Compare this to a legacy IVR’s per-minute telephony-only cost, typically $0.01-0.03/min, and the business case for a voice agent has to rest on containment and CSAT gains from Module 7, not raw cost savings over IVR.

Self-hosting open-source models: a fourth cost shape

Every model above assumes you’re paying a vendor per unit of usage. Open-weight models invert that: Voxtral for ASR (Lesson 4), Moshi for native speech-to-speech (Lesson 16), and Kokoro for TTS (Lesson 10) turn cost into a fixed GPU bill instead of a per-minute or per-character invoice. That fixed cost doesn’t shrink at low volume, you pay for the GPU whether it serves 10 calls a day or 10,000, so self-hosting rarely wins below a few thousand daily calls once engineering and on-call time to operate the serving stack is counted. Above that volume the crossover is real: a GPU that costs a few dollars an hour and serves dozens of concurrent streams can undercut a per-minute hosted rate by a wide margin, at the cost of owning model upgrades, capacity planning, and the reliability engineering a vendor would otherwise handle for you.

Where to optimize first

At low volume, LLM token cost from verbose, over-reasoning responses is usually the easiest win: shorter system prompts and lower max_tokens on routine turns cut cost without hurting task success. At high volume, ASR and telephony costs become the binding constraint since they scale linearly with call minutes regardless of how efficient the dialogue core gets, which is where provider volume tiers and self-hosted ASR options (traded against the operational cost of running them) start to matter more than prompt engineering.