What Voice Agent Observability Costs per Minute: Storage, Ingest and Audio

On this page
Most cost posts stop at the agent's own per-minute rate. This one prices the other side: the data you keep to explain a bad call. Every price here is a placeholder marked "your price here", unless a vendor page is quoted with its date.
The model turns codec, channels, spans, retention and sampling into one number per minute. For the agent bill, see voice agent total cost of ownership and hidden costs in voice agent pricing. This post covers voice agent monitoring cost only.
Sources were read on November 21, 2026. Prices vary by region and change, so re-check before you budget.
The five lines of a voice agent observability cost model
Audio is large and rarely read. Text telemetry is small and read often. They are billed differently, so model them apart.
| Line | What you pay for | Driver |
|---|---|---|
| Audio storage | Recordings kept N days | Codec, channels, retention |
| Telemetry ingest | Spans, transcripts, metrics sent in | Span count and size, sampling |
| Telemetry retention | Bytes held in the backend | Retention days |
| Query | Bytes scanned by searches | How often, how wide |
| Egress | Bytes leaving storage on playback | Share of calls replayed |
Add a row for any seat or platform fee. It does not scale with minutes, so spread it over your volume.
The core rule is simple. Cost per minute is bytes per minute, times a price per byte, times how long you keep the bytes. For what to capture in the first place, see the voice agent observability checklist.
Audio: call recording storage per minute
Compute audio size from the format, not from a guess. For uncompressed audio, bytes per second are sample rate times bytes per sample times channels. An 8 kHz, 16-bit, mono stream is 8,000 x 2 x 1 = 16,000 bytes per second. That is 960,000 bytes per minute.
For compressed audio, divide the bitrate by 8.
The phone network usually carries G.711. RFC 3551 lists PCMU with a clock rate of 8,000 and one channel. Section 4.5.14 says "Audio data is encoded as eight bits per sample, after logarithmic scaling." So, G.711 is 8,000 x 8 = 64,000 bits per second. That is 8,000 bytes per second per channel.
Opus is the common compressed option. RFC 6716 says it "scales from 6 kbit/s narrowband mono speech to 510 kbit/s fullband stereo music". That is a range, not a default. The 24 kbit/s row is a chosen setting.
| Format | Bytes per second | Bytes per minute | MB per minute |
|---|---|---|---|
| G.711, mono (64,000 / 8) | 8,000 | 480,000 | 0.48 |
| PCM 16-bit, 8 kHz, mono (8,000 x 2 x 1) | 16,000 | 960,000 | 0.96 |
| G.711, stereo | 16,000 | 960,000 | 0.96 |
| PCM 16-bit, 8 kHz, stereo | 32,000 | 1,920,000 | 1.92 |
| PCM 16-bit, 16 kHz, stereo | 64,000 | 3,840,000 | 3.84 |
| Opus 24 kbit/s, mono (chosen) | 3,000 | 180,000 | 0.18 |
Megabytes are decimal, so 1 MB is 1,000,000 bytes. Container headers are ignored.

