DEV Community: anusha

I Ran LangGraph Inside a Telnyx Edge Actor with No API Key

anusha — Thu, 13 Aug 2026 18:35:52 +0000

I wanted to see if LangGraph could run inside a real edge compute actor — not a notebook, not a local REPL, but actual edge infrastructure with durable state, retry semantics, and a 30-second inbound budget.

And I wanted to do it without managing an API key inside the function.

The Telnyx code example is here:

https://github.com/team-telnyx/telnyx-code-examples/tree/main/langgraph-agent-on-edge

The result is an SMS support agent that runs a 3-node LangGraph graph (intent → action → response) inside a Telnyx Edge Compute actor, with LLM inference through a pre-authenticated binding. No API key in code. No API key in the bundle. No API key in the logs.

The Problem with Frameworks on Edge

Most agent framework examples assume you have a long-running process with environment variables and a stable network. You import the framework, pass it your API key, and it makes HTTP calls to your LLM provider.

Edge functions flip that. You have a short-lived runtime, a 30-second inbound budget, and — on Telnyx — a pre-authenticated API binding that eliminates the need for keys entirely.

The challenge is that frameworks like LangGraph call the LLM through their own HTTP client. The stock ChatOpenAI from LangChain takes an apiKey and a baseURL. If you use it inside a Telnyx Edge function, you are managing a key that the binding was designed to make unnecessary.

The Adapter

I wrote a small adapter called TelnyxBoundChatModel. It extends LangChain's SimpleChatModel and calls the Telnyx binding instead of making its own HTTP calls:

class TelnyxBoundChatModel extends SimpleChatModel {
  async _call(messages: BaseMessage[]): Promise<string> {
    const mapped = messages.map(m => ({
      role: roleForMessage(m),
      content: contentToString(m.content),
    }));
    const res = await this.env.TELNYX.ai.openai.chat.createCompletion({
      model: this.model,
      messages: mapped,
    });
    return res.choices[0].message.content;
  }
}

That is about 70 lines of code. It maps LangChain messages to the format the binding expects, calls createCompletion, and returns the content. No key. No baseURL. No secret to rotate.

LangGraph does not know or care that the model is the binding. It just sees a SimpleChatModel that returns strings. The graph runs the same way it would with ChatOpenAI.

The Graph

Three nodes:

intent   → LLM classifies the message as "order" or "smalltalk"
action   → plain TypeScript looks up the order
response → LLM composes a reply

If the intent is order, the graph runs the action node before the response node. If the intent is smalltalk, it skips action and goes straight to response.

The whole thing is about 80 lines of graph code. It is not a ReAct agent with tool calling. It is an explicit, typed graph — the kind of thing you would build if you wanted to control the flow rather than let the model decide.

The State Problem

Here is where it gets interesting.

LangGraph has its own state — the channels that flow between nodes. The Agent SDK has durable state — setState and getState that survive restarts. And the Agent SDK has message history — this.messages, which is the conversation log.

These are three different things. The sample teaches the distinction deliberately:

Graph state (intentLabel, actionResult, replyText) is ephemeral. It lives and dies inside one process() run.
Durable state (turn, queuedTurn, lastSentTurn) survives restarts. It is for turn tracking and idempotency.
Message history (this.messages) is the memory. It is the conversation.

If you conflate them, you end up with bugs. For example, if you put the graph's intentLabel into durable state, it persists across turns and the next message gets the wrong intent. If you put the conversation into graph state, it resets on every process() run and the agent has no memory.

The Turn State Machine

Edge actors deliver messages at-least-once. A crash after a successful SMS send can retry the entire process() method. Without protection, that means duplicate replies.

The sample uses a per-turn state machine:

receive() → bump turn, set queuedTurn, queue("process")
process() → if queuedTurn <= lastSentTurn: return (stale)
             → run graph
             → stage pendingOutbound
             → send SMS
             → commit lastSentTurn

If two messages arrive before the first process() runs, the second bumps queuedTurn. The first process() handles the latest turn. The stale second process() sees queuedTurn <= lastSentTurn and returns immediately. One reply, not two.

The guard is on turn, not reply text. So identical replies across different turns are never suppressed.

The 30-Second Budget

