How Answering Machine Detection (AMD) Works in AI Calling: Distinguishing Voicemail in Under 800ms (2026)

Legacy Energy Threshold vs Neural Acoustic AMD:

Legacy Energy Detection (2018 - 2023):
[Call Connects] ──► [Wait 2,500ms for Silence Window] ──► [50/50 Guess]
- Latency: 2,000ms to 3,500ms (Causes immediate human hang-up)
- Accuracy: ~75% (Fails on short greetings and background noise)

Neural Multi-Modal AMD (2026 Standard):
[Call Connects] ──► [Evaluate Spectrogram Cadence + First Token] ──► [Decision in <800ms]
- Latency: <800ms (Zero perceptible dead air for humans)
- Accuracy: 98.2% across carrier cellular networks

The Tripartite AMD Neural Decision Pipeline:

Inbound Telephony Audio Stream (First 800ms)
                     │
                     ▼
┌────────────────────────────────────────────────────────────────────────┐
│ 1. Temporal Speech Duration:                                           │
│    - Human Greeting: Typically short bursts (0.4s to 0.9s: "Hello?")   │
│    - Automated Voicemail: Continuous, uninterrupted speech (>2.2s)     │
└────────────────────────────────────────────────────────────────────────┘
                     │
                     ▼
┌────────────────────────────────────────────────────────────────────────┐
│ 2. Acoustic Spectral Harmonics & Pitch Inflection (F0):                │
│    - Human: Variable pitch, rising inflection on greeting question     │
│    - Machine: Uniform synthesizer pitch or studio-recorded flat cadence│
└────────────────────────────────────────────────────────────────────────┘
                     │
                     ▼
┌────────────────────────────────────────────────────────────────────────┐
│ 3. Streaming Phonetic Token Matching:                                  │
│    - Keywords detected in <500ms: "message", "tone", "unavailable"     │
└────────────────────────────────────────────────────────────────────────┘
                     │
                     ▼
[Classification Emitted in <750ms: HUMAN or MACHINE]

Outbound Voicemail Routing Options:

Machine Detected (Classification Confirmed in <800ms)
                    │
       ┌────────────┴────────────┐
       ▼                         ▼
Option A: Hang Up (<20ms)   Option B: Leave Voicemail
- Saves telephony credits   - AI waits for carrier beep tone
- Recycles lead for next    - Plays tailored 20-second voicemail
  calling window            - Leaves callback number and name

import asyncio
import time

class AnsweringMachineDetector:
    """
    Evaluates initial 800ms of telephony audio to classify
    human greetings versus carrier automated voicemails.
    """
    def __init__(self):
        self.voicemail_keywords = {"leave", "message", "tone", "record", "unavailable", "reached"}

    async def analyze_initial_audio_burst(self, audio_duration_seconds: float, transcript_tokens: list) -> str:
        """Classifies call recipient in <800ms."""
        await asyncio.sleep(0.040) # Simulates neural inference latency

        # Rule 1: Keyword detection
        for token in transcript_tokens:
            if token.lower() in self.voicemail_keywords:
                print(f"[AMD @ {time.strftime('%X')}]: Keyword '{token}' detected -> MACHINE (Voicemail).")
                return "MACHINE"

        # Rule 2: Temporal duration check
        # Humans speak for <1.2s ("Hello, John speaking"). Machines speak continuously >2.0s.
        if audio_duration_seconds > 2.0:
            print(f"[AMD @ {time.strftime('%X')}]: Continuous speech duration ({audio_duration_seconds}s) -> MACHINE.")
            return "MACHINE"
        else:
            print(f"[AMD @ {time.strftime('%X')}]: Short greeting ({audio_duration_seconds}s) -> HUMAN.")
            return "HUMAN"

if __name__ == "__main__":
    amd = AnsweringMachineDetector()

    async def run_tests():
        # Scenario 1: Human says "Hello?"
        res1 = await amd.analyze_initial_audio_burst(0.65, ["hello"])
        print(f"Scenario 1 Result: {res1}")

        # Scenario 2: Machine says "You have reached the voicemail of..."
        res2 = await amd.analyze_initial_audio_burst(2.40, ["you", "have", "reached", "the", "voicemail"])
        print(f"Scenario 2 Result: {res2}")

    asyncio.run(run_tests())