Dialtrace: The Tool Measuring Silence in Voice AI Calls

Overview

The rise of voice AI has created a new UX bottleneck that existing benchmarks fail to capture. Most latency metrics focus exclusively on the software pipeline—speech-to-text, large language model processing, and text-to-speech. They ignore the telecommunication layer where the majority of perceived delay actually occurs for end users.

A new open-source tool called dialtrace aims to solve this visibility gap by placing carrier events and internal pipeline stages on a single timeline. By measuring real-world phone calls rather than isolated API cycles, it reveals where silence truly originates.

The Hidden Cost of Telephony Silence

Industry standards for voice AI latency typically measure three components: speech-to-text conversion, model inference, and text-to-speech synthesis. Teams routinely optimize these stages to achieve sub-600ms response times. However, callers frequently experience delays exceeding one second, suggesting a disconnect between benchmarked performance and actual user experience.

According to dialtrace data, a significant portion of this wait time occurs before the AI even begins processing. In tests involving a direct call from a US number to a Dutch mobile line with no AI in the path, callers waited 640ms after picking up before hearing a single syllable. This demonstrates that telephony signaling and network routing consume nearly a third of typical sub-second latency budgets.

"None of them measure the phone call," notes the project documentation. "So teams tune a 900ms pipeline down to 600ms and the caller still waits."

This fragmentation forces engineers to blame carriers for delays that may be self-inflicted through inefficient API round trips or TLS handshakes. Dialtrace separates these variables, allowing developers to distinguish between genuine telephony latency and architectural overhead.

How Dialtrace Works

The tool operates as a zero-dependency Node.js package that requires only a Telnyx API key and a Call Control App to function. Users can run immediate diagnostics using the command npx dialtrace demo or initiate live calls with specific parameters.

The system captures carrier events such as call initiation, ringing, and answered states. It simultaneously accepts custom markers via a local HTTP endpoint, allowing developers to inject their own pipeline stages into the visualization.

Timeline Integration

While a call is active, agents can POST JSON payloads to a local receiver to tag specific moments. Three lines of code are typically sufficient to integrate major milestones:

• stt.first_partial: When the speech-to-text engine returns initial audio fragments.
• llm.done: When the language model completes its generation.
• tts.first_byte: When text-to-speech begins outputting audio.

Labels such as tts.first_byte or first_audio are automatically recognized as the moment the caller stops hearing silence, aligning with the carrier's own playback events.

Sample Output Analysis

A typical run generates a visual timeline showing exactly where time is consumed. In a recent demonstration, the breakdown revealed:

1. API round trip: 121ms (8%)
2. Setup and ring: 3,789ms (signaling plus human answer time)
3. Media path: 114ms (7%)
4. Custom pipeline: 1,378ms (85%)

The tool also calculates clock skew between the developer's machine and Telnyx's servers, providing an error bar to indicate measurement uncertainty. This transparency prevents users from quoting false precision when comparing different infrastructure setups.

What the Data Reveals

Beyond latency, dialtrace extracts call quality metrics directly from Telnyx’s hangup webhooks. Developers previously had access to these stats but often overlooked them because they were buried in the OpenAPI specification.

The tool reports:

• Mean Opinion Score (MOS): Perceived audio quality for both inbound and outbound streams.
• Packet loss and jitter: Derived from skip counts against total packet counts.
• Call duration and disposition: Including who ended the call and why.

In the same test call mentioned earlier, inbound audio scored a MOS of 4.21 with 1.43% packet loss, while outbound audio achieved 4.48 MOS with only 0.20% loss. These figures help teams determine whether latency issues stem from poor network conditions or software architecture.

Limitations and Scope

It is crucial to understand what dialtrace does not measure. Because it relies on webhook timestamps rather than raw RTP stream analysis, it cannot assess audio packetization delays or codec-specific artifacts. Any metric requiring deep inspection of the media path remains outside its scope.

Furthermore, the accuracy of cross-clock comparisons depends on the stability of the HTTP round trip between the developer’s server and Telnyx. If the API latency fluctuates wildly, the estimated clock skew increases, reducing confidence in precise millisecond-level claims.

Despite these constraints, the tool fills a critical void in the voice AI ecosystem. By forcing engineers to confront the reality of telephony latency, it encourages more holistic optimization strategies.

Moving Beyond Benchmarks

The voice AI industry has long suffered from metric myopia, celebrating fast model inference while ignoring the slow reality of global telephony. Dialtrace challenges this narrative by making the invisible visible.

For teams building conversational agents, the message is clear: optimizing your LLM prompt is only part of the equation. Understanding the end-to-end journey of a call—including signaling delays, carrier quirks, and network quality—is essential for delivering a seamless user experience.

As voice AI moves from novelty to necessity, tools that provide ground-truth measurements will become indispensable. Dialtrace offers not just data, but a framework for accountability in an industry prone to inflated benchmarks.