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 thesid, 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.
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 for | Grain |
|---|---|---|
| Reconstruct exactly what happened on a call — ring, talk, hold, queue, wrap-up, and the AI-vs-human split | Call traces | One 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 sounded | MOS / jitter / loss | One quality record per call |
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.
Related
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.