The inbound method runs under a 30-second wall-clock budget. That is fine for acking a webhook, but not for an LLM round-trip plus tool calls.

So the inbound method does zero model I/O. It adds the user message to history, bumps the turn counter, and queues a background task. The webhook acks immediately.

The queued process() task runs in the actor's alarm handler, which has a budget on the order of minutes. That is where the graph runs, the LLM is called, and the SMS is sent. If it throws, the scheduler retries with backoff.

What I Learned

LangGraph runs fine inside an edge actor. You just need to give it a chat model that calls the binding instead of an HTTP endpoint.
The binding is the whole point. Once you have the adapter, the rest of the code has no keys, no secrets, and no authentication logic. The platform handles it.
State layers matter. Graph state, durable state, and message history are three different things. The sample makes that explicit because it is the most common mistake.
At-least-once delivery is real. If you do not guard outbound side effects, you will send duplicate SMS replies under retry. The turn state machine is the answer.
The 30-second budget is real. If you call the LLM inside the inbound method, you will time out. Defer to a queued task.

Run It

git clone https://github.com/team-telnyx/telnyx-code-examples.git
cd telnyx-code-examples/langgraph-agent-on-edge
npm install

Fetch the public key and store it as a secret:

PUBLIC_KEY=$(curl -s -H "Authorization: Bearer $TELNYX_API_KEY" \
  https://api.telnyx.com/v2/public_key | jq -r '.data.public')
telnyx-edge secrets add TELNYX_PUBLIC_KEY "$PUBLIC_KEY"

Deploy:

npm run typecheck
npm run types
npm run ship

Send an SMS with "where is my order ORD-10042?" and get a reply. Visit the function URL for a demo UI that shows the conversation, the turn state counters, and the process log.

The code example is here:

https://github.com/team-telnyx/telnyx-code-examples/tree/main/langgraph-agent-on-edge

I Built an Agent That Can Decide When to Text You or Call You

anusha — Thu, 13 Aug 2026 00:48:27 +0000

I wanted a simple way to show what LLM tool calling looks like when the tools are real communication actions.

Not a weather lookup. Not a calculator.

Something you can feel immediately from your phone.

The Telnyx code example is here:

https://github.com/team-telnyx/telnyx-code-examples/tree/main/agent-with-tool-calling

The result is an agent that can read a normal message like:

Text +13125550001 I am running five minutes late

and decide to call the SMS tool.

Or:

Call me at +13125550001

and decide to call the voice tool.

The Idea

Most demos make the user choose the action first.

Click this button to send a text. Click that button to place a call. Pick a workflow. Fill in a form.

This sample flips that around.

The user writes what they want. The model reads the request, chooses one of the allowed tools, extracts the phone number and message body, and the application executes the action through Telnyx.

The approved tools are:

send_sms
make_call
check_status

The model does not get to run arbitrary code. It gets a small, explicit set of tools with JSON schemas.

The Full Loop

The important part is that tool calling is a loop, not a single model response.

The flow is:

user message
  -> model receives tool definitions
  -> model returns a tool call
  -> app executes the selected tool
  -> app appends the tool result with the same toolCallId
  -> model sees the tool result
  -> model writes the final response

That last model pass matters. The tool result is structured data. The final assistant response is the human-readable summary.

So if the model chooses send_sms, the app sends the SMS first. Then the model gets the result and can say what happened in a clean sentence.

Why I Like This Example

It makes tool calling concrete.

You can inspect the code and see the exact line where Telnyx Inference is called:

this.env.TELNYX.ai.openai.chat.createCompletion()

You can inspect the SMS dispatch:

this.env.TELNYX.messages.send()

You can inspect the voice dispatch:

this.env.TELNYX.calls.dial()

And you can inspect the ledger that records each tool call and its toolCallId.

That makes the demo much easier to trust. If something happens, you can trace it.

What The Agent Remembers

The sample runs on Telnyx Edge Compute with the Agent SDK.

The ToolAgent keeps conversation history and records tool activity. That means a user can ask a follow-up like:

Did the SMS send?

The model can choose check_status, and the app can look up the latest send_sms event in the local ledger.

That is a useful pattern for real workflows. Users ask follow-up questions. They do not always phrase the second message with all the context from the first one.

The Phone Is The Interface

The fun part of this sample is that the phone becomes the proof.

When the agent sends an SMS, the recipient sees the message.

When the agent places a call, the phone rings.

That makes it different from a lot of LLM demos. You are not just watching a terminal print JSON. You are watching a model choose an action that reaches a real person through a real communications channel.

Running It

Start with the code sample:

git clone https://github.com/team-telnyx/telnyx-code-examples.git
cd telnyx-code-examples/agent-with-tool-calling
npm install

Run:

npm run typecheck
npm run types
npm run ship

Then configure your Telnyx number, Messaging Profile webhook, Call Control application, and Edge function settings.

Try:

Text +13125550001 meet me at the front desk
Call me at +13125550001
Did the SMS send?

The Pattern To Reuse

This is the shape I would reuse for a lot of communication workflows:

let the LLM classify intent
keep the tool surface small
validate phone numbers before dispatch
execute tools exactly once
store a ledger
pass the tool result back to the model
return a short final answer

That gives you the flexibility of natural language with the control of normal application code.

Resources

Code example: https://github.com/team-telnyx/telnyx-code-examples/tree/main/agent-with-tool-calling

Building an SMS Sentiment Escalation Agent on Telnyx Edge Compute

anusha — Thu, 13 Aug 2026 00:12:07 +0000

I wanted this demo to show a realistic support workflow: a customer texts in, an agent reads the tone of the message, and a human gets pulled in when the conversation is clearly going badly.

The sample puts the full messaging flow on Telnyx Edge Compute:

The request hits a deployed Telnyx Edge function.
SentimentAgent handles the message with the Agent SDK.
Telnyx AI Inference classifies the sentiment.
Actor-local SQL stores the message, score, reply, and escalation state.
Negative messages send an SMS alert to the ops number.

Why Put This on the Edge?

Sentiment analysis is often treated like analytics: run a job later, summarize the inbox, and tell the team what happened.

That is useful, but it misses the moment where automation can actually help. If a customer says "this is broken and nobody is helping me, I want a refund," you want the system to know immediately. The reply should be empathetic, the log should be updated, and a person should be alerted before the thread gets worse.

Edge Compute is a good fit because the logic runs where the event arrives. The webhook does not need to bounce through a separate backend before the first decision is made.

The sample flow is:

Inbound SMS
  -> Telnyx Edge Compute
  -> Agent SDK actor
  -> Telnyx AI Inference
  -> SQL sentiment log
  -> auto-reply
  -> human escalation when negative

The Demo Experience

After deployment, you open the telnyxcompute.com URL and use the browser view to test the flow.

Send a positive message:

I love this app, just paid for a year

Send a neutral one:

What are your hours?

Then send a negative message:

this is broken and nobody is helping me, I want a refund

The log updates with the sentiment label and score. Negative sentiment gets marked for escalation, and the UI shows the empathetic response the agent generated.

The escalation path sends SMS alerts through Telnyx Messaging so a human can jump in quickly.

What I Like About This Pattern

This sample is small, but the architecture scales to more serious workflows:

Customer support escalation
Refund and cancellation saves
Abuse or safety triage
After-hours monitoring
Routing high-value accounts to a human faster

You can also swap the sentiment prompt for another classifier. The same shape works for urgency detection, topic routing, language detection, or structured intake.

The key idea is that the AI decision is not sitting off to the side. It is inside the communication path.

Try It

The sample lives in the Telnyx code examples repo:

https://github.com/team-telnyx/telnyx-code-examples/tree/main/sentiment-analysis-agent

Run the type checks, deploy with telnyx-edge ship, open the deployed URL, and reset the live log before recording if you want a clean demo.

Point your Telnyx Messaging webhook at /webhooks/messaging, send an inbound SMS, and watch the agent classify, log, reply, and escalate from the deployed Edge function.

I Built an SMS Quiz Agent That Remembers Each Turn

anusha — Thu, 13 Aug 2026 00:10:06 +0000

I wanted a simple way to show how Telnyx Edge Compute can support a conversation that lasts longer than one request.

An SMS quiz is a good example because the state is obvious.

If I text start, answer question one, then answer question two, the system has to remember where I am. It needs to know my score, the current question, the correct answer, and whether the next question should be easier or harder.

The Telnyx code example is here:

https://github.com/team-telnyx/telnyx-code-examples/tree/main/multi-turn-sms-quiz-agent

The end result is a quiz you can answer over SMS. Text start, reply with A, B, or C, and the quiz keeps going until the final score.

The Idea

The quiz teaches Edge Compute concepts through short multiple-choice questions.

Instead of asking questions in abstract terms, the prompt pushes the model to use concrete examples:

storage units
lockers
mail and delivery
keys
filing systems
rooms and spaces
saving and retrieving items

That makes concepts like durable state easier to picture.

For example, a StatefulActor can be explained like a storage unit for one sender. You leave the score and current question there, come back on the next SMS, and the data is still there.

What The Sample Does

The flow is:

text start
receive Q1
answer A, B, or C
receive feedback
receive Q2
repeat until Q5
receive final score

Behind that simple SMS flow, the sample uses:

Telnyx Edge Compute
the Agent SDK
one StatefulActor per sender
Telnyx Messaging
Telnyx Inference
actor-local SQL for event history and webhook idempotency

The code is Node.js and TypeScript.

Why The Actor Matters

SMS messages arrive as separate webhook events.

Without durable state, each message looks isolated. The system sees B, but it does not automatically know which question that answer belongs to.

The actor solves that.

The sample routes each sender phone number to a stable actor name. That actor stores:

phase
score
difficulty
turn number
current question
current answer
sender and recipient phone numbers

So when the user sends B, the actor can retrieve the current question and grade the answer in context.

How Difficulty Adapts

The quiz starts on easy.

If the user answers correctly, the code moves difficulty up:

easy -> medium -> hard

If the user answers incorrectly, the code moves difficulty down or keeps it easy.

The model helps generate and grade questions, but the adaptation rule is controlled by code. That keeps the quiz predictable.

The Question Style

The question prompt asks for one JSON object with the question, answer, and hint.

The question itself has three choices on separate lines:

Q2/5 (easy)
What is durable state most like?
A) A saved item in a locker you can open later
B) A message that disappears as soon as it is sent
C) A random address that changes every time

