Entry Points

The platform invokes the class at a few known points, and the class returns within a budget on each. The Agent class extends Edge Compute’s StatefulActor, and the platform calls it through the actor’s entries.

Entry point	Invoked by	Contract
`fetch(req)` on the function	Every request to the address	Answered by `mountAgents`, which resolves the instance and picks the transport. The Address and Transports has the three.
Any method marked `@rpc`	`POST …/rpc/<method>` on the conversation’s address, and the socket’s RPC frames	One call, JSON in and out, within the 30-second budget. Work that needs longer goes to a queued task.
A public method	A call through an `ActorStub`, from the function or from another instance	Actor RPC, under the dispatch rules of `StatefulActor`. `@rpc` does not apply to it.
`webSocket(ws, req)`	A WebSocket upgrade on the conversation’s address	The class owns the socket. The default runs the agent socket protocol, and the `voice()` mixin takes a call’s media stream. The mixin is the `@telnyx/edge-runtime/voice` export of The Agent Runtime SDK.
`onTask(name, payload, ctx)`	The task scheduler, when a due task names no method on the class	Delivered at least once, inside the alarm handler, with a budget on the order of minutes. A task that names a method on the class is delivered to that method. `queue()` creates a task.
`authorize(token, req)`	Every connection, once	Resolve the credential into claims. `authorize` is the reference, and Mounting Agents has both gates.
`onConnect(conn)`, `onAttach(att)`	A connection, as it is established and as it is admitted	Hooks.
`alarm(info)`	The platform’s alarm	Reserved by the SDK, which drives the task scheduler with it.

One instance runs one of these at a time, so a handler never interleaves with another on the same conversation. Execution Model has the rest of the rules. A webhook is a request to fetch like any other, and what the function does with it is the function’s own code.

Activation

The platform constructs the class on every activation. The constructor opens the instance’s stores and re-arms the task scheduler before the instance takes a call.

// agent/agent.ts
constructor(ctx, env, options = {}) {
  super(ctx, env);
  // …
  this._tasks = new TaskScheduler(ctx.storage, () => randomUUID());
  this._state = new StateStore(ctx.storage, () => this.initialState());
  ctx.blockConcurrencyWhile(async () => {
    await beginActivation(ctx.storage);
    await this._tasks.rearm(this.now());
  });
}

StatefulActor receives ctx and env through super(ctx, env). It keeps them as this.ctx and this.env.
ctx.storage backs the task scheduler and the state store. The message log and the event log are built on it too.
ctx.blockConcurrencyWhile runs the store setup and the re-arm. Every other call waits until both finish. The callback has a 30-second budget.

The Fetch Entry

The class does not override the actor’s fetch. It inherits the default.

// stateful-actor.ts
async fetch(_req) {
  return new Response("Not Found", { status: 404 });
}

fetch(req) receives every request to the instance that is not an upgrade. A class that serves the streams and RPC over HTTP overrides it and passes the request to an AgentHttpServer.

The WebSocket Entry

The class overrides the actor’s webSocket and hands each socket to its socket server.

// agent/agent.ts
webSocket(ws, req) {
  if (!this._overridesSeam("authorize") &&
    !this._overridesSeam("onAttach") &&
    !this._overridesSeam("webSocket")) {
    throw new AgentSocketsNotEnabledError();
  }
  return this._socketServer().attach(ws, req);
}

webSocket(ws, req) receives the accepted socket and the handshake request. A class that overrides none of the three seams throws before it touches the socket, so the socket is refused.

The Alarm Entry

The instance has one alarm. The task scheduler sets it through ctx.storage, to the earliest due task.

// agent/tasks.ts
async rearm(_now) {
  const due = await taskEarliestDue(this.storage);
  if (due === undefined) {
    await this.storage.deleteAlarm();
    return;
  }
  await this.storage.setAlarm(due);
}

ctx.storage.setAlarm receives the earliest due time, in milliseconds since the epoch. Setting it again replaces the previous time, so every task shares the one alarm.
ctx.storage.deleteAlarm clears the alarm when no task is pending.

When the alarm fires, the class’s alarm drains every due task and re-arms.

// agent/agent.ts
async alarm(_info) {
  const dispatch = (task) => this._dispatch(task);
  // …
  for (;;) {
    const now = this.now();
    const earliest = await taskEarliestDue(this.ctx.storage);
    if (earliest === undefined || earliest > now)
      break;
    // …
    await this._tasks.runDue(now, dispatch);
  }
  // …
  await this._tasks.rearm(this.now());
}

alarm(info) is the entry the platform calls when the alarm fires. Every task the drain dispatches runs inside it, under the alarm’s time budget.

Get Started

Inside the Managed Harness

The Agent Harness SDK

The Agent Runtime SDK

The Agent Client SDK

For AI Agents

Activation

The Fetch Entry

The WebSocket Entry

The Alarm Entry

​Activation

​The Fetch Entry

​The WebSocket Entry

​The Alarm Entry

Activation

The Fetch Entry

The WebSocket Entry

The Alarm Entry