Three facts stand out.
- Stereo doubles the size. Twilio's recording docs say "
dualrecords each party of a 2-party call into separate channels", while "monorecords all parties of the call into one channel." - Sample rate is a multiplier. A phone leg stored at 16 kHz instead of 8 kHz gains size, not detail.
- Compression is the biggest lever. G.711 stereo is half of 8 kHz PCM stereo, with the same telephone audio.
Do not trim silence to save bytes if you align audio to traces, because offsets break. See linking call recordings to traces for why.
Transcript and trace volume: spans, turns and bytes
Text telemetry is what you pay to ingest. Three inputs set its size.
Span bytes per minute = spans per turn x turns per minute x bytes per span.
OpenTelemetry describes a trace as "The path of a request through your application" on its traces concept page. For a call, one trace holds every turn. A turn may carry spans for the turn, speech-to-text, the model, a tool and speech synthesis. Our trace and span model post lists them.
Illustrative inputs, to be replaced by your own export:
- 6 spans per turn.
- 4 turns per minute, one every 15 seconds.
- 1,500 bytes per span, with attributes.
That gives 6 x 4 x 1,500 = 36,000 bytes per minute. Add 2,000 for the transcript and 1,000 for a call summary and metrics. Telemetry is 39,000 bytes per minute. Audio is 960,000. So audio is 960,000 / 999,000 = 96% of the bytes.
Span size surprises teams. Attach full prompts and tool payloads to each model span, and 1,500 bytes can become 12,000. That is an 8x jump with no change in volume. Decide what goes into attributes before you pay to store it. The collector post shows where to drop fields, and the PII redaction post shows where to mask them.
Trace ingest cost, retention, query and egress
Backends price in different units, such as per gigabyte, per event or per seat. Convert each quote to dollars per gigabyte and note what it covers.
A real price page, dated. On November 21, 2026, Grafana's pricing page listed these Pro plan traces prices: "Starts at $0.05/GB Process", "Starts at $0.40/GB Write" and "Starts at $0.10/GB Retain", with "30 days retention". The text I read showed "$" without naming a currency. "Starts at" means the first tier. I name one vendor only to show how a bill splits into process, write and retain parts. Prices change.
So the fee has several parts, and retention can be its own line.
Object storage. Audio usually sits in a bucket. The Amazon S3 pricing page did not show its S3 Standard rate table in the text I could read on November 21, 2026. The storage price below is a placeholder, not a quote.
Egress. The same page has an example line: "The Data Transfer out charge from Amazon S3 in Europe (Ireland) to internet is $0.09 per GB." That is one region in one example. Check your own region and allowance.
Retention rules. Voice agent log retention cost grows with every day you keep data, so enforce limits by machine. AWS says S3 Lifecycle helps you "store objects cost effectively throughout their lifecycle", including "deleting expired objects on your behalf." Retention is also a policy choice. See recording consent. This is not legal advice.
Stored bytes equal monthly bytes times retention days divided by 30. Keep audio 90 days and you hold three months of audio at steady state. Early months cost less while the bucket fills.
A worked example, per minute (illustrative)
Copy these tables into a sheet and fill column D.
| Input | Meaning | Illustrative value | Your value |
|---|---|---|---|
| M | Call minutes per month | 100,000 | |
| b_a | Audio bytes per minute | 960,000 | |
| s, t | Spans per turn, turns per minute | 6, 4 | |
| b_s | Bytes per span | 1,500 | |
| x, y | Transcript, metrics bytes per minute | 2,000, 1,000 | |
| k, h | Keep-all share, healthy sample rate | 8%, 100% | |
| d_a, d_t | Audio, telemetry retention days | 90, 30 | |
| r | Share of calls replayed once | 2% | |
| p_o | Object storage per GB-month | $0.02 | |
| p_i | Ingest per GB | $0.50 | |
| p_h | Telemetry retention per GB-month | $0.10 | |
| p_e | Egress per GB | $0.09 | |
| p_q, q | Query per GB scanned, GB scanned per GB | $0.01, 10 |
All five prices are placeholders: your price here.
| Line | Formula | Base result |
|---|---|---|
| Share kept, K | k + (1 - k) x h | 1.00 |
| Audio GB per month | b_a x M / 1e9 | 96 |
| Telemetry GB per month | (s x t x b_s x K + x + y) x M / 1e9 | 3.9 |
| Audio storage | Audio GB x (d_a / 30) x p_o | $5.76 |
| Egress | Audio GB x r x p_e | $0.17 |
| Ingest | Telemetry GB x p_i | $1.95 |
| Telemetry retention | Telemetry GB x (d_t / 30) x p_h | $0.39 |
| Query | Telemetry GB x q x p_q | $0.39 |
| Monthly total | Sum of the five lines | $8.66 |
| Cost per minute | Total / M | $0.0000866 |
That is about $0.087 per 1,000 minutes. At these placeholder prices, the data costs a small fraction of a cent per minute. Compare it with the agent's own bill in AI voice agent cost.

