DEV Community: anusha

I Built a Voice Agent That Switches Languages Mid-Call on Telnyx

anusha — Wed, 05 Aug 2026 23:02:02 +0000

Translation apps interpret between two people speaking different languages. Code-switching is different: one caller switches languages mid-conversation and the agent follows them. No interpreter, no restart, no separate vendors — one Telnyx AI Assistant that detects the spoken language on every turn and replies in kind.

The Telnyx code example is:

https://github.com/team-telnyx/telnyx-code-examples/tree/main/ai-multilingual-code-switching-agent-python

It is a Python Flask app with a simple browser page showing a phone number. No database, no Cloud Storage. Call the number, speak in English, switch to Spanish mid-conversation, and the agent follows you.

The Flow

A customer calls a support line. They start in English, switch to Spanish for a sensitive question, then switch back. The agent detects the language from their speech on every turn and replies in that language. No language picker menu, no "press 1 for English." The caller just speaks.

One phone number, one AI Assistant, five languages — English, Spanish, Portuguese, Hindi, and Mandarin.

How Code-Switching Works

The entire behavior lives in the assistant's instructions. There is no application-layer language detection, no routing, no manual STT/LLM/TTS pipeline. The LLM follows plain English instructions:

listen carefully to the caller. detect the language they are speaking on every turn.
reply in the same language the caller is using right now.
if the caller switches language mid-conversation or mid-sentence, switch with them.

The STT (Deepgram nova-3 with language: "auto") transcribes in whatever language the caller speaks. The LLM follows the instructions. The TTS (voice ultra katie) renders the reply in that language. One platform, one API key.

Why This Is Different From Translation

The existing ai-real-time-translation-bridge-python example connects two callers who speak different languages and translates between them. That is interpretation — two people, two languages, one bridge.

This example is code-switching — one caller, multiple languages, one agent. The agent is not translating. It is the agent. It replies in whatever language you speak, switches when you switch, and never says "I did not understand" or asks you to pick a language.

Key Technical Decisions

`deepgram/nova-3` with `language: "auto"`

Per the AI Assistants docs: "To enable a multilingual agent, set the transcription model to deepgram/nova-3." The language: "auto" setting lets nova-3 auto-detect the spoken language on every turn. Note: language: "multi" is not valid and returns a 400 error. Use "auto".

`voice ultra katie` in the instructions

The existing phone assistant examples use voice ultra katie in the instructions. Ultra supports 36+ languages, so one voice handles all five demo languages without switching voices per language.

`moonshotai/Kimi-K2.6`

A native Telnyx model — no external API key required.

The Flask App Is Minimal

Since the Voice AI Assistant handles the entire conversation, the Flask app only needs to:

Create/reuse the assistant via provision_assistant.py
Serve a page showing the inbound phone number
Log webhook events for observability

There is no call-control logic, no application-layer STT, no manual TTS. The conversation runs entirely on Telnyx.

Run It

git clone https://github.com/team-telnyx/telnyx-code-examples.git
cd telnyx-code-examples/ai-multilingual-code-switching-agent-python
cp .env.example .env
python provision_assistant.py
python app.py

Open the browser, call the number, speak in any language. Switch mid-conversation and the agent follows.

Related Examples

ai-real-time-translation-bridge-python — two-caller interpreter
ai-language-learning-phone-tutor-python — phone-based language tutor
language-learning-flashcards-python — browser-based pronunciation scoring

I Built a Language Tutor That Listens and Scores Your Pronunciation

anusha — Wed, 05 Aug 2026 22:11:18 +0000

Language learning apps work fine on a screen, but the hardest part is the thing screens avoid: actually speaking out loud and getting immediate feedback on whether you said it right.

Most voice-based language tools either play a recording or transcribe your speech. They don't do both in an interactive loop. I wanted to build something that does — something that plays a phrase, listens to you repeat it, and tells you whether you got it right.

The Telnyx code example is:

https://github.com/team-telnyx/telnyx-code-examples/tree/main/language-learning-flashcards-python

It is a Python Flask app with a browser UI. No phone number, no webhook tunnel, no Cloud Storage.

The Loop

The app uses all three Telnyx AI primitives in one interactive round-trip:

TTS speaks — an Ultra voice (Camila for Spanish, Valerie for French) plays a flashcard phrase. Audio autoplays.
You repeat — click Record, speak the phrase, click Stop.
STT transcribes — Whisper transcribes your speech.
Inference scores — Kimi-K2.6 compares your transcription against the target phrase and returns a score: correct, close, or wrong, plus a one-sentence tip.

One platform, one API key, no external services.

Why This Is Different From a Translator

The existing ai-content-translator-python example does STT → translate → TTS. It's one-directional: you speak, the app translates. This example is interactive: the app speaks to you, you speak back, the app evaluates you. The flow is completely different even though it uses the same three Telnyx primitives.

The Voices

The app uses native Ultra voices per language, not one English voice with language_boost:

Language	Voice
Spanish	Camila (es, Female)
French	Valerie (fr-FR, Female)

To add more languages, enumerate voices via GET /v2/text-to-speech/voices and add them to LANGUAGE_VOICE_MAP in app.py.

How the Scoring Works

The Inference call uses a system prompt that tells Kimi to compare the target phrase against the user's spoken text and return JSON with a score and a tip:

{"score": "correct", "feedback": "Great job, your pronunciation matched the target phrase perfectly!"}

Kimi-K2.6 is a reasoning model — it takes ~10 seconds to think before scoring, but the result is more nuanced than a simple string comparison. It accounts for minor accent differences (correct), noticeable errors like wrong or missing words (close), and completely wrong speech (wrong).

The Decks

The app ships with 4 pre-built flashcard decks:

Deck	Language	Cards
Spanish — Greetings	Spanish	8
Spanish — Numbers	Spanish	6
Spanish — Common phrases	Spanish	8
French — Greetings	French	6

Add more by editing FLASHCARD_DECKS in app.py. Each card has a phrase (what TTS speaks and what you repeat) and a translation (shown as a hint).

Run It

git clone https://github.com/team-telnyx/telnyx-code-examples.git
cd telnyx-code-examples/language-learning-flashcards-python
cp .env.example .env    # fill in TELNYX_API_KEY
pip install -r requirements.txt
python app.py           # starts on http://127.0.0.1:5050

Open the browser, pick a deck, listen, repeat, get scored.

One Thing to Watch

