How to Test and Measure AI Calling Audio Quality and Latency: A Complete QA Guide (2026)

Last Updated: July 27, 2026 | 16-minute read

The Blind Deployment Trap

In web application development, QA testing is straightforward: you write Jest unit tests, run Cypress end-to-end user flows, and verify assert statements. If a button click returns a 200 OK and renders a DOM component, the software passes.

In Real-Time Voice AI Engineering, standard QA methodologies completely fall apart.

Consider what happens when an engineering team deploys a voice AI receptionist without specialized audio testing:

1. The Latency Mirage: Logs show an LLM API latency of 250ms, but actual callers on cellular networks experience a agonizing 1.8-second dead-air pause before the agent speaks.
2. The Acoustic Distortion Blindspot: In a quiet office test, the text-to-speech (TTS) sounds natural. But when a customer calls from a noisy train station in Mumbai or a windy street in New York, the background noise triggers aggressive speech-to-text (STT) hallucination, causing the bot to babble nonsensically or cut out entirely.
3. The Robotic Cadence: The AI answers every question correctly according to text logs, but customers hang up within 15 seconds because the audio stream suffers from micro-stuttering and flat, synthetic intonation.

How can engineering teams objectively test, benchmark, and measure the conversational latency and audio clarity of an AI phone agent before releasing it to thousands of customers? In 2026, state-of-the-art Voice AI QA relies on two pillars: (1) Granular Latency Decomposition (measuring exact millisecond timestamps across network RTT, ASR endpointing, LLM TTFT, and TTS audio synthesis) and (2) Automated Acoustic Scoring using neural audio evaluators like AI-Coustics and ITU-T POLQA (measuring human speech naturalness, echo cancellation, and noise robustness on a 1-to-5 Mean Opinion Score scale).

This guide provides a comprehensive blueprint for testing, benchmarking, and quality-assuring AI calling agents, featuring real-world measurement scripts, evaluation checklists, and how Tough Tongue AI automates continuous quality integration (CQI) to maintain 99.8% human-level speech fidelity.

Part of our Voice AI Architecture & Engineering Series. See also: Browser Reconnection & Session State · Tool Calling Latency & Serving Stacks · Turn Detection & Robotic Pauses · Event Loops & Scaling Concurrency

Pillar 1: How to Deconstruct and Measure Voice AI Latency

When a caller asks a question, how long does it take for the AI to start speaking its response?

In industry terminology, this is known as Voice-to-Voice Latency (or Turnaround Latency). A common amateur mistake is measuring only the LLM processing time. True conversational latency is a cumulative chain of six sequential hardware and network operations:

[User Stops Speaking on Cellular Phone]
               │
               ▼ (1. Network Inbound RTT & Jitter Buffer: ~40ms to 80ms)
[Server Receives Final Audio RTP Packet]
               │
               ▼ (2. VAD Silence Endpointing & ASR Finalization: ~60ms to 120ms)
[Text Transcript Generated by Speech Engine]
               │
               ▼ (3. Orchestration & Context Assembly: ~5ms to 15ms)
[Prompt Dispatched to LLM Serving Engine]
               │
               ▼ (4. LLM Time-to-First-Token (TTFT): ~100ms to 250ms)
[First Word Token Streaming from LLM]
               │
               ▼ (5. TTS Audio Synthesis & Encoding: ~40ms to 80ms)
[First Audio RTP Packet Push to Network Socket]
               │
               ▼ (6. Network Outbound RTT to Caller Speaker: ~40ms to 80ms)
[Caller Hears First Syllable of AI Response]

Metric 2: Turn-to-Turn Latency (TTFT, Time to First Byte, End-to-End)

The gold standard for conversational quality. Measured from the moment the user stops speaking (Voice Activity Detection endpoint) to the moment the first byte of agent audio reaches the caller's device.

Here is a nanosecond-precision end-to-end latency benchmark script that measures every component of your voice pipeline independently:

# latency_benchmark.py — Nanosecond-precision voice pipeline latency profiler
import time
import asyncio
import json
import statistics
from dataclasses import dataclass, field
from typing import Callable, Awaitable, Any

