Costing a Voice Product Per Minute

A voice agent is billed by four vendors at once, on four different units, none of which is a minute. This page converts all of them into one equation with your prices as symbols, and shows why the model leg grows faster than the call does.

The five components

Converting a minute of call into units

Every vendor’s unit reduces to one of: audio minutes, characters, or tokens. Two labelled assumptions convert between them, and you should replace both with figures measured from your own transcripts.

ASSUMPTIONS -- measure these on your own calls, do not inherit them.

  R    speaking rate while actually speaking
       Conversational English is commonly taken as around 150
       words per minute. Yours will differ by domain and by
       language.

  phi_a  fraction of call time the AGENT is speaking
  phi_h  fraction of call time the CALLER is speaking
         The remainder is silence, and it is usually a larger
         share than people expect.

  tau  tokens per word
       About 1.3 for English on a common byte-pair tokeniser.
       Substantially higher for languages the tokeniser handles
       badly -- see the tokenizer language tax.

  chi  characters per word, including the trailing space
       About 6 for English.

  T    conversational turns per minute of call

DERIVED, per minute of call:

  agent words     w_a = R * phi_a
  caller words    w_h = R * phi_h

  TTS characters  = w_a * chi
  ASR audio       = 1 minute if you stream continuously,
                    or (phi_a_echo + phi_h) if you gate on
                    voice activity -- see below

  tokens per turn:
    u  (caller -> input)      = w_h * tau / T
    a  (agent  -> output)     = w_a * tau / T

The ASR line contains the first real lever. A recogniser billed per submitted audio-minute charges you for the whole call if you stream continuously. Gating the stream on voice activity means you submit only the caller’s speech, which is typically a minority of the call. That is a direct proportional saving on one of the five components, and it removes a class of hallucination at the same time.

The context term is quadratic

This is the part that surprises people, and it is pure arithmetic. Every turn resends the entire conversation so far, because the model has no memory between calls.

Let  S  = system prompt tokens (constant, resent every turn)
     u  = caller tokens added per turn
     a  = agent tokens added per turn
     n  = number of turns in the call

Input tokens on turn k:

  in(k) = S + (k-1)(u + a) + u
          ^     ^^^^^^^^^^^^   ^
          |     |              +-- this turn's new caller words
          |     +-- everything said so far, resent
          +-- the system prompt, resent

Total input over the whole call:

  I(n) = sum over k of in(k)
       = n*S + n*u + (u + a) * n(n-1)/2

Total output over the whole call:

  O(n) = n * a

The n(n-1)/2 is the whole story. Doubling the call length
quadruples that term:

  n =  30 turns, (u+a) = 25:   25 * 30*29/2  =  10,875 tokens
  n =  60 turns, (u+a) = 25:   25 * 60*59/2  =  44,250 tokens

Twice the call, four times the history cost. Cost per minute is
therefore NOT a constant -- it rises with call duration, and any
model that quotes one flat number for it is wrong for long calls
in the direction that hurts.

The other term worth staring at is n*S. A 1,000-token system
prompt over 30 turns is 30,000 input tokens before anybody has
said anything. On short-turn voice traffic the system prompt is
routinely the largest single item in the bill.

Prompt caching attacks both terms directly, because the expensive part is a prefix that repeats: the system prompt is identical every turn and the history is identical up to the newest exchange. Where a provider supports it, the cacheable portion is I(n) − n·u — everything except each turn’s new caller words — charged at the reduced rate. See how cached tokens are billed and why prefix ordering decides whether the cache hits.

The whole equation

Prices, all as symbols. Fill from your own contracts.

  p_tel   per connected minute
  p_asr   per audio-minute submitted
  p_in    per input token
  p_cache per cached input token
  p_out   per output token
  p_tts   per character
  p_inf   your infrastructure, per minute

For one call of M minutes with n = T*M turns:

  C_tel  = M * p_tel
  C_asr  = A * p_asr            A = audio-minutes submitted
  C_tts  = M * w_a * chi * p_tts
  C_llm  = (I(n) - n*u) * p_cache + n*u * p_in + O(n) * p_out
  C_inf  = M * p_inf

  C_call = C_tel + C_asr + C_tts + C_llm + C_inf

  C_per_minute = C_call / M

Without caching, substitute p_cache = p_in and the whole of I(n)
is charged at the input rate.

Two things to notice before any number goes in:

  1. Only C_llm depends on M non-linearly. Everything else is
     proportional to the minute.
  2. C_asr is the only term you can reduce without changing the
     product at all, by not submitting silence.

One illustrative fill-in

ILLUSTRATIVE ONLY -- substitute your own prices and measurements.