Kimi-K2.6 is a reasoning model. It spends tokens thinking before it produces the JSON score. If max_tokens is too low (I tried 200 at first), it runs out of tokens during reasoning and returns empty content. The fix is max_tokens: 1000 — enough for reasoning + the short JSON response. This is a Kimi-specific behavior; a non-reasoning model like Llama-3.3-70B would work with 200 tokens, but Kimi is the recommended Telnyx model.

Related Examples

ai-language-learning-phone-tutor-python — phone-based language tutor
ai-content-translator-python — STT + translate + TTS pipeline
multi-character-narrator-python — multi-voice TTS with emotions

I Wanted to Hear Every Telnyx Voice in One Scene, So I Built a Multi-Character Narrator

anusha — Wed, 05 Aug 2026 00:22:44 +0000

Telnyx ships over 700 Ultra voices across 36 languages with sub-100ms time-to-first-byte. The voices are not the problem. Hearing them is.

The docs list three. The Voices API returns 4,000+ across every provider. Voice pickers play a fixed sample sentence per voice. None of that tells you how a voice handles emotion, pacing, or character inside a real scene.

So I built a small app that lets you do exactly that. You write a short scene with a few characters, assign each character a different Telnyx Ultra voice and an SSML emotion, and render the whole thing into one MP3. Every voice speaks in character, in context, in one continuous audio file.

The Telnyx code example is:

https://github.com/team-telnyx/telnyx-code-examples/tree/main/multi-character-narrator-python

The Use Case

Voice pickers exist. They play a fixed sample sentence per voice. What they do not do is let you hear a voice inside a real scene — a tense argument, a calm narrator, a panicked character, a reassuring guide — because a single sample sentence does not tell you how a voice handles emotion, pacing, or character.

This example solves that. You write a short scene with a few characters. Each character gets a different Telnyx Ultra voice. Each character gets an SSML emotion. You hit render. The app fans out parallel TTS calls, stitches the per-line audio in script order, and plays you one continuous MP3 with every voice speaking in character.

The default scene is the Ides of March from Julius Caesar. Five characters, ten lines, five distinct voices, five different emotions:

Cassius — determined, plotting the assassination
Caesar — surprised, realizing the betrayal
Brutus — apologetic, justifying the act
Mark Antony — angry, mourning the fallen leader
Narrator — calm, setting the scene

One render, one MP3, every voice in context. That is the demo.

The Eight Curated Ultra Voices

The app ships with eight pre-built Telnyx Ultra voices curated for the most common use cases. Each one is a real Telnyx voice with a UUID voice ID that works on the REST endpoint.

Voice	Gender	Language	Best Use Case	Sound Profile
Asher	Male	en	Voice Assistants & Media	Smooth, dynamic, podcaster-style tone
Callie	Female	en	Coaching & Onboarding	High energy, encouraging, friendly tone
Clara	Female	en-US	General Purpose IVR/AI	Clear, standard US accent, versatile pacing
Howard	Male	en-US	Conversational Agents	Deep, reassuring, highly trustworthy
Allie	Female	en-US	Casual & Interactive AI	Conversational flow, natural pauses
Jasper	Male	en-GB	Finance & Healthcare	Calm, authoritative, precise delivery
Skyler	Neutral	en	Modern Brand Voice	Casual, tech-forward, friendly vibe
Arvin	Male	en	Navigation & Directives	Steady, clear cadence for detailed guidance

Pick any of the eight for any character. Click Preview to hear the voice with the selected emotion before rendering the whole scene.

Twenty Ultra SSML Emotions

Ultra supports inline SSML emotion tags placed before the text:

<emotion value="excited" />Great news — your order shipped early!

The app exposes all twenty Ultra SSML emotions as a per-character dropdown. Primary emotions: angry, excited, content, sad, scared. Additional: happy, enthusiastic, curious, calm, grateful, affectionate, sarcastic, surprised, confident, hesitant, apologetic, determined, frustrated, disappointed.

Each character in the default Julius Caesar scene is auto-assigned an emotion that fits the role. Cassius is determined. Caesar is surprised. Brutus is apologetic. Mark Antony is angry. The Narrator is calm. Same voice, different emotion, different delivery — all from one inline SSML tag per line.

How It Was Made

The app is a single Flask file with an inline browser UI. No phone number, no webhook, no Cloud Storage, no database. One env var: TELNYX_API_KEY.

The pipeline

POST /narrate  (script with speaker labels)
  -> parse script into ordered lines
  -> map speaker -> voice (8 curated Ultra voices, overridable)
  -> map speaker -> emotion (20 Ultra SSML emotions, overridable)
  -> parallel fan-out: one REST TTS call per line
     POST /v2/text-to-speech/speech
       text_type=ssml, output_type=binary_output
       <emotion value="..." /> wrapping when emotion set
  -> stitch per-line MP3 bytes in script order
  -> store in memory (1h TTL)
  -> return project_id + per_line_ttfb_ms + audio_url
  -> GET /audio/<project_id>.mp3 streams the stitched MP3

Why REST, not WebSocket

Ultra is REST-only on the public WebSocket. A 403 on wss://api.telnyx.com/v2/text-to-speech/speech is intentional. The app uses POST /v2/text-to-speech/speech with output_type: binary_output so it can measure true time-to-first-byte per line. Base64 mode would hide the real latency.

Why UUIDs, not display names

Ultra voice IDs are UUIDs in the Telnyx.Ultra.<uuid> format, not short display names like Telnyx.Ultra.Clara. Short names return 400 on the REST endpoint. The Voices API at GET /v2/text-to-speech/voices returns all available voices with their UUIDs — over 700 Ultra voices alone, filterable by provider == "telnyx" and id | startswith("Telnyx.Ultra.").

The app ships with eight curated UUIDs so the demo works out of the box, but the dropdown is easy to extend with any voice from the Voices API.

Parallel fan-out with per-line error isolation

The app uses ThreadPoolExecutor to render every line in parallel. If one line fails (e.g. an invalid voice override), the response includes an errors array and the stitched audio contains only the successful lines in script order. A failed line does not lose the whole render.

The browser UI

The UI auto-detects speakers as you type. Each speaker gets a voice dropdown, an emotion dropdown, and a Preview button that renders a short sample line in the selected voice with the selected emotion. The render button fans out the parallel TTS calls, stitches the result, and autoplays the MP3.

Run It

git clone https://github.com/team-telnyx/telnyx-code-examples.git
cd telnyx-code-examples/multi-character-narrator-python
cp .env.example .env    # fill in TELNYX_API_KEY
pip install -r requirements.txt
python app.py           # starts on http://127.0.0.1:5050

