AI Engineer World's Fair 2026

The Human Is an Async API — Melanie Warrick, Temporal

Loading slides…

Read the talk

The Human Is an Async API

Melanie Warrick’s ice cream delivery demo shows how Temporal lets an agent wait for a human without stopping unrelated work—and recover an approval even when its worker goes offline.

From a talk by Melanie Warrick

At a glance

Ideas worth remembering

  • A human-dependent decision should pause the affected work while unrelated orders continue.

  • Temporal separates workers that execute code, workflows that coordinate steps, and activities that perform external model and tool calls.

  • A wait condition preserves the pending interaction without holding a thread; a signal supplies the human’s response later.

  • In the worker-outage demo, the separate event store queues an approval, and replay reconstructs the workflow’s state so the order can continue after recovery.

  • Choose human checkpoints by balancing the cost of a wrong decision against alert fatigue.

One changed order should not stop the delivery fleet

An ice cream customer changes their mind after placing an order. Driver A now needs to wait while another human approves the change. Meanwhile, other orders should keep arriving and other drivers should keep delivering. This is the opening problem in Melanie Warrick’s Temporal demo: how to pause the work affected by a human decision without freezing the service around it.

Selected presentation frame from The Human Is an Async API — Melanie Warrick, Temporal at 172 secondsOpen full source frame
The delivery dashboard during the order-change demo, with the presenter on stage.

The fictional business belongs to Ziggy, Temporal’s mascot, and operates from San Francisco’s Ferry Building. Three agents coordinate its deliveries: a fleet agent, a customer agent and a dispatch agent. Google ADK orchestrates the agents, while Temporal tracks their execution state. Temporal’s UI exposes an event history for the parent workflow coordinating the delivery system.

The order change produces a visible, local interruption: driver A waits, but the rest of the fleet continues working. After approval, the system reads the update and A moves toward Oracle Park. The important relationship is between the decision and the work it controls. A human response gates this order’s next step; it does not need to gate every order in the system.

0:131:43

Agent loops need a place to preserve their progress

The familiar agent loop is reason, act, observe. It can be implemented as a for loop or a while loop, but the loop alone does not explain what happens when a process fails halfway through its work. The surrounding harness supplies the structure needed to run an agent in production. Its precise scope is debated—models, tools, memory, guardrails and security may all enter the picture—but Warrick’s addition is clear: durability belongs there too.

Selected presentation frame from The Human Is an Async API — Melanie Warrick, Temporal at 238 secondsOpen full source frame
A slide diagrams an agent loop through Reason, Observe, and Act.

Ziggy’s service contains three such loops with different jobs:

  • Fleet research: Assess drivers using tools such as Google Maps.
  • Customer research: Investigate orders using tools such as Google Search.
  • Dispatch decisions: Combine the fleet and customer agents’ findings to decide what happens next.

Human input can enter this structure, but so can failures. Preserving the agents’ progress and handling those failures is a separate concern from choosing the next delivery.

Temporal supplies primitives for state management and failure handling that application code can use. The aim is to make these concerns consistent across the distributed system, rather than requiring each agent loop to invent its own recovery behavior. Temporal is available as software and as a managed service; the execution model is something the application explicitly adopts.

3:414:11

Workers execute code; workflows track steps; activities call outside

Three parts divide the execution responsibilities:

  • Worker: Runs the application code.
  • Workflow: Tracks the steps and coordinates their progression. An agent loop can run inside a workflow.
  • Activity: Performs an interaction with something external, including a model call or a tool call.

For an agent, this separates the sequence of decisions from the external operations used to make those decisions. The workflow coordinates the loop; activities perform its model and tool interactions.

Selected presentation frame from The Human Is an Async API — Melanie Warrick, Temporal at 403 secondsOpen full source frame
A slide lays out Worker, Workflow, and Activity as three execution primitives.

The software is free and open source, with self-hosting available. The managed service is the paid option. That choice changes who operates the state-management infrastructure; either way, the application structures its code around workers, workflows and activities.

A human decision exposes the weakness of an ordinary blocking function. If “call the human” means keeping a live invocation waiting for a response, the service can lose track of that engagement when it goes down. The problem is larger than a slow response: the application must remember what question is pending and where execution should continue after an answer arrives.

6:286:58

A wait condition parks the work; a signal brings the answer

Two primitives turn the human interaction into an asynchronous exchange. A wait condition suspends the affected progression and preserves it in the workflow’s durability layer. A signal supplies input to that workflow later. Because the waiting state is preserved, recovery can return to the point where the human decision was needed instead of losing the pending interaction.

Selected presentation frame from The Human Is an Async API — Melanie Warrick, Temporal at 502 secondsOpen full source frame
The presenter introduces wait conditions and signals alongside a code slide.

Waiting does not mean holding a thread until somebody answers. The waiting execution yields, allowing other coroutines or workflows to continue; a workflow with no runnable work can be parked. Timeouts can bound how long an application waits for a human. Warrick describes the ability to keep millions of workflows parked, although this demonstration does not establish throughput or resource requirements at that scale.

The ADK integration applies the same division of work to an existing agent setup. A Temporal model wrapper surrounds the model, activity tooling wraps the tools, and the wrapped components go into the ADK agent. The worker receives the Google ADK plugin. The agent still runs through its framework, while its external calls participate in Temporal’s execution model.

The wait condition controls the path that depends on the response. The signal injects the human’s input into the workflow. This distinction matters: pausing a decision-dependent path does not require stopping all concurrent work, and accepting the answer does not require keeping the original process alive throughout the wait.

8:048:34

An agent can request the human through a graph interrupt