Do not read that as "observability is free". Bytes are cheap, so mistakes live in the multipliers.
What moves the bill
Change one input at a time and recompute. These seven runs use the same model, in dollars per 1,000 call minutes.
| Run | What changed | $ per 1,000 minutes |
|---|---|---|
| A | Base example | 0.087 |
| B | A, sampling healthy traces at 10% | 0.066 |
| C | Full payloads on spans (12,000 bytes) | 0.263 |
| D | C, sampling healthy traces at 10% | 0.096 |
| E | A, ingest at $5.00 per GB | 0.262 |
| F | 16 kHz PCM stereo kept 365 days | 0.969 |
| G | Opus 24 kbit/s mono, 90 days | 0.038 |

Read it in three passes.
- Audio format and retention drive the audio line. Run F is 11 times run A. Its audio line holds 4 times the bytes for about 4 times as long.
- Span size and ingest price drive the telemetry lines. Runs C and E triple the base. Neither touches audio.
- Sampling pays most when spans are fat. Run D is about 63% below run C. Run B cuts only 24%, because audio stays whole.
Sampling cut telemetry volume by 76% in run B, yet the total fell by 24%. If audio is your largest line, change codec and retention, not sampling.
Sampling: keep every error, sample the healthy rest
Sampling is the lever on the telemetry lines. OpenTelemetry's sampling page says: "Sampling is one of the most effective ways to reduce the costs of observability without losing visibility."
For voice agents, use tail sampling: decide after the call ends. Keep every call with an error, a slow turn or a handoff. Sample the healthy rest. Our post on voice agent trace sampling explains why deciding at the start loses rare failures. This post prices the choice.
The kept share is K = k + (1 - k) x h. With k = 8% and h = 10%, K = 0.08 + 0.92 x 0.10 = 17.2%. You store 17.2% of traces and drop 82.8%.
Three cautions keep the saving honest.
- Sample traces, not metrics. Counts, rates and latency percentiles should cover every call. They are tiny.
- Treat audio as its own track. You may keep audio for every call you could be asked to audit.
- Cost sampling is not review sampling. Which calls a person or model should score is a different question. See sampling live calls for evaluation and score every call, not a sample.
The cost of not observing: a method
The bill is half the picture. The other half is what a blind agent costs. This post gives no numbers for it, because yours will differ.
Cost of blindness = U x C x F x K.
| Term | Meaning | Your value |
|---|---|---|
| U | Minutes per month a fault runs unnoticed | |
| C | Calls per minute in those minutes | |
| F | Share of those calls the fault breaks | |
| K | Cost of one broken call (repeat, handling, lost sale) |
Take U from your last five incidents.
Add repeat callers as a second term. A caller who phones again after a failed call is another call you pay for. Count repeats within a set window and multiply by your cost per call.
Then find break-even. Observability pays when the minutes it saves, times C x F x K, exceed its monthly cost from the model. The cost per resolution post shows how to price one failed call. Build vs buy voice agent cost covers the tooling trade-off.
Where Evalgent fits
Evalgent Observe is launching. It works from the OpenTelemetry data you send. It traces each failure to the step or handoff that caused it and groups failures into root causes. It never sits in the media path, so nothing touches live audio or slows a call. The cost model above applies to any backend, because what you send decides the bytes.
Observe says "undetermined" where your data is blind, and it shows coverage gaps. That is another reason to keep every error trace when you sample. Evalgent Monitor is live. It flags tool-call failures, latency spikes, PII leakage and policy failures on production calls, with fix recommendations. Evalgent works with teams to set up evals and monitoring for their first agent, and it is not self-serve. Pricing questions go to the sales conversation, which you can start through the demo link.
How to estimate your voice agent observability cost in 7 steps
1. Fix the stored audio format - Write down codec, sample rate and channels. Compute bytes per minute, then check against one real recording.
2. Measure your span volume - Export one day of traces. Count spans per turn, turns per minute and bytes per span.
3. Add transcript and metrics bytes - Take them from the same export. Keep them apart because they are not sampled.
4. List your real prices - Convert each quote to dollars per GB, per GB-month or per GB scanned. Note region, tier and coverage. Leave "your price here" where you have no quote.
5. Set retention per tier - Choose days for audio, transcripts, traces and metrics. Apply them with lifecycle rules.
6. Apply the sampling rule - Keep every error, slow and handed-off call. Set a rate for healthy calls. Compute K and redo the telemetry lines.
7. Run the sensitivity table - Change span size, ingest price, codec and retention one at a time. Then add the blindness term to see break-even.
Frequently asked questions
How much does voice agent observability cost per minute?
It depends on bytes per minute and your prices. In the illustrative model here, the data costs about $0.087 per 1,000 call minutes at placeholder rates. Fat spans, a high ingest price or long audio retention can multiply that several times. Build the model with your own bytes and quotes before trusting any figure.
How much storage does a call recording use?
Storage per minute equals bytes per second times 60. A stereo G.711 recording is 16,000 bytes per second, or 960,000 bytes per minute. An 8 kHz, 16-bit mono PCM recording is also 960,000. Stereo 16 kHz PCM is 3,840,000. Opus at a chosen 24 kbit/s mono is 180,000.
How many bytes per minute is G.711 audio?
G.711 is 64 kbit/s per channel, which is 8,000 bytes per second. That is 480,000 bytes per minute for mono and 960,000 for stereo. RFC 3551 gives the 8,000 clock rate and eight bits per sample. Container headers add a small amount that this model ignores.
Does trace sampling reduce observability cost?
Yes, for the telemetry lines. Keep all errors, slow calls and handoffs, then sample healthy traces. With an 8% keep-all share and 10% healthy sampling, you store 17.2% of traces in the illustrative model. Sampling does not shrink audio storage, so total savings depend on how much of your bill is telemetry.
What drives voice agent observability cost the most?
Four inputs: audio codec and sample rate, retention days, bytes per span, and the backend's ingest price. In the illustrative runs, wideband stereo audio kept 365 days cost about 11 times the base. Full prompts on spans and a tenfold ingest price each tripled it. Measure your own mix.
How long should I keep call recordings?
Cost is one input, not the rule. Retention depends on your consent terms, regulation and how often you replay old calls. Set a shorter period for raw audio and a longer one for metrics, and enforce it with lifecycle rules. This is not legal advice, so check the rules that apply to you.
Is stereo or mono call recording cheaper?
Mono is half the size of stereo at the same format. Stereo costs twice as much to store but separates the two parties. If you need to tell who spoke, pay for stereo and compress it instead of mixing to mono.
Is voice agent observability worth the cost?
Compare the model's monthly bill with the cost of blindness. That is undetected minutes times calls per minute, times the failed share, times the cost of one failed call. If your detection delay is long, the bill is small beside the loss.
The bottom line
Voice agent observability cost per minute is bytes per minute times price times retention, summed over audio, ingest, retention, query and egress. Measure your own span size, codec and retention first, because they move the bill more than call volume does.
Related Articles

How to automate voice agent testing: synthetic callers vs manual QA
Learn how ai test automation replaces manual QA for voice agents. Compare synthetic callers vs human testers, with a 5-step framework to scale without hiring.
Read more
AI Agent Testing vs Voice Agent Testing: What General Tools Miss for Voice
AI agent testing measures text outputs. Voice agent testing measures behaviour through an acoustic pipeline. Five failure categories general tools miss.
Read more