Open the browser UI. The default Julius Caesar script is pre-loaded. Pick voices, pick emotions, preview, render, play.

Where This Goes Next

The app is a starting point. Add more voices from the 700+ Ultra voices available via the Voices API. Add more languages — Ultra covers 36, and the same script-render-stitch pipeline works for any of them via language_boost. Add Cloud Storage for persistent, shareable audio URLs. Add more sample scripts — audiobook chapters, podcast intros, e-learning role-plays, game cinematics — any multi-speaker content where you want to hear voices in context.

The point is the same: hear Telnyx voices in a real scene, not a sample sentence. Everything else follows from that.

I Built a Website Voice Assistant That Can Actually Control the Page

anusha — Fri, 31 Jul 2026 17:07:24 +0000

A lot of website AI demos stop at answering questions.

The assistant can explain where something is, but it does not actually take you there. It can tell you to open settings, but it does not open settings. It can ask you to fill out a form, but it does not touch the form.

That is the difference I wanted to show with Telnyx AI Assistant client-side tools.

The Telnyx code example is here:

https://github.com/team-telnyx/telnyx-code-examples/tree/main/ai-assistant-client-side-tools-nextjs

The process is clone the sample, configure the same tool names and JSON schemas on your Telnyx AI Assistant, set the public assistant ID in the browser app, and then test the UI actions from the website call button.

The Idea

Client-side tools let a Telnyx AI Assistant invoke predefined JavaScript functions in the browser during a voice or chat conversation.

That sounds small, but it changes the demo.

Instead of saying:

Go to the AI Assistants page and click Create Assistant.

the assistant can call:

navigate_to_section
open_create_assistant_modal

The browser updates immediately because those functions are normal React state updates.

What I Built

The sample is a fictional SaaS dashboard called PolarForge AI. It is built with Next.js, React, TypeScript, and Tailwind CSS.

It has a sidebar, several dashboard sections, light and dark themes, an AI Assistants page, a Create Assistant modal, and an activity panel that logs every tool call.

The assistant can use five tools:

set_theme
navigate_to_section
open_create_assistant_modal
get_form_state
update_assistant_form

The interesting one is get_form_state, because it has to read current React state. It is not returning a hard-coded object. If the modal is open and the form says the assistant name is "Enterprise Concierge", the tool returns that visible state.

Why Client-Side Instead of Webhook?

Webhook tools are still useful. If the assistant needs to create an account, charge a card, update a CRM record, or call something with privileged credentials, that belongs on the backend.

But a lot of website actions are local:

switch to dark mode
open a modal
navigate inside a single-page app
fill a visible form
read page state
call APIs the browser is already authenticated to call

That is where client-side tools are a better fit. The assistant does not need a backend webhook just to change React state.

The Integration

The app uses @telnyx/ai-agent-lib:

<TelnyxAIAgentProvider agentId={agentId}>
  <ToolRegistrar executeTool={executeTool} />
  <TelnyxWidget />
</TelnyxAIAgentProvider>

Inside React, the tools are registered with:

client.registerClientTool("navigate_to_section", async (args) => {
  return executeTool("navigate_to_section", args);
});

The matching tool definitions still need to exist on the Telnyx AI Assistant. The names and JSON schemas need to match what the browser registers.

The Demo Moment

The clean version of the demo is:

User: switch to dark mode
Assistant: calls set_theme
Page: changes to dark mode

User: take me to AI Assistants
Assistant: calls navigate_to_section
Page: switches section without reload

User: create an assistant named Enterprise Concierge
Assistant: opens the modal and updates the name field
Page: shows the form update
Activity panel: logs every tool call

That is the proof: the assistant is not just talking about the app. It is controlling the app through approved browser functions.

Security Boundary

The browser does not get a Telnyx API key.

The sample uses public NEXT_PUBLIC_* configuration for the AI Agent Lib connection. If you need to provision an assistant or call the Telnyx REST API, do that from a secure server-side environment or through the Telnyx Portal.

The sample also validates every tool call. Unknown sections fail. Unknown form fields fail. Invalid voices or languages fail. Updating the form while the modal is closed fails.

That is the shape I would keep in a production app: small explicit tools, strict validation, and no privileged secrets in client-side code.

Resources

Code example: https://github.com/team-telnyx/telnyx-code-examples/tree/main/ai-assistant-client-side-tools-nextjs
Client-side tools docs: https://developers.telnyx.com/docs/inference/ai-assistants/client-side-tools
AI Agent Lib: https://www.npmjs.com/package/@telnyx/ai-agent-lib
Telnyx release note: https://telnyx.com/release-notes/client-side-tools-ai-assistants

I Built a Voice AI Assistant for Lab Results Notifications

anusha — Thu, 30 Jul 2026 18:22:31 +0000

Lab results are one of those healthcare workflows where the phone call sounds simple, but the product boundaries matter a lot.

A patient wants to know whether results are back. The clinic needs to verify identity. The system should disclose only what is appropriate. And if the patient needs the full report, the best answer is usually a secure portal link, not reading everything out loud or putting lab values in an SMS.

So I built the sample as a notification assistant, not a clinical assistant.

The Telnyx code example is here:

https://github.com/team-telnyx/telnyx-code-examples/tree/main/ai-lab-results-notification-voice-python

It uses Telnyx AI Assistants with a small Python + Flask app for the screen-share dashboard and optional backend extension points.

The Flow

The caller dials a Telnyx phone number that is assigned directly to the AI Assistant.

The assistant asks for:

Full legal name
Date of birth

Only after those match a mock record does it disclose the lab result summary.

For the normal result path, the assistant says the result is back and within the expected range, then asks whether the patient wants a secure portal link by text.

If the patient says yes, the assistant uses Telnyx native messaging to send a portal link. The text does not include lab values.

For abnormal or borderline examples, the assistant gives follow-up language and points the patient toward a nurse callback or clinical staff.

The Part I Care About

The AI is not practicing medicine.

The AI is not interpreting raw lab values.

The AI is not replacing the provider.

It is doing the operational part:

verify identity
give a short provider-approved summary
send the patient to the secure portal
route follow-up

That distinction matters in healthcare AI demos. A good demo should show what the system can do, but also show what it refuses to do.

Why Use Telnyx AI Assistants Here

The cleanest version of this demo does not need a custom tunnel in the call path.

The phone number is assigned directly to the Telnyx AI Assistant. The assistant is provisioned from provision_assistant.py. The SMS link uses the assistant's native send_message tool.

That means the live demo path is:

Telnyx number
  -> Telnyx AI Assistant
  -> native SMS link