The first interaction began with a customer changing an order. The next reverses the direction: an agent decides it needs a human. The same wait-and-signal mechanism handles both. To demonstrate that the durability layer can span frameworks, the second setup keeps the customer and fleet agents on ADK and runs the dispatch agent on LangGraph.

In the LangGraph integration, graph nodes receive integration metadata. Model invocations and other tool calls become activities, while workflow code coordinates the steps. Warrick describes the distinction as deterministic workflows and nondeterministic activities: the orchestration must be recoverable from its history, while external calls can produce results that depend on the outside world. The worker also receives the LangGraph plugin.

LangGraph’s interrupt provides the point where a node asks for outside input. The surrounding loop uses a wait condition to pause the affected workflow, and a signal captures the human’s response. The graph expresses where the decision is needed; Temporal preserves the waiting execution and carries the eventual answer back into it.

Selected presentation frame from The Human Is an Async API — Melanie Warrick, Temporal at 799 secondsOpen full source frame
Code is displayed as the presenter explains LangGraph's interrupt flow.
11:3613:21

Approve the high-value order while the worker is offline

A high-value order now enters Ziggy’s service. The parent workflow continues coordinating the system, while child workflows split off for each order per framework. The customer and fleet agents assess this order and send their results to dispatch. Dispatch requests human involvement and enters a waiting state. Other delivery cars continue moving.

This is where the title becomes an execution requirement. Humans generally do not answer in 200 milliseconds; a response may take minutes, days or weeks. The high-value order therefore needs a preserved waiting state whose lifetime can exceed the lifetime of the process handling it.

Warrick presses Kill Worker. The worker goes offline and the demo shows it disconnected. She then presses Approve while it is still offline. The approval can be tracked and queued because the event is stored outside that worker, in a separate data store. The worker’s absence prevents it from executing the next step immediately; it does not erase the human’s decision.

When the worker comes back online, the event history is replayed to reconstruct the workflow’s state. “It’s not redone,” Warrick explains: recovery establishes where execution left off, then proceeds with the queued approval. The order is assigned and delivered. This demonstrates recovery from a worker outage while the separate event store remains available; it does not imply recovery from every possible failure of the whole system.

What survives when the worker disappears? The flow below follows the same high-value order through the interruption. The approval is recorded before the worker returns, so recovery has both the prior execution history and the new decision needed to move forward. That separation between stored events and active execution is what makes the offline approval useful.

The high-value order survives the worker outage

Assess the high-value orderOrder execution — Customer and fleet agents send their results to dispatch.
Wait for a humanOrder execution — Dispatch pauses this order’s progression; other deliveries continue.
Worker goes offlineWorker outage — Kill Worker disconnects the executing process.
Human presses ApproveWorker outage — The response arrives while the worker is offline.
Approval event is queuedPreserved state — A separate data store tracks the event outside the worker.
Worker returns and replays historyRecovery — Reconstruct the prior state and receive the queued approval.
Assign and deliver the orderRecovery — Execution continues from the recovered state.
The human’s approval enters the separate event store while the worker is offline. On return, the worker reconstructs state from history and continues with that approval.
Read the diagram as text
  • Assess the high-value order. Order execution — Customer and fleet agents send their results to dispatch.
  • Wait for a human. Order execution — Dispatch pauses this order’s progression; other deliveries continue.
  • Worker goes offline. Worker outage — Kill Worker disconnects the executing process.
  • Human presses Approve. Worker outage — The response arrives while the worker is offline.
  • Approval event is queued. Preserved state — A separate data store tracks the event outside the worker.
  • Worker returns and replays history. Recovery — Reconstruct the prior state and receive the queued approval.
  • Assign and deliver the order. Recovery — Execution continues from the recovered state.
  • Assess the high-value order → Wait for a human: Dispatch requests human involvement.
  • Wait for a human → Worker goes offline: Worker is killed during the wait.
  • Worker goes offline → Human presses Approve: Human responds during the outage.
  • Human presses Approve → Approval event is queued: Record and queue the response.
  • Approval event is queued → Worker returns and replays history: Approval is available when execution resumes.
  • Worker returns and replays history → Assign and deliver the order: Continue with the approved decision.
13:4714:17

Choose human checkpoints by the cost of being wrong

Durable waiting answers how to involve a human. It leaves a harder product decision: when should the agent ask? Warrick’s starting point is the cost of being wrong, particularly where security is involved. The high-value order illustrates a case where dispatch escalates, but the appropriate policy depends on the problem being solved.

Two pressures pull that policy in different directions:

  • Costly mistakes: Probabilistic models can make unreliable decisions, so consequential actions may justify human review.
  • Alert fatigue: Repeated requests can train people to answer “Yes, yes, yes” without giving each decision meaningful attention.

Asking more often is therefore not automatically safer. The checkpoint must be valuable enough to deserve the attention it consumes.

Selected presentation frame from The Human Is an Async API — Melanie Warrick, Temporal at 1030 secondsOpen full source frame
A slide asks when a human should be in the loop and lists decision considerations.

The wait-and-signal mechanism supports whichever checkpoints the application chooses. A customer can initiate a change, or an agent can request approval; both become preserved waits followed by human input that lets execution continue. The mixed ADK and LangGraph example also shows that this interaction need not belong to a single agent framework.

Warrick closes by inviting builders to discuss the problems they are solving with autonomous agents. The practical question to carry into that discussion is specific: which decision deserves a human’s attention, and what must the system remember while it waits? In Ziggy’s service, the answer is an order’s pending decision and execution state—even when the worker responsible for advancing it disappears.

13:4716:25
Transcript download
Full transcript

Loading transcript…