Run a cascaded agent when you want to pick the best model for each stage instead of a single duplex model. The runtime chains three provider sessions per call: 
caller audio (PCM16, 8 kHz)
   -> ASR   (speech -> text)          e.g. Deepgram
   -> LLM   (text  -> reply text)     e.g. OpenAI / Anthropic / Gemini / Ollama
   -> TTS   (text  -> speech)         e.g. ElevenLabs / Cartesia
   -> caller audio
You choose each provider independently in one agent-config.yml, drop in the credentials, and the TeleQuick Agent Runtime opens a streaming session with each vendor on the caller’s shard. No code — the pipeline is assembled from config.
Prefer a single low-latency duplex model? See BYO speech-to-speech, which sets pipeline_mode: realtime and hands the whole turn to one provider (OpenAI Realtime, Gemini Live, and others). A cascade gives you more control and per-stage swappability; speech-to-speech gives you the lowest turn latency.

​
Set the pipeline

1

Choose your three providers

Pick one id from each table below. The defaults — deepgram for ASR, openai for LLM, elevenlabs for TTS — are what a bare cascade falls back to, so you can start by overriding just the stage you care about.
2

Add credentials

Each provider reads a per-tenant key resolved at call setup (see Credentials). Set the keys for the providers you selected — an agent with no usable provider key is refused rather than started.
3

Write agent-config.yml

Set pipeline_mode: cascaded and the per-stage provider/model/voice fields. Full example below.
4

Save and place a test call

Config is hydrated into the runtime from the control plane — no rebuild. Place a call and watch the latency breakdown to see per-stage timing (ASR final, LLM first token, TTS first audio).

​
agent-config.yml

agent-config.yml
name: support-agent
pipeline_mode: cascaded          # ASR -> LLM -> TTS chain (vs. "realtime")

# --- Speech-to-text ---
asr_provider: deepgram
asr_model: nova-2                # forwarded onto the ASR socket

# --- Language model ---
llm_provider: openai
llm_model: gpt-4o-mini
temperature: 0.4
conversation_memory_messages: 20 # rolling history the runtime replays each turn
llm_max_retries: 2               # retry the primary provider on a failed turn...
llm_fallback_provider: anthropic # ...then fall back once to this provider

# --- Text-to-speech ---
tts_provider: elevenlabs
tts_voice: <voice-id>            # ElevenLabs voice_id / Cartesia UUID / Deepgram Aura voice

# --- Shared ---
language: en                     # ISO 639-1 hint; pins the agent's output language
system_prompt: >
  You are a friendly support agent for Acme. Keep replies short and spoken-friendly.
The runtime processes audio as PCM16 LE at 8 kHz end to end, so every provider you pick is fed and drained at that rate (Deepgram is opened with encoding=linear16; providers that natively want 16/24 kHz are resampled for you).

​
ASR providers

Set asr_provider (and optionally asr_model, forwarded as the provider’s model hint).
asr_providerVendorNotes
deepgram (default)DeepgramStreaming, interim + final transcripts. Default model nova-2.
elevenlabsElevenLabsStreaming ASR surface (shares your ElevenLabs key).
Additional streaming ASR ids exist for Indic and regional coverage and for self-hosted transcription on a co-located model server — see Self-hosted inference. Deepgram is the recommended default for English telephony.

​
LLM providers

Set llm_provider and llm_model. The LLM stage is where tool calling runs — see Tool calling. 
llm_provider: openai      # default when llm_provider is unset
llm_model: gpt-4o-mini
llm_fallback_provider runs a different provider entirely if the primary fails after llm_max_retries, so a vendor incident degrades one turn instead of dropping the call. It is a resilience path, not a load balancer.

​
TTS providers

Set tts_provider and put the provider’s voice id in tts_voice.
tts_providerVendorVoice field
elevenlabs (default)ElevenLabstts_voice = ElevenLabs voice_id (streaming, low first-audio).
cartesiaCartesia (Sonic)tts_voice = Cartesia voice UUID (streaming WebSocket).
cartesia-httpCartesiaSame voices, one-shot HTTP fallback (no streaming).
deepgramDeepgram (Aura)tts_voice = Aura voice, e.g. aura-asteria-en.
openaiOpenAIReuses your OpenAI key; one-shot per utterance.
Streaming TTS providers emit audio as the LLM text arrives, which is what keeps first-audio low. If a provider can’t open a streaming session (missing voice, bad key), the runtime falls back to a one-shot synthesis for that turn so the caller still hears a reply.

​
Credentials

Provider keys are per-tenant. Set them in the TeleQuick console at agent.telequick.dev and they are resolved from the control plane at call setup, sealed at rest, and injected into the pipeline — they are never baked into agent-config.yml. For single-tenant or local development, the runtime also reads keys from the environment as a fallback: 
export OPENAI_API_KEY=...
export ANTHROPIC_API_KEY=...
export GEMINI_API_KEY=...
export DEEPGRAM_API_KEY=...
export ELEVENLABS_API_KEY=...
export CARTESIA_API_KEY=...

# Ollama needs no key — just the endpoint
export OLLAMA_ENDPOINT=127.0.0.1:11434
An agent whose selected providers have no usable key is refused at session creation with a clean error rather than starting and failing mid-call. Confirm each stage’s key is present before you route live traffic to the agent.

​
What runs around the cascade

  • Turn detection. A cascade uses local, on-device VAD by default (the runtime owns endpointing and barge-in) rather than a cloud provider’s server VAD. Tune the thresholds, barge-in hold window, and idle watchdog on the turn detection page.
  • Language. The language hint prepends a hard directive to the system prompt so the model answers in your market’s language instead of mirroring the caller.
  • Session limits. Connect/idle/max-session deadlines apply per stage; see Session lifecycle.
Backchannel suppression in a cascade is acoustic (utterance duration + a hold-and-confirm barge window) — short “mhm”/“ok” replies don’t interrupt the agent. Lexical gating (“stop” vs “ok”) is not built; plan around the acoustic behavior. See turn detection.

​
Next steps

Runtime configuration

Every knob: turn detection, budgets, guardrails, and codecs.

Speech-to-speech

Trade per-stage control for the lowest turn latency with a single duplex model.

Tool calling

Give the LLM stage HTTP, MCP, and client tools.

Latency breakdown

See per-stage ASR / LLM / TTS timing on a live call.