The Flask app is still useful, but mostly for the demo dashboard and optional backend extension points.

That keeps the call experience simple enough to explain on screen.

The Dashboard

I also added a local Flask UI at:

http://127.0.0.1:5000

It shows:

call flow
mock patient test identities
HIPAA compliance safeguards
local audit and callback state

It does not show API keys, real PHI, the raw assigned phone number, or raw transcripts.

That screen is useful for a video because it gives viewers something concrete to look at while the phone call is happening.

HIPAA Compliance Safeguards

This sample is designed around the safeguards expected in a HIPAA-compliant lab results notification workflow:

mock data only
identity verification before result disclosure
minimum necessary spoken result summary
no lab values in SMS
recording disabled
assistant data retention disabled
no diagnosis or treatment advice

For production, pair these controls with the required BAA, role-based access controls, storage controls, audit logs, retention settings, monitoring, and legal/compliance review.

That is the deployment posture this demo is built to show: Telnyx AI for a privacy-sensitive healthcare workflow, with PHI kept out of SMS and result access routed through a secure portal.

Run It Locally

git clone https://github.com/team-telnyx/telnyx-code-examples.git
cd telnyx-code-examples/ai-lab-results-notification-voice-python
python3 -m venv .venv
source .venv/bin/activate
pip install -r requirements.txt
cp .env.example .env

Set:

TELNYX_API_KEY=KEY...
TELNYX_PHONE_NUMBER=+18005551234

Start the dashboard:

python app.py

Provision the assistant:

python provision_assistant.py

Then assign a Telnyx number directly to the assistant in the Portal and call it.

For the happy path, use:

name: maya rivera
date of birth: november 22 1984

Then ask for the secure portal link by text.

Production Notes

For a production version, I would move patient verification and result lookup out of the prompt and into a backend connected to the real patient portal or EHR workflow.

I would also keep the assistant prompt conservative:

verify identity
disclose minimum necessary
do not diagnose
do not interpret beyond provider note
do not put lab values in sms
route clinical questions to staff

That is the shape I like for this kind of workflow. AI handles a narrow phone interaction, while the secure patient portal remains the place where patients access the full report.

Resources

Code example: https://github.com/team-telnyx/telnyx-code-examples/tree/main/ai-lab-results-notification-voice-python
Telnyx AI Assistant quickstart: https://developers.telnyx.com/docs/inference/ai-assistants/no-code-voice-assistant
AI Assistant interruption settings: https://developers.telnyx.com/docs/inference/ai-assistants/interruption-settings
Architecting for HIPAA on Telnyx: https://telnyx.com/resources/architecting-hipaa-telnyx
Telnyx Developer Docs: https://developers.telnyx.com

I Built a Voice AI Payment Collection Demo That Keeps Card Details Out of the Assistant

anusha — Wed, 29 Jul 2026 23:55:26 +0000

Voice AI payment collection is tricky because the most impressive part of the demo is also the part you should not let the model handle.

An assistant can verify a caller, explain an account balance, answer billing questions, and negotiate a payment plan. But once the caller is ready to enter card details, the assistant should step aside.

I built a Telnyx code example that does exactly that.

The code example:
https://github.com/team-telnyx/telnyx-code-examples/tree/main/ai-pci-protected-payment-collection-python

The Flow

A caller dials a Telnyx number for a billing line. Telnyx sends the inbound call event to a Flask webhook. The app answers with Voice API and starts a Telnyx AI Assistant.

The assistant explains what the line can do: account status, billing questions, payment plans, and secure keypad payment collection. Then it verifies the caller by full name and date of birth.

After verification, the assistant can disclose the account balance and help the caller choose a payment plan. If the caller agrees to pay, the assistant calls a backend webhook tool called start_secure_payment.

That tool starts Telnyx Pay over Voice. From that point on, the caller enters card details with the phone keypad. The assistant does not ask for the numbers, does not hear the numbers, and does not receive the keypad digits.

Why This Pattern Matters

The pattern is simple:

AI handles the conversation
Pay over Voice handles card entry
The app records only sanitized payment status

That split is the point of the sample.

If you let a general voice agent collect card numbers, you immediately create a logging, recording, transcript, and storage problem. Even if the assistant is "just helping," the raw payment data can end up in places it does not belong.

Pay over Voice moves that sensitive step into a purpose-built IVR flow. Telnyx prompts for card number, expiration date, billing ZIP, and security code. The caller enters those values by keypad, and Telnyx sends payment progress/completion events back to the app.

The local dashboard in the sample is intentionally boring in the right way. It shows high-level proof that the secure payment flow started and completed. It does not show raw PAN, CVV, expiration date, billing ZIP, or raw DTMF.

What The Demo Shows

The sample includes:

Flask webhook handling for inbound Voice API events
AI Assistant startup with ai_assistant_start
Assistant webhook tools
Pay Connector provisioning
Pay over Voice start command
Mock payment processor endpoint
Sanitized event dashboard
Test-mode payment flow

The demo customer is Jordan Lee, with a past-due balance of $342.50. A good demo path is:

caller: jordan lee
caller: march fifteenth nineteen ninety
caller: can i do forty dollars a week?
caller: yes, start the secure payment

Then Pay over Voice takes over. For test mode, enter:

4111111111111111
0827
94111
123

Run It Locally

git clone https://github.com/team-telnyx/telnyx-code-examples.git
cd telnyx-code-examples/ai-pci-protected-payment-collection-python
cp .env.example .env
python3 -m venv .venv
source .venv/bin/activate
pip install -r requirements.txt
ngrok http 5000

Set your public URL and API key in .env, then provision the assistant:

python provision_assistant.py
python app.py

Point your Voice API application webhook to:

https://<ngrok-id>.ngrok-free.app/webhooks/voice

Call your Telnyx number and walk through the billing flow.

Where To Take It Next

For a production implementation, replace the mock payment processor with your actual processor, review PCI scope with your compliance team, verify webhook signatures, and store only the sanitized payment outcome your business process needs.

The assistant should keep the same boundary: explain, verify, plan, and hand off. It should never ask for card details out loud.

Resources

Code: https://github.com/team-telnyx/telnyx-code-examples/tree/main/ai-pci-protected-payment-collection-python
Pay over Voice: https://developers.telnyx.com/docs/voice/programmable-voice/pay
Voice API commands: https://developers.telnyx.com/docs/voice/programmable-voice/voice-api-commands-and-resources
Start AI Assistant: https://developers.telnyx.com/api-reference/call-commands/start-ai-assistant
Telnyx Portal: https://portal.telnyx.com

