← All guides · Voice agents in production

How to Compute Your Voice Agent Cost per Minute

Part 7 of Voice agents in production · 1,514 words · ~7 min read · published 2026-10-10 · updated 2026-10-10 · Markdown variant

How to compute a voice agent cost per minute from your own pilot: symbolic formulas for native speech-to-speech and cascaded STT, LLM and TTS, the variables that move the result, idle audio, retries, tool-call turns, and a sensitivity check.

Part of the Voice AI Agent in Production: Architecture, Latency, Handoff and Launch guide.

This article shows how to compute a voice agent cost per minute from your own measurements, and it cannot give you the number itself. The corpus holds no total-cost figure for a call, and the voice AI agent in production pillar already says so in its cost section; here the job is the method that replaces the missing number.

Labels used below: "corpus" means a claim from a named reference, "inference" means the author's reasoning with no published source. Every formula and the worked example are inference. The example uses arbitrary placeholder units and is not a price.

What can the corpus tell you about voice agent pricing?

The corpus gives three usable inputs and nothing that adds up to a per-minute price. All three come from the voice and realtime agents reference, whose vendor facts were web-verified on 2026-07-09 and not re-verified on 2026-09-28.

Arithmetic on those list prices: the full model costs 3.2 times the mini on both the input and the output side. Prices can change without notice, so treat them as a shape, not a quote. The corpus holds no rate card for any speech-to-text or text-to-speech vendor, and no figure for tokens per minute of audio.

What is the formula for a native speech-to-speech agent?

For a native speech-to-speech agent, cost per minute is audio input tokens plus audio output tokens plus any text tokens, each multiplied by its own price. As inference, in symbols:

cost_per_min = tokens_per_audio_minute * in_share  * price_audio_in
             + tokens_per_audio_minute * talk_ratio * price_audio_out
             + text_tokens_per_min_in  * price_text_in
             + text_tokens_per_min_out * price_text_out

• tokens_per_audio_minute is how many tokens one minute of audio becomes. Do not assume it: the corpus gives none, and it may differ between input and output and between vendors.
• in_share is the fraction of each call minute in which audio is sent to the model. If the microphone streams continuously, it is 1.0 whether or not the caller speaks.
• talk_ratio is the fraction of each call minute the agent itself is speaking.
• text_tokens cover system prompt, tool schemas, tool results and any history the vendor counts as text.

Keep audio and text as separate counts because the two are priced differently. The general compounding model in the agent cost and latency optimization reference, cost roughly tokens per call times price times N calls, is the same idea with a turn count; the formula above just spells out the audio terms.

What is the formula for a cascaded agent?

For a cascaded agent, cost per minute is the sum of three stage costs, each priced by its own vendor. The corpus confirms the shape, three sequential model calls per turn, and nothing about how any vendor bills; stage pricing is outside it. In symbols (inference):

cost_per_min = stt_rate * stt_minutes_per_min
             + turns_per_min * (llm_in * price_llm_in + llm_out * price_llm_out)
             + tts_rate * tts_units_per_min

• stt_rate and tts_rate are whatever unit each vendor bills (audio seconds, characters or something else); read each rate card and use its unit, not an assumed one.
• llm_out is the generated text tokens per turn; tts_units_per_min is the amount of speech synthesized per minute of call, in whatever unit the TTS vendor bills.
• turns_per_min is your measured turn count divided by call minutes.
• llm_in includes the system prompt, tool schemas and the earlier turns of the conversation, so it grows through the call.

A cascade also lets you swap the model in each term independently, which is the control the corpus credits to the architecture. The decision between the two designs is covered in what to log and filter in a voice agent, by architecture.

How do you get tokens_per_audio_minute from a pilot?

Get it by measuring: run a pilot with real callers and divide each call's reported audio token usage by its length in minutes. The corpus does not describe any vendor's usage fields, so read your vendor's response documentation for what it returns, and treat the steps as inference.

1. Run a pilot of real calls, including noisy, interrupted and silent ones.
2. Log, per call, the audio input tokens, audio output tokens, text input tokens, text output tokens and call duration, as separate numbers.
3. Compute T per call as audio tokens divided by audio minutes, separately for input and output.
4. Look at the distribution, not the mean: the shortest calls and the longest calls will disagree.
5. Re-run after any prompt, voice or model change, because T and history size may move.

How to record and price these counts safely, including versioning the price table, is in agent cost telemetry in production, which this article does not repeat. Cluster-wide guidance on measuring per call is in the pillar.

Where do silence, retries and tool calls add cost?

Silence, retries and tool-call turns can each add billable input without adding useful conversation, and all three are inference until your pilot confirms them.

• Idle audio. A session that streams microphone audio during pauses, hold or background noise may bill that audio as input. Test with a call that is mostly silence and compare its usage to its length. The corpus says the 2.1 realtime models improved "noise/silence handling", which is a quality claim, not a billing one.
• Retries. If a caller is misheard and repeats, or the agent re-asks, the repeated turn is paid twice. Count repeated turns as a metric next to turn count.
• Tool-call turns. A tool call may add a model step before the spoken reply, and the tool result goes back into the context as text. Whether a vendor bills that step as a separate response is not stated in the corpus; check one call with tools against one without. Tool design is covered in function calling in a voice agent.
• History. If the full conversation is re-read on each turn, input grows with turn number, so long calls cost more per minute than short ones. Confirm with the usage of the last turn of a long call.

Which variables move the result most?

The variables that appear in more than one term or multiply an entire term move the result most, and a sensitivity check on your own pilot data will rank them. The ranking below is inference from the structure of the formulas, not a measurement.

Worked example with arbitrary placeholder units, not dollars and not a real result: set tokens_per_audio_minute to 1 unit, in_share to 1.0, talk_ratio to 0.4, input price to 1 and output price to 2, and ignore text. Input term: 1.0. Output term: 0.8. Total: 1.8 units, of which the output term is about 44%. Doubling talk_ratio to 0.8 raises the total to 2.6, a rise of about 44%; halving in_share to 0.5 lowers it to 1.3, a fall of about 28%. These numbers show how to read a sensitivity, nothing about real calls.

What should you do before quoting a number?

Before quoting any cost per minute, price your pilot twice, once per architecture, from the same recorded calls, and publish the range with its date. Concretely:

• Record the vendor, model, rate-card date and the pilot's call count next to the figure.
• Report a distribution (median and a high percentile) as the pillar's per-call advice suggests, not an average alone.
• Add the non-model costs the corpus does not cover, such as telephony minutes and human handoff, which are outside these formulas. See voice agent human handoff.
• Check latency alongside cost, since cheaper stages often change the voice agent latency budget.
• Re-verify the OpenAI list prices: the corpus figures were verified 2026-07-09 and not re-verified 2026-09-28.

As of October 2026, ChangeGamer runs no voice agent, so there is no measured per-minute figure here, and none should be inferred from the placeholders above.

#voice #cost #pricing #realtime #cascaded #speech-to-speech #agents #production