The Voice Loop

support-agent/
├── agent.json
├── instructions.md
└── .telnyx/                        written by deploy
    ├── index.ts
    ├── telnyx.toml
    ├── telnyx-env.d.ts
    └── package.json

@telnyx/acp/                      the package
├── managed/
│   ├── index.ts
│   ├── agent.ts
│   ├── model.ts
│   ├── memory.ts
│   ├── tools.ts
│   ├── mcp.ts
│   ├── voice.ts                                       ◀
│   ├── direct-turn.ts                                 ◀
│   └── filler.ts                                      ◀
├── channels/
│   ├── index.ts
│   ├── phone.ts
│   ├── email.ts
│   ├── web.ts
│   └── wire.ts
├── synth/
│   ├── index.ts
│   ├── code-entry.ts
│   └── vendor.ts
└── spec/
    ├── schema.ts
    ├── model.ts
    ├── phone.ts
    ├── project.ts
    └── io.ts

A call does not pass through admit. The voice() mixin from @telnyx/edge-runtime/voice runs STT and TTS, takes each end of turn from STT, and asks the class for one thing per utterance, a turn engine. By default that is the direct engine in managed/direct-turn.ts. The turn goes straight to the model with the conversation held in memory, and the confirmed exchange is written behind the call. With voice.harness true the harness itself is the engine. Each turn then runs the harness’s model and tools as a direct turn, not as a persistent run, at the cost of a second or more before the first word. defineManagedVoiceAgent in managed/voice.ts wraps the managed class in the mixin:

// managed/voice.ts
export function defineManagedVoiceAgent(spec, host = {}) {
  const Base = defineManagedAgent(spec, host);
  class ManagedVoiceAgent extends voice(Base) {
    greeting(call) {
      this.nameCaller(call.from);   // the caller's number names their memory profile; the summary read starts here
      return defaultGreeting(spec);
    }
    // turnEngine, speechProviders, reply, turnEnded, callEnded, warmCall …
  }
  return ManagedVoiceAgent;
}

The mixin answers the call, runs barge-in and the keypad, and ends the call. The class overrides its hooks, and adds warmCall of its own.

warmCall runs before the call is answered, as The Call Webhook shows.
greeting is spoken when the call is answered. The mixin’s own says nothing.
turnEngine returns the engine above. The mixin’s own returns none.
speechProviders builds the STT and TTS providers from spec.voice.
reply wraps the mixin’s own reply in withFiller from managed/filler.ts. When the caller is confirmed done and voice.filler.afterMs pass without a word from the model, one short phrase is spoken as its own sentence, and the reply follows. The phrase is said, never written, so it reaches neither the message log nor the caller’s memory.
turnEnded logs the turn’s clock and writes the exchange to the message log after the reply has finished playing.
callEnded writes the last reply to state with setState() and, with memory on, pushes the call to Agent Memory under its id.

Each turn reaches the engine through reply:

// managed/voice.ts
reply(transcript, call) {
  const base = super.reply(transcript, call);
  if (!this.filler) return base;
  // …the same reply, wrapped in withFiller
}
// …
turnEngine() {
  const self = this;
  if (harnessOnCalls(spec)) return self.ready({ calls: true });
  return (this.direct ??= createDirectTurnEngine({
    model: voiceModel(spec, host, self.env),
    // …instructions, history and record
  }));
}

super.reply(transcript, call) is the mixin’s own reply, which hands the transcript to the engine that turnEngine() returns.

transcript is STT’s first pass at the caller’s words, and call.confirmed resolves to the confirmed words.
While the turn is speculative, the mixin calls the engine’s begin() with the first pass, then commits the confirmed words or discards the turn.
Otherwise it calls the engine’s turn() with the confirmed words, and the result’s text is spoken.
A reply the caller cuts short is still a turn. The direct engine remembers the caller’s words and what was said of the reply before the cut, with the note [cut off by the caller] after it, in its history and in the journal; once playback reports what the caller heard, the entry is corrected to that. The next turn’s context holds both, so an interrupted “Sure, what is the new…” and the caller’s “12 Main St” line up.

With voice.harness true the engine is ready({ calls: true }), the recovered harness for calls, and both calls are its own. That harness leaves out every tool marked ask, since a call cannot wait for an approval; without any ask it is the same instance texts use.

begin() streams provisional text, with no writes or tools until the turn is committed.
turn() runs the input to completion and records the turn in the message log.

By default the direct engine answers both calls itself, with the AI SDK’s streamText and no harness. Over the mount, the voice class is the managed class unchanged except for webSocket(), with the same six RPC methods. Extending the Managed Agent has the hooks’ signatures.

Get Started

Inside the Managed Harness

The Agent Harness SDK

The Agent Runtime SDK

The Agent Client SDK

For AI Agents

The Voice Loop