I Built a Voice AI Agent for Pre-Visit Insurance Clearance

anusha — Wed, 22 Jul 2026 22:51:50 +0000

Pre-visit insurance clearance is one of those workflows that sounds simple until you see how many phone calls it creates.

A patient calls before an appointment. They need to know whether a procedure, test, or medication requires prior authorization. Staff need to identify the patient, understand what they are asking for, collect payer and provider context, decide how urgent it is, and route the request to the right billing queue.

I built a Telnyx code example that turns that call into a structured intake ticket.

The code example:
https://github.com/team-telnyx/telnyx-code-examples/tree/main/ai-pre-visit-clearance-voice-agent-python

The Flow

A patient calls a Telnyx number. Telnyx sends the inbound call event to a Flask webhook. The app answers with Call Control, then starts gather_using_ai to collect the patient's spoken pre-clearance request as structured fields.

When Telnyx finishes collecting those fields, the app receives call.ai_gather.ended. From there, the app classifies the request with AI Inference, confirms the details with the patient, creates a staff-facing ticket, sends the patient an SMS confirmation, and optionally alerts billing staff in Slack.

The agent is non-clinical. It doesn't give medical advice, approve or deny coverage, or diagnose. It collects administrative data and routes it — which is the bottleneck in a lot of healthcare revenue-cycle work.

Why This Pattern Matters

The main Telnyx primitive here is Gather Using AI.

The app asks Telnyx to gather the fields it needs directly inside the call. The webhook response gives the backend something structured enough to use in a workflow.

That makes the rest of the app cleaner:

Call Control handles the inbound call lifecycle
Gather Using AI collects the spoken intake details
call.ai_gather.ended advances the workflow
AI Inference classifies urgency and type
Messaging sends the patient a confirmation
Slack gives billing staff a queue signal

The implementation patterns it covers:

DOB fallback when caller ID is unknown
command_id on Call Control commands
send_silence_when_idle when answering
structured JSON classification for procedure, urgency, and request type
keyword-based urgency override for phrases like "ASAP" or "can't wait"
confirmation before ticket creation
partial ticket creation if the caller hangs up after providing useful context

Run It Locally

git clone https://github.com/team-telnyx/telnyx-code-examples.git
cd telnyx-code-examples/ai-pre-visit-clearance-voice-agent-python
cp .env.example .env
pip install -r requirements.txt
python app.py
ngrok http 5000

Point your Telnyx Call Control Application webhook to:

https://<your-ngrok-domain>/webhooks/voice

Seed a patient:

curl -X POST http://localhost:5000/patients \
  -H "Content-Type: application/json" \
  -d '{"patient_id":"P001","name":"Jordan Lee","phone":"+15551112233","dob":"03/15/1990","insurance":"Blue Cross","provider":"Dr. Smith"}'

Call the number and say:

I need clearance for an MRI on my lower back.

The app collects the request, classifies it, confirms the details, creates a ticket, and sends an SMS confirmation.

Where To Take It Next

Replace in-memory storage with your EHR, PMS, or billing system integration. Wire ticket completion into real prior auth submission APIs. Add privacy review and HIPAA-ready operational controls before production use. Queue Slack and SMS side effects so webhook responses stay fast.

The key boundary should stay the same: the agent collects and routes. Staff and payer systems make the actual coverage decisions.

Resources

Code: https://github.com/team-telnyx/telnyx-code-examples/tree/main/ai-pre-visit-clearance-voice-agent-python
Gather Using AI: https://developers.telnyx.com/api-reference/call-commands/gather-using-ai
call.ai_gather.ended: https://developers.telnyx.com/api-reference/callbacks/call-ai-gather-ended
Voice API commands: https://developers.telnyx.com/docs/voice/programmable-voice/voice-api-commands-and-resources
AI Inference docs: https://developers.telnyx.com/docs/inference
Messaging docs: https://developers.telnyx.com/docs/messaging
Telnyx Portal: https://portal.telnyx.com

I Built a Voice AI Assistant for Prescription Refill Intake

anusha — Tue, 21 Jul 2026 23:35:10 +0000

Prescription refill calls are one of those workflows that sound simple until you look at the operational details.

The caller needs to explain which medication they are calling about. The pharmacy or clinic may need the preferred pharmacy, the callback number, how soon the refill is needed, and whether the request needs manual review.

But there is also a hard boundary: the AI should not approve a prescription, deny a refill, change dosage instructions, diagnose anything, or make clinical decisions.

So I built the workflow as an intake assistant, not a decision-maker.

The Telnyx code example is here:

https://github.com/team-telnyx/telnyx-code-examples/tree/main/ai-prescription-refill-intake-voice-assistant-python

It uses Telnyx AI Assistants with a small Python + Flask backend.

The Flow

The caller dials a Telnyx phone number. Telnyx sends a call.initiated webhook to the Flask app.

The app does two things:

Answers the call
Starts the configured Telnyx AI Assistant with ai_assistant_start

After that, the assistant owns the live conversation. It gives an emergency reminder, then asks one question at a time.

The assistant has three backend tools:

create_refill_request
flag_manual_review
queue_callback

When the assistant has enough information, it calls create_refill_request. If the request mentions a controlled substance, dosage change, side effects, urgent access issue, or similar follow-up trigger, it calls flag_manual_review. If the caller wants a callback, it calls queue_callback.

The Part I Care About

The AI is not the system of record.

The AI is not approving the refill.

The AI is collecting enough information for staff to do the next step.

That distinction matters a lot in healthcare voice AI. A useful assistant should reduce the intake burden without pretending to replace a pharmacist, clinician, or compliance process.

The backend is where the workflow is enforced. It stores the request, masks caller identifiers, checks the assistant tool secret, and exposes a review endpoint for staff.

Why Use Telnyx AI Assistants Here

You could build this as a manual voice state machine with gather and speak commands. That works, but the code gets focused on conversation plumbing.

With Telnyx AI Assistants, the shape is cleaner:

Call Control answers the phone
AI Assistant handles the conversation
assistant tools call the Flask backend
backend stores refill workflow state
staff reviews the request

The assistant prompt is also provisioned from code in provision_assistant.py, which means someone can recreate the assistant from the repo instead of manually copying settings from a portal screenshot.

Run It Locally

git clone https://github.com/team-telnyx/telnyx-code-examples.git
cd telnyx-code-examples/ai-prescription-refill-intake-voice-assistant-python
python3 -m venv .venv
source .venv/bin/activate
pip install -r requirements.txt
cp .env.example .env

