The Run

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

The run executes as a task on the instance. The harness’s tasks arrive at onTask in managed/agent.ts, which hands them to the harness:

// managed/agent.ts
async onTask(name, payload, info) {
  if (name === DELIVERY_TASK) { await this.retryDelivery(payload); return; }   // a reply's next try; see Delivery
  if (!name.startsWith(HARNESS_TASK_PREFIX)) { await super.onTask(name, payload, info); return; }
  const harness = await this.ready();
  const before = (await this.messages.last())?.seq ?? 0;   // runs are dispatched one at a time, so what the log gains is this run's
  this.modelError = undefined;
  const run = await harness.dispatch({ name, payload });
  await this.noteRun(run, before);
}

onTask(name, payload, info) overrides the runtime SDK’s onTask(), the fallback for a task whose name is not a method of the class.

The harness’s task names start with HARNESS_TASK_PREFIX, __telnyx_agent_harness_, and name no method of the class, so the tasks arrive here.
DELIVERY_TASK, __telnyx_acp_deliver, is the next try at a reply the channel refused; Delivery has the window.
Any other task goes to super.onTask, the runtime’s default, which treats it as delivered.

this.messages.last() is last() on the message log. Runs are dispatched one at a time, so every message past the seq it returns is this run’s. harness.dispatch({ name, payload }) is dispatch().

name and payload are the task as the harness queued it.
It executes the run’s turn and returns the run’s HarnessRun as the turn left it.

Inside dispatch, three things happen.

The model is called with the instructions and the conversation’s message log.
Tools run, subject to their approvals.
Each assistant message is appended to the log as it lands.

When dispatch returns, noteRun writes the outcome to state, through the runtime SDK:

// managed/agent.ts
async noteRun(run, before) {
  if (!run) return;
  const state = await this.getState();
  const last = await this.messages.last();
  const reply = last && last.seq > before && last.role === "assistant" && last.content.trim() !== "" ? last.content : undefined;
  // …
  const at = this.now();
  const patch = {};
  // …the outcome's fields, as in the table below
  if (Object.keys(patch).length) await this.setState(patch);
  // …delivery, then the memory push
}

getState() returns the runs already noted, so a redelivered task does not note a run twice.
last() returns the newest message. It is the reply only when its seq is past before, its role is assistant and it has text.
now() is the time a completed or failed outcome records as at.
setState() merges the patch. A null in it deletes a key, as it deletes awaitingApprovalRunId once that run ends.

The outcome decides the keys written.

Outcome	State
Completed with a reply	`lastReply`, `lastRunId`, and an entry in `pendingDeliveries` under the run id when the message came in through a channel
Completed with nothing to say	`lastRunId`, `failedRunId`, `lastError: "EMPTY_REPLY"`
Failed	`lastRunId`, `failedRunId`, `lastError` with the model’s own message when it threw
Paused on an `ask`	`awaitingApprovalRunId`

The state stream carries each of these, which is how invoke ends with a reply, or with a line that says why there is none. With memory on, a completed run’s exchange is pushed to Agent Memory under the run’s id. Delivery is the last step.

Get Started

Inside the Managed Harness

The Agent Harness SDK

The Agent Runtime SDK

The Agent Client SDK

For AI Agents