You can see everything a call does, in real time and after it hangs up. TeleQuick Voice records each call’s signalling, media quality, and agent behaviour as it happens, then folds it into durable records you can query, chart, and alert on — without you running a metrics pipeline. Every view keys off the same identifier: a call’s sid. The live-ops row, the per-segment trace, the one-row CDR, the quality score, and the traffic tally all hang off that one key, so you can pivot from “what’s ringing right now” to “why did this specific call sound bad” without stitching IDs across systems.

What you can see

Live call state

Every call that’s currently up — who’s on it, which leg (PSTN, SIP, browser, AI agent), and what state it’s in (ringing, talking, held, queued). Pushed to your live-ops screens, not polled.

Per-segment call traces

One row per segment of a call — the AI-handled leg and the human-handled leg are split out, each with its own ring / talk / hold / queue / wrap-up timings. Trace a call end-to-end across signalling, media, and the agent.

Per-call CDRs

One durable row per completed call: start, answer, and clear timestamps, duration, the standardized clear reason (Q.850), the codec used, and whether an agent handled it. The billing- and reporting-grade record.

Quality metrics

MOS, jitter, and packet loss for the media leg of every call, scored on the ITU-T E-model straight from loss and jitter — so you can rank calls by how they actually sounded.

Per-tenant traffic

Bytes and bandwidth attributed per workspace and per modality, with voice media counted per-tenant per-call. Know exactly who is driving load.

Dashboards

Prebuilt production views — all-calls reports, wallboards, agent timelines, VDN flow, and the traffic & bandwidth board — sitting on top of all of the above.

Live call state

While calls are in flight, the engine streams state transitions — initiated, ringing, answered, held, resumed, transferred, cleared — to your operations screens as they happen. Because updates are pushed over the same low-latency transport the media rides, a wallboard reflects the floor within a tick rather than on a polling interval. Each live row tells you the sid, the legs attached (a PSTN caller, a SIP deskphone, a browser softphone, an AI agent), the current state, and — once an AI segment exists — that the call is being handled by an agent. This is the same event stream that later becomes the per-segment trace, so what you watch live and what you query afterwards never disagree.
Everything you can see live, you can also fetch on demand — list the currently active calls from the control-plane API when you need a point-in-time snapshot rather than a stream. See the SDK’s call control surface under Calls.

Per-segment traces vs. one-row CDRs

These are two different grains of the same call, and you’ll reach for each in different situations.
You want to…Reach forGrain
Reconstruct exactly what happened on a call — ring, talk, hold, queue, wrap-up, and the AI-vs-human splitCall tracesOne row per segment
Bill, count, or report on completed calls (duration, clear reason, codec, agent-handled)CDRs (below)One row per call
Judge how a call soundedMOS / jitter / lossOne quality record per call
A call trace captures every lifecycle transition folded per sid. When a call is transferred from an AI agent to a human, the trace shows two segments — the AI leg and the human leg — each with its own timings, so you can see how long the caller spent with the bot before the warm handoff and how the human leg went. This is what powers agent timelines, wrap-up-to-ready analysis, and VDN flow reports. A CDR is the single settled row written when a call clears: start / answer / clear timestamps, total duration, the Q.850 clear reason mapped to a status, the negotiated codec, and the agent handler (if any). It’s the record you export for billing and long-horizon reporting. Both are derived from the same lifecycle events, so a CDR and its trace always tell the same story at their two grains — see Call lifecycle for the transitions they’re built from.

Quality: MOS, jitter, and loss

For every call’s media leg, the media plane continuously measures packet loss and jitter and scores an estimated MOS using the ITU-T G.107 E-model. That score lands alongside the call’s other records, so “sort my calls by worst audio quality” is a first-class query, not a forensic exercise. Because the score is computed from the same loss and jitter counters the media plane already tracks per call, it costs nothing extra at call time and is available the moment the call clears. Reading and acting on these numbers is covered in MOS, jitter & packet loss.

Per-tenant traffic

The engine attributes bytes and bandwidth to the workspace that generated them, broken down by modality, with voice media counted per-tenant per-call. This rolls up into a Traffic & Bandwidth view so you can answer “which workspace is driving the load right now” and “how has this tenant’s voice traffic trended” from one place. It’s the load-and-cost lens over the same fleet the CDRs describe.

Dashboards

Sitting on top of live state, traces, CDRs, quality, and traffic are prebuilt production dashboards: all-calls and call-detail reports, live wallboards, agent timelines, VDN-flow and skill-drill views, and the traffic board. Which ones to watch — and which are polished vs. still filling in — is covered in Production dashboards.
Some dashboard tiles depend on features you may not have enabled (for example, a skill-queue view is only populated once you’re routing through an ACD skill). Where a view has no data yet, it renders empty rather than fabricating numbers — treat an empty panel as “no traffic on that path,” not as an outage.

When the summary isn’t enough

The records above tell you what happened. When you need to know why — a call that sounds wrong, a transfer that never connected, an agent that talks over the caller — drop down a level:

SIP / RTP debugging

Inspect the telephony leg: SIP transactions, SDP negotiation, and the RTP media flow behind a specific sid.

Packet-level debugging

Go all the way to the wire when the summaries and traces don’t explain it.

Latency breakdown

See where the milliseconds go, hop by hop, across the transport and the agent turn.

Barge-in debugging

Diagnose turn-taking: false barge-ins, missed interruptions, and the agent talking over the caller.

Call lifecycle

The lifecycle transitions that every trace and CDR is built from.

Sessions, calls, tracks & streams

The sid object model that ties every observability view together.