Set the required environment variables:

TELNYX_API_KEY=KEY...
PUBLIC_BASE_URL=https://your-ngrok-url.ngrok-free.app
TOOL_SECRET=replace_with_a_random_shared_secret
TELNYX_PHONE_NUMBER=+18005551234
TELNYX_PUBLIC_KEY=your_telnyx_public_key_here

Start the app:

python app.py

Expose it:

ngrok http 5000

Provision the assistant:

python provision_assistant.py

Then set your Call Control Application webhook URL to:

https://<your-ngrok-domain>/webhooks/voice

Call the Telnyx number and ask for a prescription refill.

What To Watch In The Code

The main app is app.py.

The inbound webhook answers the call and starts the assistant:

requests.post(
    f"{TELNYX_API_BASE}/calls/{call_control_id}/actions/ai_assistant_start",
    headers=telnyx_headers(),
    json={"assistant_id": TELNYX_ASSISTANT_ID},
    timeout=10,
)

The assistant setup is in provision_assistant.py. That file creates or updates the assistant, sets the model, adds the prompt, configures dynamic variables, and registers the webhook tools.

The tool endpoints are intentionally narrow. They accept structured data and return workflow state. That makes the assistant useful without letting it become the approval layer.

Production Notes

The sample keeps state in memory because it is designed to be easy to run locally.

For production, I would add encrypted database storage, staff authentication, audit logging, retention policies, monitoring, stricter PHI controls, and a full compliance review.

I would also keep the assistant instructions conservative:

collect intake
route to staff
do not approve or deny
do not change medication instructions
do not diagnose
send emergency callers to 9-1-1

That is the useful shape for this kind of healthcare AI workflow.

Resources

Code example: https://github.com/team-telnyx/telnyx-code-examples/tree/main/ai-prescription-refill-intake-voice-assistant-python
Telnyx AI Assistant quickstart: https://developers.telnyx.com/docs/inference/ai-assistants/no-code-voice-assistant
Attach an AI Assistant to a Call: https://developers.telnyx.com/docs/voice/programmable-voice/ai-assistant-start
AI Assistant dynamic variables: https://developers.telnyx.com/docs/inference/ai-assistants/dynamic-variables
Telnyx Developer Docs: https://developers.telnyx.com

I Built a Voice AI Assistant That Can Bring a Human Into the Same Call

anusha — Tue, 21 Jul 2026 18:56:45 +0000

Most voice AI demos stop at the assistant. A caller talks to an AI, the AI answers, maybe it creates a ticket, and the call ends.

But a lot of real workflows need a human in the loop. A support assistant might need an integrations engineer. A healthcare assistant might need a care team member. A financial services assistant might need a licensed advisor. A sales assistant might need the right account executive.

The interesting part is doing that without making the caller hang up, call a different number, or repeat the same context to another person.

The Telnyx code example is here:

https://github.com/team-telnyx/telnyx-code-examples/tree/main/ai-assistant-multiparticipant-calling-nodejs

It shows a Node.js + Express backend that lets a Telnyx AI Assistant add another participant to the same live AI conversation.

The Flow

The caller dials a Telnyx number. Telnyx sends a call.initiated webhook to the app. The app answers the call with an inline AI Assistant configuration.

The assistant has a few tools:

classify_issue
record_specialist_consent
dial_specialist

The first two are there so the assistant does not immediately dial someone. It should understand the issue and ask permission before adding another participant.

The third tool is the bridge to the backend. When the assistant calls dial_specialist, the backend creates a second call leg with POST /v2/calls.

Then, when the specialist answers, Telnyx sends a call.answered webhook for that second leg. At that point, the backend calls ai_assistant_join and passes two important values:

the existing AI conversation_id
the specialist's call_control_id

That is the moment the call becomes multiparticipant.

The Part I Care About

The AI is not just transferring the caller. It is coordinating the call.

The caller stays in the original conversation. The assistant already has the issue context. When the specialist joins, the assistant can summarize what is happening and then get out of the way unless it needs to clarify, create a ticket, or close the loop.

That makes the experience feel much closer to a real support handoff:

caller: I am seeing webhook delivery failures
ai: I can bring in an integrations specialist on this same call. Does that work?
caller: yes
backend: dials specialist
specialist: hi, this is Anusha from integrations
ai: Anusha, the caller is seeing intermittent 401 responses on webhook deliveries...

Why Use a Backend Tool Instead of Only Portal Setup?

The Telnyx Portal supports assistant tools, and the docs cover multi-participant calls. This example focuses on the backend-driven version because developers often need control over:

which participant to dial
when consent was recorded
how the second call leg is tracked
what metadata is stored
what happens if the participant does not answer
how the handoff is audited

The backend tool makes that logic explicit.

Run It Locally

git clone https://github.com/team-telnyx/telnyx-code-examples.git
cd telnyx-code-examples/ai-assistant-multiparticipant-calling-nodejs
cp .env.example .env
npm install
npm test
npm start

Expose it:

ngrok http 8787

Point your Programmable Voice / Voice API application webhook to:

https://<your-ngrok-domain>/webhooks/voice

Then call your Telnyx number and ask for a support case that needs a specialist.

What To Watch In The Code

The main file is server.js.

The assistant instructions and tool definitions are inline, so someone can recreate the demo from the folder without copying a prebuilt Portal assistant. The dial_specialist endpoint handles the tool call. The call.answered handler joins the specialist into the conversation.

The key call is:

await fetch(`https://api.telnyx.com/v2/calls/${id}/actions/ai_assistant_join`, {
  method: "POST",
  headers: telnyxHeaders(),
  body: JSON.stringify({
    conversation_id: session.conversationId,
    participant: {
      id: specialistCallControlId,
      role: "user",
      name: "support specialist",
      on_hangup: "continue_conversation",
    },
  }),
});

That is the handoff.

Production Notes

The code sample keeps state in memory because it is meant to be easy to run. For production, I would store session state in Redis or Postgres, verify webhook signatures, add retries around outbound dialing, log consent, and add assistant behavior for when humans are talking directly to each other.

The pattern is still the same:

AI handles the front door
AI calls a backend tool
backend dials the next participant
Telnyx joins them into the same AI conversation

Resources

Code example: https://github.com/team-telnyx/telnyx-code-examples/tree/main/ai-assistant-multiparticipant-calling-nodejs
Multi-participant calls docs: https://developers.telnyx.com/docs/inference/ai-assistants/multi-participant-calls
Join AI Assistant Conversation API: https://developers.telnyx.com/api-reference/call-commands/join-ai-assistant-conversation
Telnyx Developer Docs: https://developers.telnyx.com