Call parameters
  M     = 5 minutes
  T     = 6 turns per minute      -> n = 30 turns
  R     = 150 words per minute
  phi_a = 0.47 agent speaking     -> w_a = 70 words per call-minute
  phi_h = 0.30 caller speaking    -> w_h = 45 words per call-minute
  tau   = 1.3 tokens per word
  chi   = 6 characters per word
  S     = 800 tokens system prompt

Derived
  u = 45 * 1.3 / 6  = 9.75, round to 10 tokens per turn
  a = 70 * 1.3 / 6  = 15.2, round to 15 tokens per turn
  u + a = 25

  I(30) = 30*800 + 30*10 + 25 * 30*29/2
        = 24,000 +    300 +        10,875
        = 35,175 input tokens
  O(30) = 30 * 15 = 450 output tokens
  TTS   = 5 * 70 * 6 = 2,100 characters
  ASR   = 5 audio-minutes (streaming continuously)

Invented prices
  p_tel   = $0.010 per minute
  p_asr   = $0.005 per audio-minute
  p_in    = $1.00  per million tokens
  p_out   = $4.00  per million tokens
  p_tts   = $0.15  per 1,000 characters
  p_inf   = $0.001 per minute

Cost of the call
  telephony   5 * 0.010                  = $0.0500
  ASR         5 * 0.005                  = $0.0250
  LLM in      35,175 * 1.00 / 1e6        = $0.0352
  LLM out        450 * 4.00 / 1e6        = $0.0018
  TTS         2.1 * 0.15                 = $0.3150
  infra       5 * 0.001                  = $0.0050
                                          ---------
  C_call                                  = $0.4320
  C_per_minute = 0.4320 / 5               = $0.0864

What the SHAPE says, which is the transferable part:

  * TTS is 73% of this call. Whenever a per-character TTS price is
    the largest term, the cheapest optimisation in the system is
    saying less -- and shorter replies also cut latency.
  * The model leg is about 9%, and 68% of it is the system prompt being
    resent 30 times. Caching that prefix would remove most of it.
  * Output tokens are 0.4%. Optimising the output token price on a
    voice agent is optimising a rounding error.
  * ASR is charged on 5 minutes of which roughly 1.5 contain the
    caller speaking. VAD gating removes about 70% of that line.

Change the prices and the ranking changes completely. That is the
point of leaving them as symbols: the equation is stable, the
ordering is not.

The levers, in order of effect

1. Say less. Agent word count drives the TTS bill linearly and drives the perceived latency too. Cutting an average reply from three sentences to one is usually the largest single change available, and it improves the product.
2. Cache the prefix. The n·S term is pure repetition. Where prompt caching is available, structure the request so the invariant part is genuinely a prefix — system prompt, tools, then history — because a cache that misses because something dynamic was placed early is a cache you are not getting.
3. Gate ASR on voice activity. Stop paying for silence and for your own audio echoing back. Proportional, easy, no product change.
4. Shorten the system prompt. It is multiplied by every turn of every call. A thousand tokens of instructions that could be four hundred is a 60% cut in the largest input term.
5. Compact long conversations. The quadratic term is only quadratic because you resend everything. Replacing the older history with a short summary after a threshold converts the growth back to linear; conversation compaction covers how to do it without losing the thread.
6. Match the model to the turn. Most turns in a transactional call are routing, confirmation or slot filling. A small fast model handles those and a larger one handles the rest, which usually improves latency at the same time.
7. End calls that are going nowhere. A call that has not progressed in ninety seconds is accruing every line item at once. Transferring it to a person is often cheaper than continuing, as well as better.

What the model leaves out

The equation above prices a call that connects and goes well. Real cost per minute is higher, and these are the terms that make it so:

• Calls that are not conversations. Ringing, hold, queue time, wrong numbers, voicemail. Telephony bills for connected time regardless of whether anyone said anything, and outbound campaigns can spend a substantial share of their minutes this way.
• Rounding. Per-minute billing rounded up means a 35-second call costs a minute. On a product with many short calls that is a large multiplier, and it is invisible in a model built on averages.
• Retries and failovers. A model request that times out and is reissued is billed twice if the first one produced tokens. The speculative pattern that saves latency deliberately spends some calls this way.
• Escalation. If a fraction of calls transfer to a person, the true comparison is your per-minute cost plus that fraction times the human cost, against the human cost alone. Write it out: with human cost H per minute, escalation rate e and human handling time proportion h, the agent is cheaper when C + e·h·H < H. At a high escalation rate the automation can cost more than the thing it replaced, and this is a real outcome rather than a hypothetical one.
• Storage and its retention. Recordings and transcripts accrue and are subject to the schedule in retention rules. Small per call, unbounded in aggregate until deletion is actually running.
• The people who watch it. Reviewing transcripts, maintaining prompts, running the cohort evaluations. This is usually the largest number on the page and it never appears in a per-minute figure.