The incorrect answers are supposed to be plausible. That matters because the quiz should test understanding, not just make the right answer obvious.

Running It

Start with the code sample:

git clone https://github.com/team-telnyx/telnyx-code-examples.git
cd telnyx-code-examples/multi-turn-sms-quiz-agent
npm install

Then run:

npm run typecheck
npm run types
npm run ship

Set your Telnyx Messaging Profile webhook to the deployed function, then text start to your Telnyx number.

You need a Telnyx API key and an SMS-capable Telnyx number. The sample uses the Telnyx Edge binding in the function code, so API credentials are not hard-coded into the message handling logic.

Why I Like This Example

It is small, but it shows the core pieces of a stateful SMS agent:

route each user to their own durable state
acknowledge inbound webhooks quickly
do slower AI work in the actor queue
save enough state to continue on the next message
send the next SMS from the same workflow

That is the pattern I would reuse for many SMS experiences where the user needs to answer one step at a time.

Resources

Code example: https://github.com/team-telnyx/telnyx-code-examples/tree/main/multi-turn-sms-quiz-agent

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

DEV Community: anusha

I Ran LangGraph Inside a Telnyx Edge Actor with No API Key

The Problem with Frameworks on Edge

The Adapter

The Graph

The State Problem

The Turn State Machine

The 30-Second Budget

What I Learned

Run It

I Built an Agent That Can Decide When to Text You or Call You

The Idea

The Full Loop

Why I Like This Example

What The Agent Remembers

The Phone Is The Interface

Running It

The Pattern To Reuse

Resources

Building an SMS Sentiment Escalation Agent on Telnyx Edge Compute

Why Put This on the Edge?

The Demo Experience

What I Like About This Pattern

Try It

I Built an SMS Quiz Agent That Remembers Each Turn

The Idea

What The Sample Does

Why The Actor Matters

How Difficulty Adapts

The Question Style

Running It

Why I Like This Example

Resources

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

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

`voice ultra katie` in the instructions

`moonshotai/Kimi-K2.6`