I Built a One-Curl Audio Translator with Telnyx AI Inference

anusha — Tue, 14 Jul 2026 22:06:14 +0000

Localizing a podcast, translating a recorded meeting, or dubbing a lecture used to require three different services stitched together. The Telnyx AI Inference API exposes STT, chat completions, and TTS on the same private backbone, which means a single Flask app can run the whole pipeline.

The Telnyx code example is:

https://github.com/team-telnyx/telnyx-code-examples/tree/main/ai-content-translator-python

It is a Python Flask app you can clone and run in a few minutes. No phone number, no webhook tunnel, no background job runner.

The Flow

You POST an audio file plus a target language. The app calls Telnyx STT to transcribe the audio in the source language, calls AI Inference to translate the transcript with a TTS-friendly system prompt, and calls Telnyx TTS to render the translated text into audio. Long transcripts are chunked at sentence boundaries so the TTS model never gets an input larger than it supports, and the chunks are concatenated into one mp3.

The response includes the job id, both transcripts, and a URL you can curl to download the dubbed audio.

Why I Like This Example

It is small enough to demo live, but it covers the parts that often get cut from an audio translation demo:

File upload with multipart form data and a writable temp file
Three Telnyx AI endpoints chained together with per-stage error handling
Long-transcript chunking at sentence boundaries
Response shape handling for TTS endpoints that can return raw audio, JSON with base64, or JSON with a fetch URL
Temp file cleanup so the upload does not leak disk space
Auto language detection (or pinned language) depending on whether you trust STT's detection

The design choice I care most about is per-stage error handling. If the TTS call fails on chunk 3 of 8, the app returns 200 partial with the transcripts still intact, rather than throwing away the STT and translation work.

Run It Locally

git clone https://github.com/team-telnyx/telnyx-code-examples.git
cd telnyx-code-examples/ai-content-translator-python
cp .env.example .env
pip install -r requirements.txt
python app.py

Translate a Spanish clip into English:

curl -X POST http://localhost:5000/translate \
  -F audio=@spanish-sample.mp3 \
  -F source=es \
  -F target=en

Download the dubbed audio:

curl -OJ http://localhost:5000/translate/<job_id>/audio

Read the full transcripts:

curl http://localhost:5000/translate/<job_id> | python3 -m json.tool

What To Demo

I would keep the demo short:

Show the /languages endpoint to call out the supported set.
POST a Spanish audio file with target=en and walk through the response shape (job_id, transcript previews, audio_url).
Play the downloaded dubbed mp3.
Show GET /translate/<job_id> for the full transcripts.
(Optional) POST with source=auto to show language detection.

That gives viewers the full loop without getting lost in implementation details.

Where To Take It Next

The demo keeps translation jobs in memory for one hour. Production would replace the in-memory jobs dict with object storage (S3, GCS) for the audio blobs and a database (Postgres) for the metadata, run STT / translate / TTS in a queue, return 202 Accepted for long jobs, add API key auth, and cap upload size and audio length up front.

Resources

Code example: https://github.com/team-telnyx/telnyx-code-examples/tree/main/ai-content-translator-python
Telnyx AI Inference docs: https://developers.telnyx.com/docs/inference
Telnyx Developer Docs: https://developers.telnyx.com
Telnyx Portal: https://portal.telnyx.com

I Built an AI Subscription Cancel-Save Agent That Does Not Manipulate You

anusha — Tue, 14 Jul 2026 22:03:54 +0000

Cancel-save flows are easy to over-engineer into manipulative dark patterns, and easy to under-engineer into "your subscription has been cancelled, goodbye" experiences that lose revenue. A good cancel-save agent does three things: classifies the reason, offers one relevant save option, and respects a direct cancellation request.

The Telnyx code example is:

https://github.com/team-telnyx/telnyx-code-examples/tree/main/ai-subscription-cancel-save-retention-agent-python

It is a Python Flask app that combines Telnyx Voice, AI Inference, and Messaging into a small demo you can clone and run in a few minutes.

The Flow

A customer calls in saying they want to cancel. The Flask app receives the webhook, verifies the customer by caller ID, and asks why they want to cancel. AI Inference returns the reason (too_expensive, not_using, missing_feature, support_issue, competitor_switch, temporary_pause, other) and the sentiment. Hardcoded urgent phrases (lawyer, sue, fraud, chargeback) and direct cancel phrases (cancel now, please cancel my subscription) short-circuit before any offer.

Otherwise, the agent offers one save option from the OFFER_POLICY mapping. A "yes" applies the save or pauses the subscription. A "no" or "cancel" ends the call with a graceful cancellation. An ambiguous yes/no gets exactly one clarifying prompt — the agent never loops.

The case is recorded with the outcome (saved, cancelled, paused, transferred, needs_followup), and the customer record is updated. Hangups before resolution are recorded as needs_followup so reps can call back.

Why I Like This Example

It is small enough to demo live, but it covers the parts that often get cut from a "Hello World" voice AI demo:

Single-prompt AI Inference classification that returns structured JSON
An offer policy that maps reason to one offer and one default outcome
Hardcoded overrides for urgent phrases and direct cancel so the agent does not rely on the LLM to get safety right
One clarifying prompt on ambiguous yes/no so the conversation does not loop
Idempotent webhook handling so retries do not double-log cases
Hangup tracking so open cases never disappear

The design choice I care most about is non-manipulation. The agent does not push back on a direct cancellation, and it offers one save option — not five — when the customer is open to one. That maps to how good customer-success teams actually operate.

Run It Locally

git clone https://github.com/team-telnyx/telnyx-code-examples.git
cd telnyx-code-examples/ai-subscription-cancel-save-retention-agent-python
cp .env.example .env
pip install -r requirements.txt
python app.py

Expose the webhook:

ngrok http 5000

In the Telnyx Portal, set the Voice API app webhook URL to https://<ngrok-id>.ngrok-free.app/webhooks/voice. Seed a customer with POST /customers, then call the Telnyx number from the customer's phone.

What To Demo

I would keep the demo short and show three flows back-to-back:

Customer says "I want to cancel, it's too expensive" then accepts the 25% off offer. Case ends saved, customer status active.
Customer says "I want to cancel, it's too expensive" then declines. Case ends cancelled, customer status cancelled.
Customer says "I want a lawyer this is fraud." Case ends transferred, call moves to the human escalation number.