@dataclass
class LatencyResult:
    component: str
    samples: list = field(default_factory=list)

    @property
    def p50_ms(self) -> float:
        if not self.samples:
            return 0.0
        sorted_s = sorted(self.samples)
        return sorted_s[len(sorted_s) // 2]

    @property
    def p95_ms(self) -> float:
        if not self.samples:
            return 0.0
        sorted_s = sorted(self.samples)
        return sorted_s[int(len(sorted_s) * 0.95)]

    @property
    def p99_ms(self) -> float:
        if not self.samples:
            return 0.0
        sorted_s = sorted(self.samples)
        return sorted_s[int(len(sorted_s) * 0.99)]

    @property
    def mean_ms(self) -> float:
        return statistics.mean(self.samples) if self.samples else 0.0


async def benchmark_component(
    name: str,
    func: Callable[..., Awaitable[Any]],
    iterations: int = 100,
    warmup: int = 5,
    **kwargs,
) -> LatencyResult:
    """Benchmark a single pipeline component with nanosecond precision."""
    result = LatencyResult(component=name)

    # Warmup runs (excluded from measurements)
    for _ in range(warmup):
        await func(**kwargs)

    # Measured runs
    for i in range(iterations):
        start_ns = time.perf_counter_ns()
        await func(**kwargs)
        elapsed_ns = time.perf_counter_ns() - start_ns
        result.samples.append(elapsed_ns / 1_000_000)  # Convert to milliseconds

    return result


async def run_full_pipeline_benchmark(
    asr_func: Callable,
    llm_func: Callable,
    tts_func: Callable,
    tool_func: Callable = None,
    iterations: int = 100,
) -> dict:
    """Benchmark every component of the voice pipeline independently."""

    results = {}

    # 1. ASR (Speech-to-Text) latency
    asr = await benchmark_component("ASR", asr_func, iterations)
    results["asr"] = asr

    # 2. LLM (Cognitive processing) latency - Time to First Token
    llm = await benchmark_component("LLM_TTFT", llm_func, iterations)
    results["llm_ttft"] = llm

    # 3. TTS (Text-to-Speech) latency - Time to First Audio Byte
    tts = await benchmark_component("TTS_TTFB", tts_func, iterations)
    results["tts_ttfb"] = tts

    # 4. Tool calling latency (if applicable)
    if tool_func:
        tool = await benchmark_component("Tool_Call", tool_func, iterations)
        results["tool_call"] = tool

    # Calculate end-to-end estimate
    e2e_p50 = sum(r.p50_ms for r in results.values())
    e2e_p95 = sum(r.p95_ms for r in results.values())
    e2e_p99 = sum(r.p99_ms for r in results.values())

    report = {
        "components": {
            name: {
                "p50_ms": round(r.p50_ms, 2),
                "p95_ms": round(r.p95_ms, 2),
                "p99_ms": round(r.p99_ms, 2),
                "mean_ms": round(r.mean_ms, 2),
            }
            for name, r in results.items()
        },
        "end_to_end": {
            "p50_ms": round(e2e_p50, 2),
            "p95_ms": round(e2e_p95, 2),
            "p99_ms": round(e2e_p99, 2),
        },
        "verdict": "PASS" if e2e_p95 < 800 else "FAIL",
        "iterations": iterations,
    }

    return report


if __name__ == "__main__":
    # Example usage with mock functions (replace with your actual pipeline)
    async def mock_asr():
        await asyncio.sleep(0.06)  # Simulate 60ms ASR

    async def mock_llm():
        await asyncio.sleep(0.15)  # Simulate 150ms LLM TTFT

    async def mock_tts():
        await asyncio.sleep(0.04)  # Simulate 40ms TTS

    report = asyncio.run(run_full_pipeline_benchmark(
        asr_func=mock_asr, llm_func=mock_llm, tts_func=mock_tts,
        iterations=50,
    ))
    print(json.dumps(report, indent=2))

How to Use This: Replace the mock_* functions with actual calls to your ASR, LLM, and TTS services. Run this benchmark before every deployment to catch latency regressions. The verdict field provides an automatic PASS/FAIL gate against the 800ms p95 threshold.

How to Instrument Timestamps in Your Pipeline

To benchmark your voice agent accurately, you must inject precise nanosecond timestamps (process.hrtime.bigint() in Node.js or time.perf_counter_ns() in Python) at four mandatory architectural gateways:

1. T_0 (Speech_End): Triggered by your Voice Activity Detector (VAD) when 300ms of audio silence is detected.
2. T_1 (ASR_Final): Triggered when the speech-to-text WebSocket emits the is_final: true transcript event.
3. T_2 (LLM_First_Token): Triggered when the HTTP/WebSocket client receives the first non-whitespace character chunk from the language model.
4. T_3 (TTS_First_Audio): Triggered when the text-to-speech engine outputs its first 20ms PCM/Opus audio buffer ready for RTP transmission.

Formula for Internal Processing Latency: $\text{Latency}_{\text{Internal}} = (T_1 - T_0) + (T_2 - T_1) + (T_3 - T_2)$

If your internal latency exceeds 350ms, you must optimize your serving stack before deploying to public cellular networks.

Pillar 2: How to Measure Audio Quality and Speech Fidelity

Latency is only half the battle. An AI agent that responds in 200ms but sounds like a static-filled radio from 1985 will fail to convert leads or resolve customer issues.

How do engineers objectively measure audio clarity without listening to 5,000 test recordings manually?

1. Legacy Metrics: PESQ and POLQA

For decades, telecommunications engineers used PESQ (Perceptual Evaluation of Speech Quality) and POLQA (Perceptual Objective Listening Quality Analysis)—standardized ITU-T algorithms that compare a degraded audio stream against a clean reference recording.

• While effective for testing SIP codec compression (e.g., G.711 vs. G.722 Opus), legacy PESQ algorithms struggle to evaluate AI generative speech, often misclassifying natural human breath sounds and emotional vocal inflection as "audio distortion."

2. The Modern Standard: AI-Coustics and Neural MOS Evaluation

In 2026, industry leaders have adopted neural audio assessment models, such as those highlighted in LiveKit's acoustic research with AI-Coustics.

These deep learning models evaluate real-time audio streams across four critical vectors on a 1.0 to 5.0 Mean Opinion Score (MOS) scale:

• Speech Naturalness (MOS-N): Measures prosody, intonation pacing, syllable emphasis, and robotic artifacts. A score < 4.0 indicates artificial, uncanny-valley speech.
• Background Noise Robustness (MOS-B): Evaluates how cleanly the speech signal separates from ambient noise (e.g., call center chatter, wind, street sirens).
• Echo & Duplex Clarity (MOS-E): Detects acoustic echo feedback (when the bot's microphone captures its own speaker output) and evaluates half-duplex clipping during interruptions.
• Total Acoustic Quality (MOS-T): The unified benchmark score representing overall conversational clarity.

Building an Automated Quality Gate: CI/CD Pipeline for Voice AI

Manual QA testing is the single biggest bottleneck in voice AI deployment velocity. Production-grade voice AI operations demand a fully automated CI/CD quality pipeline that runs latency benchmarks and audio scoring on every commit.

Here is a complete GitHub Actions CI pipeline that blocks deployments if audio quality or latency regressions are detected:

# .github/workflows/voice-quality-gate.yml
name: Voice AI Quality Gate

on:
  push:
    branches: [main, staging]
    paths:
      - 'voice_agent/**'
      - 'models/**'
      - 'tts_config/**'
  pull_request:
    branches: [main]

jobs:
  audio-quality:
    name: PESQ Audio Quality Scoring
    runs-on: ubuntu-latest
    timeout-minutes: 10

    steps:
      - uses: actions/checkout@v4

      - name: Set up Python
        uses: actions/setup-python@v5
        with:
          python-version: '3.12'
          cache: 'pip'

      - name: Install dependencies
        run: |
          pip install pesq numpy scipy wave
          pip install -r requirements-test.txt

      - name: Generate test audio samples
        run: |
          # Run agent against 20 standard test utterances
          python scripts/generate_test_audio.py \
            --test-suite tests/audio_pairs/ \
            --output-dir /tmp/test_results/ \
            --agent-config config/production.yaml

      - name: Run PESQ scoring suite
        run: |
          python audio_quality_scorer.py /tmp/test_results/ | tee pesq_results.json
          # Extract pass/fail for GitHub step summary
          PASSED=$(python -c "import json; r=json.load(open('pesq_results.json')); print(r['suite_passed'])")
          if [ "$PASSED" != "True" ]; then
            echo "::error::PESQ Quality Gate FAILED - Audio quality below threshold"
            exit 1
          fi

      - name: Upload quality report
        uses: actions/upload-artifact@v4
        if: always()
        with:
          name: pesq-quality-report
          path: pesq_results.json

  latency-benchmark:
    name: Pipeline Latency Benchmark
    runs-on: ubuntu-latest
    timeout-minutes: 15
    services:
      redis:
        image: redis:7-alpine
        ports: ['6379:6379']

    steps:
      - uses: actions/checkout@v4

      - name: Set up Python
        uses: actions/setup-python@v5
        with:
          python-version: '3.12'

      - name: Run latency benchmark
        env:
          REDIS_URL: redis://localhost:6379
          LLM_ENDPOINT: ${{ secrets.LLM_STAGING_ENDPOINT }}
        run: |
          python latency_benchmark.py | tee latency_results.json
          E2E_P95=$(python -c "import json; r=json.load(open('latency_results.json')); print(r['end_to_end']['p95_ms'])")
          echo "E2E p95 latency: ${E2E_P95}ms"
          if (( $(echo "$E2E_P95 > 800" | bc -l) )); then
            echo "::error::Latency Gate FAILED - E2E p95=${E2E_P95}ms exceeds 800ms budget"
            exit 1
          fi

      - name: Post results to PR
        if: github.event_name == 'pull_request'
        uses: marocchino/sticky-pull-request-comment@v2
        with:
          header: latency-benchmark
          message: |
            ## 🎯 Voice Pipeline Latency Results
            | Component | p50 | p95 | p99 |
            |-----------|-----|-----|-----|
            | ASR | ${{ env.ASR_P50 }}ms | ${{ env.ASR_P95 }}ms | ${{ env.ASR_P99 }}ms |
            | LLM TTFT | ${{ env.LLM_P50 }}ms | ${{ env.LLM_P95 }}ms | ${{ env.LLM_P99 }}ms |
            | TTS TTFB | ${{ env.TTS_P50 }}ms | ${{ env.TTS_P95 }}ms | ${{ env.TTS_P99 }}ms |
            | **E2E** | **${{ env.E2E_P50 }}ms** | **${{ env.E2E_P95 }}ms** | **${{ env.E2E_P99 }}ms** |

Why This Matters: Without automated quality gates, audio regressions caused by model updates, TTS config changes, or infrastructure migrations slip into production undetected. The PESQ scorer catches audio degradation; the latency benchmark catches pipeline slowdowns. Both must pass before any voice agent change reaches production callers.

Pillar 3: Automated PESQ Scoring for Voice AI

PESQ takes a reference audio clip (what the agent should have said) and a degraded audio clip (what the caller actually heard) and produces a score from 1.0 (bad) to 4.5 (excellent). A production voice AI agent should consistently score above 3.8 MOS on PESQ and above 4.0 on POLQA to be considered human-quality.

Here is a production Python script for automated PESQ/POLQA scoring that integrates into your CI/CD pipeline:

# audio_quality_scorer.py — Automated PESQ scoring for voice AI quality gates
import numpy as np
import wave
import json
from dataclasses import dataclass
from typing import Tuple
from pathlib import Path

try:
    from pesq import pesq
except ImportError:
    raise ImportError("pip install pesq")

SAMPLE_RATE = 16000  # Voice AI standard: 16kHz narrowband
MIN_ACCEPTABLE_MOS = 3.8  # Below this = quality regression, block deployment
TARGET_MOS = 4.2  # Production target for human-quality experience

@dataclass
class AudioQualityReport:
    pesq_mos: float
    passed: bool
    reference_file: str
    degraded_file: str
    sample_rate: int
    details: str

def load_wav(filepath: str) -> np.ndarray:
    """Load a WAV file and return float32 audio samples."""
    with wave.open(filepath, 'r') as wf:
        assert wf.getsampwidth() == 2, "Expected 16-bit PCM audio"
        assert wf.getframerate() == SAMPLE_RATE, f"Expected {SAMPLE_RATE}Hz sample rate"
        frames = wf.readframes(wf.getnframes())
        audio = np.frombuffer(frames, dtype=np.int16).astype(np.float32)
        return audio / 32768.0  # Normalize to [-1.0, 1.0]

def score_audio_quality(
    reference_path: str,
    degraded_path: str,
    mode: str = "wb",  # "wb" = wideband, "nb" = narrowband
) -> AudioQualityReport:
    """Compare reference vs degraded audio and return PESQ MOS score."""
    ref = load_wav(reference_path)
    deg = load_wav(degraded_path)

    # Align lengths (trim to shorter) — in production, use cross-correlation alignment
    min_len = min(len(ref), len(deg))
    ref = ref[:min_len]
    deg = deg[:min_len]

    mos_score = pesq(SAMPLE_RATE, ref, deg, mode)

    passed = mos_score >= MIN_ACCEPTABLE_MOS
    details = (
        f"PESQ MOS: {mos_score:.2f} "
        f"({'PASS' if passed else 'FAIL'}) "
        f"[threshold={MIN_ACCEPTABLE_MOS}, target={TARGET_MOS}]"
    )

    return AudioQualityReport(
        pesq_mos=round(mos_score, 2),
        passed=passed,
        reference_file=reference_path,
        degraded_file=degraded_path,
        sample_rate=SAMPLE_RATE,
        details=details,
    )


def run_quality_suite(test_pairs_dir: str) -> dict:
    """Run PESQ scoring across all reference/degraded pairs in a directory."""
    results = []
    test_dir = Path(test_pairs_dir)

    for ref_file in sorted(test_dir.glob("*_reference.wav")):
        deg_file = test_dir / ref_file.name.replace("_reference.wav", "_degraded.wav")
        if not deg_file.exists():
            continue

        report = score_audio_quality(str(ref_file), str(deg_file))
        results.append({
            "test_case": ref_file.stem.replace("_reference", ""),
            "mos": report.pesq_mos,
            "passed": report.passed,
            "details": report.details,
        })

    all_passed = all(r["passed"] for r in results)
    avg_mos = sum(r["mos"] for r in results) / len(results) if results else 0

    return {
        "suite_passed": all_passed,
        "average_mos": round(avg_mos, 2),
        "total_tests": len(results),
        "results": results,
    }


if __name__ == "__main__":
    # Example: run quality suite from command line
    import sys
    test_dir = sys.argv[1] if len(sys.argv) > 1 else "./test_audio_pairs"
    suite = run_quality_suite(test_dir)
    print(json.dumps(suite, indent=2))

    if not suite["suite_passed"]:
        print("\n❌ QUALITY GATE FAILED — Blocking deployment")
        sys.exit(1)
    else:
        print(f"\n✅ All {suite['total_tests']} tests passed (avg MOS: {suite['average_mos']})")

Architectural Comparison: Basic QA vs. Enterprise CQI Pipelines

How Tough Tongue AI Automates Audio QA and Latency Benchmarking

At Tough Tongue AI, we do not rely on guesswork or subjective listening tests to guarantee voice quality. We built an industrial-grade benchmarking harness directly into our core telephony orchestration engine.

When you deploy a voice agent on our platform, your infrastructure is continuously backed by:

• Real-Time Latency Telemetry: Our dashboard displays live, broken-down latency metrics for every single call, tracking exact STT endpointing, LLM time-to-first-token (TTFT), and TTS audio synthesis in milliseconds.
• Automated 150-Point Acoustic Grading: Every agent deployment is subjected to automated synthetic calling simulations across Indian dialects (Hindi, Tamil, Marathi, Telugu), noisy cellular line profiles, and rapid barge-in scenarios before release.
• Sub-400ms Turnaround Guarantee: By utilizing custom edge-optimized speech-to-text models and continuous batching LLM serving stacks, Tough Tongue AI consistently maintains an average voice-to-voice latency of 380 milliseconds across global and Indian SIP carriers.
• Proven in Blind User Studies: In our rigorous 150-person blind evaluation against competitors, human evaluators ranked Tough Tongue AI #1 for Naturalness (4.8/5.0 MOS) and #1 for Conversational Speed, proving that engineering discipline translates directly into superior user experience.

Evaluation Checklist: The Voice AI Pre-Launch QA Audit

Before launching an AI voice receptionist or outbound sales bot to live customer phone lines, execute this mandatory 5-point QA audit:

• The 400ms Latency Decomposition Audit: Log timestamps for 50 test calls. Verify that your combined internal latency ($T_1 \to T_3$) consistently remains under 400 milliseconds. If any single component (like STT or LLM) consumes over 250ms, halt deployment until optimized.
• The 65dB Background Noise Test: Call your voice bot from an active café or while playing heavy traffic sounds on a speaker at 65 decibels. Verify that the bot transcribes your words accurately without hallucinating or dropping your call.
• The Rapid-Fire Barge-In Test: While the bot is speaking a long sentence, interrupt it abruptly with a short command ("Stop, give me the pricing"). Verify that the bot immediately halts its speech within 150ms and pivots to answer your new question without finishing its previous sentence.
• The Indian Dialect & Accent Verification: If deploying in India or diverse global markets, test your bot using regional accents (e.g., South Indian English, Hinglish, or Punjabi inflection). Verify that your speech-to-text Word Error Rate (WER) remains below 8%.
• The 24-Hour Stress & Memory Leak Audit: Run an automated test suite that executes 100 continuous, 5-minute conversations against your staging server over 24 hours. Monitor audio MOS scores; if audio fidelity degrades or micro-stuttering appears after hour 12, check your media server for uncollected audio buffers or event loop lag.

Deploy Flawless, Human-Grade AI Voice Agents Today

Stop guessing whether your AI calling bot sounds good enough for your customers. Replace manual testing with an enterprise-grade voice AI platform engineered from the ground up for sub-400ms latency and crystal-clear acoustic quality.

Experience the difference in real time:

• Book a private live benchmarking & audio QA demo with Ajitesh
• Test our sub-400ms conversational latency in an interactive sandbox
• Review our blind test comparison results against top industry competitors

Frequently Asked Questions (FAQ)

What is a good Mean Opinion Score (MOS) for an AI calling agent?

A Mean Opinion Score (MOS) is a numerical rating from 1.0 (unintelligible distortion) to 5.0 (perfect human clarity). For commercial AI phone calling agents, a MOS of 4.0 to 4.3 is considered acceptable for general customer service, while state-of-the-art enterprise platforms like Tough Tongue AI achieve 4.6 to 4.8 MOS, which is acoustically indistinguishable from a high-definition human phone call.

How do I calculate Word Error Rate (WER) for AI speech-to-text?

Word Error Rate (WER) is calculated using the Levenshtein distance formula: $WER = \frac{S + D + I}{N}$, where $S$ is the number of substituted words, $D$ is deletions, $I$ is insertions, and $N$ is the total number of words in the clean reference transcript. For high-volume business telephony, your speech-to-text WER must remain under 6% to 8% to prevent downstream LLM hallucination.

What causes an AI voice agent to pause for 2 seconds before answering?

A 2-second pause (high latency) is typically caused by a sequential bottleneck in the AI pipeline. Common culprits include: (1) An unoptimized Voice Activity Detector (VAD) waiting 800ms of silence before deciding the user finished speaking, (2) Routing LLM requests to slow public cloud models (like standard GPT-4) without streaming token generation, or (3) Waiting for the text-to-speech (TTS) engine to synthesize an entire paragraph before transmitting the first audio packet.

How do I test AI calling voice bots against regional Indian accents?

To test against regional Indian accents, build an automated testing suite utilizing prerecorded audio datasets representing diverse Indian demographics (e.g., Hindi-English, Tamil-English, Telugu, and Marathi speakers). Run these audio streams through your telephony gateway and evaluate STT transcription accuracy and response relevance. Platforms like Tough Tongue AI come natively pre-trained on Indian dialects and code-switching to guarantee high accuracy out of the box.

Why is AI-Coustics better than traditional PESQ for testing generative voice AI?

Traditional PESQ (Perceptual Evaluation of Speech Quality) algorithms were designed in the 1990s to test static telecom compression codecs (like G.711) by mathematically comparing waveforms against a fixed reference recording. Because generative AI text-to-speech creates dynamic vocal inflection, natural breath pauses, and varied pacing, PESQ often penalizes high-quality AI voices. Modern neural evaluators like AI-Coustics analyze acoustic naturalness, prosody, and noise robustness using deep neural networks trained on human acoustic perception.

Further Technical Reading & References:

• LiveKit Technical Blog: Testing Audio Quality of LiveKit Agents with AI-Coustics
• LiveKit Technical Blog: Open-Source Audio Intelligence for Real-Time Applications
• Tough Tongue AI: Voice AI Blind Test — Tough Tongue vs Gnani vs Bolna
• Tough Tongue AI: Scaling AI Calling from Pilot to Production in Enterprise