A different shape for durable execution

Turning a working prototype into a production backend usually means bolting on queues, retry policies, status stores, and monitoring—then keeping a separate orchestration service alive on top of the code that actually does the work. Vercel Workflows takes the opposite approach: the orchestration logic lives inside the application code itself, with the infrastructure layered underneath.

Workflows has been in beta since October 2025. Since then, Vercel says the platform has processed over 100 million runs and more than 500 million steps across over 1,500 customers, with more than 200K npm downloads weekly. The platform is now generally available.

The built in observability dashboard for Workflow SDK on Vercel. The built in observability dashboard for Workflow SDK on Vercel.

Where it fits

The platform targets anything that can't finish inside a single request.

  • Agents: Workflows integrates with the AI SDK, supporting durable long-running agents that keep state, hold tools, and pause for external events. AI SDK v7 adds a WorkflowAgent on top of this model.
  • Backends: The TypeScript Workflow SDK remains the core implementation, and a new Workflow Python SDK is now in beta.
  • Long-running tasks: Multi-step onboarding, payment flows, ETL pipelines, or anything that otherwise needs hand-wired queue and retry logic.

How the runtime is built

Rather than routing state through a central orchestrator, Workflows splits coordination across three infrastructure pieces:

  • Event log: Every step input, output, stream chunk, sleep, hook, and error is appended here. It's the authoritative record of execution state.
  • Functions on Fluid compute: Each step runs as its own invocation. The workflow library inside the function handles dequeueing, state loading, encryption, execution, and handoff to the following step.
  • Vercel Queues: Each step enqueues the next automatically. Queues can run on Vercel, in your own Postgres, or in-memory during local development.

With no separate orchestration tier, you're only billed for compute when step functions are actually running.

Control flow with a small API

In TypeScript, marking a function with "use workflow" turns it into a durable workflow, and "use step" isolates an individual unit of work. The rest is ordinary control flow.

export async function createSite(input: { userId: string }) {
  "use workflow"
  const profile = await fetchUserProfile(input.userId)
  const plan = await generateSitePlan(profile)
  const site = await buildSite(plan)
  return site
}
async function fetchUserProfile(userId: string) {
  "use step"
  return db.user.findUnique({ where: { id: userId } })
}
async function generateSitePlan(profile: unknown) {
  "use step"
  return callModel({ prompt: `Generate a site plan for ${JSON.stringify(profile)}` })
}
async function buildSite(plan: unknown) {
  "use step"
  return provisionSite(plan)
}

The example above creates a site across three durable steps. It looks like one function calling another—that's intentional. Each step automatically gets retries, persistence, isolation, and observability. The same code runs against a database locally and at scale in production without additional orchestration tooling.

One demonstration from the beta period is an infinite chess match that continuously runs models against each other, passes the current board state, validates moves, and re-renders the game turn after turn, indefinitely, inside workflow steps.