That gives viewers the full loop without getting lost in implementation details.

Where To Take It Next

The demo uses in-memory state, which is fine for learning. Production would wire the customer and case stores into your billing system (Stripe, Recurly, Chargebee) so a saved outcome actually applies the discount and a paused outcome defers the next invoice. Add consent recording (record_channels: "dual") for compliance audits, and replace the caller-ID match with a one-time code flow for real verification.

Resources

Code example: https://github.com/team-telnyx/telnyx-code-examples/tree/main/ai-subscription-cancel-save-retention-agent-python
Telnyx Voice docs: https://developers.telnyx.com/docs/voice/call-control
Telnyx AI Inference docs: https://developers.telnyx.com/docs/inference
Telnyx Messaging docs: https://developers.telnyx.com/docs/messaging
Telnyx Portal: https://portal.telnyx.com

I Built a Hotel Concierge Line with Telnyx Voice, SMS, and Slack

anusha — Tue, 14 Jul 2026 21:45:33 +0000

Hotel guests do not care whether the front desk is staffed. They want to text or call one number and have their room service, housekeeping, concierge, or maintenance request handled. A concierge line is a good test case for voice AI because the workflow is familiar and the volume is real.

The Telnyx code example is:

https://github.com/team-telnyx/telnyx-code-examples/tree/main/hotel-guest-services-python

It is a Python Flask app that combines Telnyx Voice, AI Inference, Messaging, and Slack into a small demo you can clone and run in a few minutes.

The Flow

A guest calls or texts the Telnyx number. The Flask app receives the webhook, looks up the room by caller ID, and either greets the guest by name or asks for the room number. Each request is sent to Telnyx AI Inference, which classifies it into room_service, housekeeping, concierge, or maintenance. Urgent phrases (fire, flood, leak, locked out, gas, medical) override the LLM and route the request as urgent.

The request is appended to a log, the guest gets an SMS confirmation, and staff get a Slack alert with the right emoji for the department. When staff mark the request complete, the guest gets another SMS.

Why I Like This Example

It is small enough to demo live, but it covers the parts that often get cut from a "Hello World" voice AI demo:

Caller-ID-based room lookup, with a regex-based fallback for unknown callers
A constrained JSON system prompt so the LLM returns structured output you can trust
An urgent-phrase override that does not depend on the LLM getting it right
Slack alerts that match the department
Idempotent webhook handling so retries do not double-log requests

That makes it useful as a starting template for any single-vertical phone service where one phone number handles a small set of structured requests.

Run It Locally

git clone https://github.com/team-telnyx/telnyx-code-examples.git
cd telnyx-code-examples/hotel-guest-services-python
cp .env.example .env
pip install -r requirements.txt
python app.py

Expose the webhook:

ngrok http 5000

In the Telnyx Portal, set the Voice API app webhook URL to https://<ngrok-id>.ngrok-free.app/webhooks/voice and the Messaging Profile inbound webhook URL to https://<ngrok-id>.ngrok-free.app/webhooks/sms. Call or text the Telnyx number to test.

What To Demo

I would keep the demo short:

Call from a phone matching room 205. Say "Can I order a club sandwich and a sparkling water please?"
Show the open request in curl http://localhost:5000/requests.
Show the Slack alert in the staff channel.
Mark it complete with curl -X POST http://localhost:5000/requests/0/complete.
Show the fulfilment SMS on the guest phone.

Then call from an unknown number, say "Room 205 please", and make a second request to show the unknown-caller path.

Where To Take It Next

The demo uses in-memory state, which is fine for learning. Production would replace ROOMS and service_requests with your PMS database (Opera, Mews, Cloudbeds), persist call state and event IDs to Redis, queue Slack and SMS side effects, add call recording for QA, and map urgent requests to a real paging system instead of Slack.

Resources

Code example: https://github.com/team-telnyx/telnyx-code-examples/tree/main/hotel-guest-services-python
Telnyx Voice docs: https://developers.telnyx.com/docs/voice/call-control
Telnyx AI Inference docs: https://developers.telnyx.com/docs/inference
Telnyx Messaging docs: https://developers.telnyx.com/docs/messaging
Telnyx Portal: https://portal.telnyx.com

DEV Community: anusha

I Built a Voice Agent That Switches Languages Mid-Call on Telnyx

The Flow

How Code-Switching Works

Why This Is Different From Translation

Key Technical Decisions

deepgram/nova-3 with language: "auto"

voice ultra katie in the instructions

moonshotai/Kimi-K2.6

The Flask App Is Minimal

Run It

Related Examples

I Built a Language Tutor That Listens and Scores Your Pronunciation

The Loop

Why This Is Different From a Translator

The Voices

How the Scoring Works

The Decks

Run It

One Thing to Watch

Related Examples

I Wanted to Hear Every Telnyx Voice in One Scene, So I Built a Multi-Character Narrator

The Use Case

The Eight Curated Ultra Voices

Twenty Ultra SSML Emotions

How It Was Made

The pipeline

Why REST, not WebSocket

Why UUIDs, not display names

Parallel fan-out with per-line error isolation

The browser UI

Run It

Where This Goes Next

I Built a Website Voice Assistant That Can Actually Control the Page

The Idea

What I Built

Why Client-Side Instead of Webhook?

The Integration

The Demo Moment

Security Boundary

Resources

I Built a Voice AI Assistant for Lab Results Notifications

The Flow

The Part I Care About

Why Use Telnyx AI Assistants Here

The Dashboard

HIPAA Compliance Safeguards

Run It Locally

Production Notes

Resources

I Built a Voice AI Payment Collection Demo That Keeps Card Details Out of the Assistant

The Flow

Why This Pattern Matters

What The Demo Shows

Run It Locally

Where To Take It Next

Resources

I Built a Voice AI Agent for Pre-Visit Insurance Clearance

The Flow

Why This Pattern Matters

Run It Locally

Where To Take It Next

Resources

I Built a Voice AI Assistant for Prescription Refill Intake

The Flow

The Part I Care About

Why Use Telnyx AI Assistants Here

Run It Locally

What To Watch In The Code

Production Notes

Resources

I Built a Voice AI Assistant That Can Bring a Human Into the Same Call

The Flow

The Part I Care About

Why Use a Backend Tool Instead of Only Portal Setup?

Run It Locally

What To Watch In The Code

Production Notes

Resources

I Built a One-Curl Audio Translator with Telnyx AI Inference

`deepgram/nova-3` with `language: "auto"`

`voice ultra katie` in the instructions

`moonshotai/Kimi-K2.6`