DEV Community

Sonam
Sonam

Posted on

Build an AI Meeting Facilitator on Telnyx Edge Compute

#telnyx #ai #voice #edge

Most meeting tools wait until the call is over.

They record, transcribe, summarize, and then hand you notes after the damage is already done.

That is useful, but it misses the live part of the meeting: who got interrupted, who has not spoken yet, and whether the group is actually making decisions.

The conference-agent-mediator example takes a different approach. It puts an AI participant directly into a Telnyx conference bridge.

Code: https://github.com/team-telnyx/telnyx-code-examples/tree/main/conference-agent-mediator

What it builds

This is a TypeScript app running on Telnyx Edge Compute with the Telnyx Agent SDK.

The agent:

  • joins a Telnyx conference as a participant
  • starts live transcription for each speaker
  • stores transcript turns in durable actor state
  • checks the conversation every 30 seconds
  • asks an LLM whether the room needs a facilitation nudge
  • speaks that nudge into the conference
  • summarizes the meeting when it ends
  • sends the summary by SMS
  • streams live state to observers over WebSocket

The result is a meeting facilitator that is not just a post-call summary bot. It is in the room while the conversation is happening.

The flow

At a high level:

Caller joins conference
  -> ConferenceAgent actor is created
  -> participant audio is transcribed
  -> transcript turns are stored
  -> mediation loop checks who has spoken
  -> AI generates a short facilitator prompt
  -> Telnyx speaks the prompt into the bridge
  -> meeting ends
  -> AI summary is generated
  -> SMS summary is sent
Enter fullscreen mode Exit fullscreen mode

The main idea is one actor per conference.

That actor owns the state for the meeting: participants, transcript, prompts, phase, and final summary.

Why actors fit this problem

A conference is stateful.

Events arrive over time:

  • a participant joins
  • transcription starts
  • a speaker says something
  • another speaker joins
  • the mediator decides whether to intervene
  • the conference ends

If this were split across a stateless webhook handler, a worker, a database, and a scheduler, you would spend a lot of time rebuilding context.

With the Agent SDK, the conference itself can become the unit of state.

The sample keeps the transcript and participant state on the ConferenceAgent, so every webhook and timer callback has the context it needs.

The mediation loop

The app uses a crash-safe timer that runs every 30 seconds.

Each pass checks whether the conference is live, looks at recent transcript turns, finds quiet participants, and asks Telnyx AI Inference for a short facilitator line.

The prompt is intentionally conservative. The agent should not constantly interrupt. It should only step in when there is a useful reason, like bringing a quiet person into the conversation or helping the group return to a decision.

Example mediator output:

Before we move on, I would like to hear from Dana, who has not had a chance to weigh in yet.
Enter fullscreen mode Exit fullscreen mode

In live mode, the agent speaks that line into the conference bridge.

API and runtime pieces

The example includes:

  • POST /webhooks/voice for Telnyx Call Control events
  • an Agent SDK actor for conference state
  • live transcription events from Telnyx
  • Telnyx AI Inference for mediation and summary generation
  • Telnyx Messaging for the post-call SMS summary
  • an observer socket for live transcript and state updates
  • demo mode so you can test the pipeline without real phone calls

The important part is that these are not stitched together across several vendors.

Voice, transcription, LLM inference, stateful agents, and SMS all sit behind the same Telnyx platform.

Running the example

Clone the repo:

git clone https://github.com/team-telnyx/telnyx-code-examples.git
cd telnyx-code-examples/conference-agent-mediator
npm install
Enter fullscreen mode Exit fullscreen mode

Set your runtime values with placeholders first:

telnyx-edge secrets add TELNYX_API_KEY <YOUR_TELNYX_API_KEY>
telnyx-edge secrets add SMS_FROM <YOUR_TELNYX_SMS_NUMBER>
telnyx-edge secrets add SMS_TO <SUMMARY_RECIPIENT_NUMBER>
Enter fullscreen mode Exit fullscreen mode

Deploy:

telnyx-edge ship
Enter fullscreen mode Exit fullscreen mode

Then point your Telnyx Call Control application webhook at:

https://conference-agent-mediator-<id>.telnyxcompute.com/webhooks/voice
Enter fullscreen mode Exit fullscreen mode

The sample also supports demo mode, which is useful when you want to exercise the actor, transcript, mediation, and summary flow before wiring up live calls.

What I like about this pattern

The interesting part is not only that AI can summarize a meeting.

The interesting part is that the agent can participate while the meeting is still happening.

Because the agent runs close to the communications path, it can react to the live transcript quickly enough for a mediation prompt to still feel relevant.

That opens up a broader pattern:

  • meeting facilitators
  • sales-call coaches
  • support-call supervisors
  • interview note takers
  • training assistants
  • live compliance monitors

Any workflow where the assistant needs to observe a conversation, keep state, and act during the call can use the same foundation.

Production notes

Before using this with real meetings, I would add:

  • authentication for observer sockets
  • participant consent flows
  • retention controls for transcripts
  • redaction for sensitive data
  • stronger speaker identity mapping
  • prompt tuning for different meeting cultures
  • monitoring for transcription, inference, and SMS delivery
  • explicit controls for when the agent is allowed to speak

The sample keeps the moving parts small on purpose, but the architecture is the useful thing: one durable agent owns one live conversation.

Resources:

Top comments (0)