Chat SDK Adds Durable Approvals: Agent Workflows That Wait For a Human

On August 6, Vercel announced that its Chat SDK can now pause a workflow until a human approves it. A single requestApproval call from the new chat/workflow subpath posts an Approve/Deny card into a chat thread and suspends a Workflow SDK run until someone decides. The wait can be seconds or days, and it survives deploys and restarts. No approvals table, no onAction handler, no polling loop.

The changelog example is a deploy gate:

import { requestApproval } from "chat/workflow";
import type { Thread } from "chat";

export async function deployApproval(opts: { thread: Thread; version: string }) {
  "use workflow";

  const { approved, user, timedOut } = await requestApproval(opts.thread, {
    title: `Deploy Website?`,
    fields: { Version: opts.version },
    timeout: "24h",
  });

  if (approved) {
    await deploy(opts.version);
  }
}

What shipped#

The approval surface is a small API with sharp edges, documented in the approvals guide:

• Durable wait, not a message. requestApproval suspends the workflow until a click or a timeout. Thread instances serialize across the workflow boundary, and you register your Chat instance as a singleton so the run revives cleanly after a restart.
• A real result object. The call resolves to { approved, timedOut, user }, where user is the person who decided. A timeout is a first-class outcome, not an error you recover from by squinting at logs.
• Verified decisions. Chat SDK checks the platform's signature on every click, and the button's callback URL never reaches the client. The user.id on the result is genuinely the person who clicked - important for anything that ends up in an audit trail.
• Scoped approvers. Pass approvers with user IDs and clicks from anyone else post a notice while the workflow keeps waiting. The docs say it plainly: set approvers for anything consequential.
• Stale-proof cards. When a decision lands or the timeout elapses, the card is edited in place - buttons are replaced with an outcome line, so an old thread cannot be clicked a second time to authorize a second deploy.
• Custom cards for webhooks. buildApprovalCard and buildResolvedCard are exported for flows where the buttons should target a webhook you manage yourself.

Options are minimal on purpose: title (required), subtitle, description, fields, approveLabel/denyLabel, timeout in ms/s/m/h/d, and approvers. Omit the timeout and the workflow waits indefinitely.

Why it matters#

Durable approvals are the missing primitive in agent deployments. For the past year, teams building agents that do irreversible things - deploys, releases, refunds, credential rotation - have hand-rolled the same three pieces: a place to store pending approvals, an event handler that resumes the run, and a poller that checks whether anything happened. That stack is where agents silently die: the process restarts, the in-memory state is gone, and the "human check" never happens.

This design moves the human into the workflow graph instead of bolting them on next to it. The suspend is a language feature of the Workflow SDK - the same durability model as our AI SDK 7 writeup covered in June, where approval support landed in the SDK proper. What is new here is the chat surface: the approval lives where the operator already is, and the platform signature guarantees who clicked. For Slack or Discord-based ops, that collapses a whole custom approvals service into one function call.

The approvers option is the quietly important part. Most approval UIs let everyone vote; this one lets you enumerate exactly who can decide, which is the difference between a rubber stamp and a control. Combined with verified clicks and the in-place outcome line, you get a decision record you could actually defend later - no custom logging required.

Where it fits#

This is Vercel's agent platform assembling itself in public. The v0 API makes app-building agents callable by software; AI Gateway budgets cap what those agents spend; MCP tooling shapes how those agents reach tools. Durable approvals are the gate between the agent and the action - the moment a human explicitly says "yes" instead of the agent guessing.

It also speaks to the approval-fatigue problem we covered in Approval Fatigue Is an Agent Security Bug: the failure mode of bad approval UIs is that they fire constantly and train people to click through. A durable gate is only as good as its placement. If every step of a five-step workflow requires a chat click, this reintroduces fatigue with extra steps. The right shape is what that post argued for - risk-aware autonomy with approvals reserved for irreversible actions - and requestApproval slots into that exactly: a scoped, signed, time-boxed decision on a narrow action.

One honest caveat: this is chat-platform-shaped. The card, the signature check, and the click handling all belong to the platform integration, so the durability guarantees are strongest where Chat SDK integrations exist. And registerSingleton plus the Workflow SDK peer dependency means this is a deliberate architecture choice, not a drop-in snippet. But for teams already on that stack, it is the approval layer that was previously three systems, now one call.

Continue Reading#

• Vercel AI SDK 7: The Production Agent Upgrade - the SDK-level agent runtime, WorkflowAgent, and earlier approval support
• The v0 API Is GA - Vercel's app-building agent as a headless service, called from agent loops
• AI Gateway Spend Budgets and Alerts - the other half of agent governance: capping what agents can spend
• Approval Fatigue Is an Agent Security Bug - why approval UX determines whether gates actually protect you
• AI Agent Containment Needs a Capability Ledger - the wider trust-boundary debate around agent actions

Sources#

• Pause workflows for approval with Chat SDK - Vercel Changelog - the August 6 announcement
• Approvals - Chat SDK documentation - API reference, options, result shape, and setup
• Workflow SDK - the durable execution runtime that suspension builds on