Back to Explore
NewsVibeFix editorialUpdated Nov 20, 2026

The Longer an Agent Runs, the More It Fears a Crash: Vercel Workflow SDK 5 Turns the Execution Layer Into Production Gear

On 12 November 2026, Vercel released Workflow SDK 5: every run payload encrypted end to end with AES-256-GCM, infrastructure in every Function region, and step overhead down as much as 25x. The context is 4 billion steps and 700 million runs: agents are expensive and long-running, so they need durability too.

A developer wearing glasses sits before several monitors showing code in a dim office at night, adjusting his glasses as blue and purple light fills the workspace

In short: the longer an agent runs, the more it fears a crash

On 12 November 2026, Vercel released Workflow SDK 5, under the title "Workflow SDK 5: built for production." This is not a new product launch but an upgrade to an execution layer: it lets developers write regular async JavaScript that keeps running through crashes, deployments, and long waits — without losing state, redoing work, or starting over. Vercel opens the blog with scale: since Workflow SDK launched, customers have run more than 4 billion steps and 700 million runs on it. That number is the premise for understanding this release — 5.0 is not something built from zero, but an upgrade shaped by 700 million runs and the two kinds of work that emerged from them.

Vercel divides those two kinds of work cleanly in the blog. The first is traditional automation: moving data, processing orders, coordinating background jobs, managing subscriptions, running ETL and data pipelines. The second is agents and harnesses: "Agents are expensive and long running, so they naturally require durability too." That sentence ties all of 5.0's changes together — encryption, regional deployment, performance — all in service of making "things that run a long time don't die halfway" hold up in production.

First, what it is: two directives that draw the line between what can break and what cannot

The programming model is simple enough to state in one sentence: write regular async JavaScript, and the SDK guarantees it keeps running after crashes, deployments, and long waits. Two directives make the guarantee work. A function marked "use workflow" is deterministic orchestration — it only decides "what happens next" and must contain no side effects. A function marked "use step" is where the real work happens: it can fail, pause, and produce side effects. Every step's arguments and return values are written to an event log, so after a crash or a redeploy the runtime resumes from the last completed step instead of starting over.

The blog's example is a new-user welcome flow: create the user, send a welcome email, wait three days, send a follow-up email. The await sleep("3d") in the middle is the point — a flow that waits three days cannot be built by "just waiting" on an ordinary server; it takes scheduled jobs, a state machine, or queues and retries. Workflow SDK folds that into a single function: the code reads sequentially, but every step is persisted, interruptible, and resumable. For people building with agents, the significance is that you can write a three-day flow without learning queues, status tables, and retry logic first — but you have to get the split right: what belongs in a workflow and what belongs in a step. Get it wrong and the durability guarantee does not hold.

There is also an infrastructure concept in 5.0 that is easy to miss, called a World. A World is the interface for storing progress, dispatching work, and delivering streams, and it is shared by Workflow SDK, WorkflowAgent (the AI SDK wrapper for agent loops), fx (Vercel's open-source native coding agent), durable-harness (which adds durability to existing harnesses), and eve (Vercel's agent framework). The blog adds a careful caveat: improvements to the shared storage, queue, and streaming infrastructure can benefit any consumer of a World, but optimizations inside the Workflow replay runtime apply to Workflow SDK — they do not automatically apply to every harness. That sentence is written for people who would equate "the foundation got faster" with "my harness got faster": foundation and upper layers are two different things, and they should not be accounted together.

More secure: the event log holds your customers' data, so 5.0 encrypts it by default

The first big change in 5.0 is security, and the blog states the reason up front: the event log stores every step's arguments and return values so a run can recover after a crash or deployment. But that data can include sensitive customer information, model context, credentials, and tool-call results — exactly the most sensitive things are the ones being persisted. Version 5 encrypts every payload end to end with AES-256-GCM, using a unique key for each run, before it leaves your code. Workflow and step inputs and outputs, hook payloads, and stream data are all encrypted. After encryption, any Workflow SDK backend, including Vercel, only sees and stores ciphertext; plaintext is decrypted only in your deployment or in authorized observability tools.

On Vercel, encryption needs no setup and no code changes. Each run's key is derived from a key scoped to the deployment that created it, so a run can only decrypt its own data. Your workflow code does not change. When you need to see a payload, you can decrypt it in the dashboard or the CLI; decryption happens in your browser or terminal, follows the same permissions as the project's environment variables, and every request is recorded in your team's audit log. The blog gives two commands: npx workflow inspect run <run-id> shows payloads as "Encrypted," and npx workflow inspect run <run-id> --decrypt decrypts locally if you have access. What can be seen, what cannot, and who looked are all recorded.

People who self-host Worlds get encryption too, because it is implemented in the SDK rather than only in Vercel's managed service. A custom World implements getEncryptionKeyForRun() and returns the same 32-byte key for a run on every call, so the SDK can encrypt new payloads and decrypt them during replay. Cross-run writes are sealed as well: when code resumes another run's hook, starts a run in another deployment, or writes into a stream forwarded from another run, the payload is encrypted to the target run's public key — the writer can encrypt for that run without reading its existing payloads. And with the experimental experimental_retention: 0 option, inputs, outputs, and stream contents are deleted as soon as a run completes or fails, while the run's metadata stays visible for observability.

There is one easy trap here, and the blog states it plainly enough to quote: the new run attributes in v5 are plaintext. You can attach searchable context to a run, such as an order ID, and then find runs by it — but attributes are stored in plaintext, so they should not contain secrets. Encryption protects payloads, not labels you stick on by hand. Putting an order ID in an attribute is correct usage; putting an API key there is misuse — and the blog puts that sentence in the feature introduction precisely because someone will mistake "searchable" for "safe for anything."

Closer: in v4 every run squeezed into one region; in 5.0 each run lives near its user

The second big change is regions. Workflow SDK 4 had a flaw every multi-region user could feel: no matter how many regions a project was deployed to, each run's event log, queue, and streams were only stored in iad1 (US East). A step running anywhere else made a cross-region request every time it recorded progress. In v5, Vercel deployed Workflow infrastructure to every Vercel Function region. Each run has its own home region: its state, queue dispatch, and streams are served from the region where it started, without cross-region round trips on the hot path. By default, a run starts in the region of the function that starts it. Deploy to several regions, and each run stays close to the user who triggered it, with no configuration.

The blog gives two concrete uses. To place a run somewhere else, pass a region to start(): to keep an order workflow's data in Frankfurt, pass { region: "fra1" }. The benefit is not only speed but compliance: a customer's data can stay in the region where it has to stay. But the blog adds a limit: the region option decides where a run's data lives; your steps run where your app is deployed, so deploy to that region too if you want them to execute there. Existing v4 runs also stay in iad1 — they do not move automatically.

Regional deployment also improves reliability as a side effect. A disruption in one region does not have to stop new runs in healthy regions; for projects with Vercel Function failover configured, steps can execute in a fallback region while continuing to use the run's original home region for state — that state remains pinned to its home region and does not migrate during failover. The blog also says that, with the help of anonymized telemetry and close collaboration with many customers, the team found and fixed dozens of rare bugs and race conditions, and that Workflow SDK now recovers on its own from more kinds of intermittent network errors. The concluding line is Vercel's own observation: "with Workflow SDK 5, we've seen almost no runs fail or stall because of a platform or runtime bug." That is a vendor-reported observation, not an independently tested conclusion, and it should be read at that level.

Faster: step-to-step overhead down as much as 25x — but read the measurement conditions first

The third big change is performance, the section with the densest numbers in the blog. The headline first: comparing v5.2.0 with v4.8.12, Vercel saw 1.6x to 25x improvements in measured latency and overhead across its measured workloads, while preserving the same developer experience and introducing no major breaking changes. Then the measurement conditions, because they decide what the numbers can say: measured on 8 October 2026, on Vercel production in iad1, against the managed Vercel World; each version used a separate deployment of the same app; steps take 1 KB of JSON in and out. The blog states the scope at the end of the section: "These measurements describe one workload, in one region, against the Vercel World. They are a useful view of runtime overhead, rather than a prediction for every application." That sentence has to be read together with the numbers, not after them.

The benchmark table lists seven measurements; four are worth remembering. Time to first step (p75) fell from 418 ms to 172 ms, 2.4x faster — the time from your app calling start() until the first line of the workflow's first step runs, covering run creation, queuing, running the workflow code up to its first step, and starting that step. Between-steps overhead (p75) in a five-step benchmark fell from 618 ms to 109 ms, 5.7x faster. Late-run overhead (p75) in a 1,020-step benchmark fell from 1,748 ms to 70 ms, 25x lower — the largest improvement in 5.0. Median time to finish all 1,020 steps fell from 21.0 minutes to 3.0 minutes, 7x faster. Resume time (p75) fell from 699 ms to 425 ms, 1.6x faster. Stream delivery median time fell from 226.1 seconds to 53.5 seconds, 4.2x faster; chunk trip time (p75) fell from 172 ms to 102 ms, 1.7x faster; and runs with a chunk delayed by more than a second fell from 6 out of 10 to 0 out of 10.

Three specific changes sit behind those numbers, and the blog names all of them. First, fewer queue hops: in v4, each step handed execution back through the queue; in v5, an invocation can execute several steps inline, including parallel steps, before yielding for a wait, a hook, or an approaching timeout. The runtime also avoids unnecessary persistence round trips and folds step creation into execution. Second, incremental replay: in v4, replay overhead grew with the event log — in the 1,020-step benchmark, the final sampled range reached 1,748 ms; on v5.2.0 it was 70 ms. Third, WebSocket streaming: on the Vercel World, v5.2.0 writes streams over WebSockets by default. In a benchmark replaying a 52.4-second agent response (2,593 chunks, ten runs per version), median delivery dropped from 226.1 seconds to 53.5 seconds — and the blog notes explicitly that this measures "delivery of a recorded response, not faster model generation." Payload compression also makes AI token streams average around 80% smaller.

Benchmark comparison: Vercel Workflow SDK v5.2.0 vs v4.8.12 — first-step time 418 ms down to 172 ms, between-steps overhead 618 ms down to 109 ms, late-run overhead 1,748 ms down to 70 ms, resume time 699 ms down to 425 ms; median time for 1,020 steps fell from 21.0 minutes to 3.0 minutes

Two smaller items: a better trace viewer, and a Python SDK in beta

Beyond security, regions, and performance, 5.0 has two smaller items worth including. The first is the redesigned trace viewer: span search, zoom, a minimap, and local inspection during development. Together with run attributes, you can tag a run with an order ID and find it later — much easier than paging through logs by time when a team has run thousands of workflows. The second is the Python SDK, now in beta: the same durable workflows, steps, sleeps, and hooks, in Python. Installation is still one command: pnpm add workflow@latest. The blog also says the v5 upgrade docs cover what changed, and that this upgrade introduces no major breaking changes — a message worth verifying before acting on it for anyone already running v4: "no major" does not mean "none," and the upgrade docs are still the place to check.

Drawing the line with earlier coverage: this is neither a harness review nor a harness launch

The word "harness" has appeared a lot on this site recently, and this article is easy to confuse with three others, so the boundary is worth drawing. The first is Vercel's durable-harness from 21 October: that one is about a library — adding durability to Pi and OpenCode, with experimental support for Claude Code and Codex, so existing harnesses survive crashes; this article is about the runtime underneath it, the Workflow SDK 5.0 release itself, with durable-harness only one of the things running on top. The second is Microsoft's Copilot Harness from 28 October: that one is Microsoft's agent foundation — one foundation, swap models without rewriting — a different vendor's different product. The third is cycle224's Garry Tan harness evaluation: that one is a review, measuring the "shell" — the same model across different harnesses, comparing cost and results; this article is not a review but a release note for a specific version, and its numbers all come from Vercel's own measurement on 8 October, with the methodology stated in the text.

Two more names that collide are worth a line each. The 22 October piece on Vercel's fx covered Vercel Labs' open-source fx, a minimal coding agent written in Zig — fx is one of the things running on Worlds, above Workflow SDK 5.0, not the same thing. And on 17 November Vercel announced eve 1.0 as generally available — Vercel's agent framework, also running on Worlds; this article mentions eve only in the list of World consumers and does not go into it — eve 1.0 deserves its own piece in a later cycle. Read separately, Vercel's last two months come into focus: in October, durable-harness was open-sourced so existing harnesses stop dying on crashes; in November, the Workflow SDK underneath was raised to 5.0 with encryption, regional deployment, and speed, and the upper layers — fx, eve — are being moved onto production one by one.

For people building projects with agents: when you need it, and when you don't

Start with the practical question: does your project need a durable workflow? The answer depends on whether your work "dies halfway." If your agent loop involves thousands of sequential events, high-throughput token streams, long tool chains, and dynamic subagents — the blog's own four features — then the overhead of every step gets amplified, and the cost of a crash is large: rerunning burns tokens again, redoing means calling tools again, and lost intermediate state has to be cleaned up by a human. That kind of work is worth putting on Workflow SDK. If your work is one-off, finishes in minutes, and costs nothing to rerun, a durable workflow is unnecessary complexity: the event log, encryption, regions, and tracing are costs paid for "running a long time," and short runs do not need to pay them.

The second thing to settle is that durability is not correctness. Workflow SDK guarantees "it resumes after a crash," not "what it resumes is right." If your step has a bug, replay will faithfully run the bug again; if your workflow logic has the wrong order, durability will only make the wrong order execute more reliably. That is what the blog's "deterministic orchestration" requirement means: only deterministic orchestration logic belongs in "use workflow", and anything with side effects must go in "use step". That split is not a style question but a correctness question — mix randomness, the current time, or external calls into the orchestration, and the replayed result will differ from the first run, and the durability guarantee breaks.

Third, read the upgrade docs before the benchmark table. The blog says this upgrade introduces no major breaking changes, but "no major" is not "none"; run attributes are plaintext, v4 runs stay in iad1 and do not move, and experimental_retention: 0 is still experimental — all details to confirm before upgrading. The benchmark numbers should also be read with their conditions attached: 1 KB of JSON, iad1, the managed Vercel World, one measurement on 8 October. If your workload has bigger steps, a different region, or a self-hosted World, the numbers will differ — the blog says so itself, and reading it that way keeps "1.6x to 25x" from becoming a promise for every application.

Conclusion: the prompt is not the product — the execution layer is

One sentence in this blog deserves to be pulled out of the technical detail: Vercel's weekly community digest listed Workflow SDK 5 as the week's top highlight for one reason — it lets developers write regular async JavaScript that continues running through crashes, deployments, and long waits. The subtext is that the next phase of the agent race will not be decided by whose prompts are cleverer, but by whose execution layer survives production. Models will be replaced, harnesses will be replaced, benchmark scores will go stale — but "after 700 million runs, it still resumes when it breaks" is something bought with real traffic, not something a blog post can claim into existence.

For people building with agents, that judgment has a practical meaning: what you build with an agent will sooner or later have to go from "it ran once" to "it runs every day." Before that day comes, three questions are worth settling: what happens when your long flow breaks, what sensitive data sits in your event log, and how far your runs are from your users. Workflow SDK 5 answers those three questions, but its answers apply directly only to people on Vercel; for everyone else, the questions still stand — only the answers have to be found elsewhere. Prompts can help you build a product. The execution layer decides whether your product stays alive — the real news in this release is in that sentence, not in the benchmark table.

Views 0Comments 0

Comments (0)

ME
0/1000
Loading comments...

Sources

Browse projectsPublish your project

Related articles

A developer with glasses types on a laptop at a wooden desk, an external monitor to the left showing C code on a dark background, a small plant on the desk
News
Microsoft's Coding Model Stops Playing Second Fiddle: MAI Code 2 Scores 96% of Opus 5.5 for 5% of the Cost — Read the Three Caveats First

On 17 November 2026, Microsoft launched MAI Code 2 and Code 2 Flash: the larger model has 77 billion active parameters and a one-million-token context, averaging 63.2% across four benchmarks — close to GPT-6.1 Sol and Claude Opus 5.5 — at $0.309 per task. Read the three caveats first: promotional pricing, the lowest score of the three, and no long-horizon work.

Developer WorkflowProduct LaunchModel Updates
A developer types at a dual-monitor workstation; the left screen shows a dark code editor, the right a testing dashboard with green checkmarks and bar charts
News
Did Your Agent Get Better or Worse? AWS Open-Sources UAEF to Measure Agents from Every Framework with One Ruler

On 11 November 2026, AWS open-sourced UAEF: adapters turn traces from LangGraph, LangChain, Strands and Bedrock AgentCore into one format, then 36 metrics across 7 dimensions score them, flagging regressions past 5%. The judge model is hardened too — scores must cite verbatim evidence, and never decide safety.

Developer WorkflowProduct LaunchTesting & Quality
Against a black background, a conductor seen from behind raises a baton, with swirling trails of light circling beneath him like an orchestra being conducted
News
One API for 45 Models, and It Switches Providers When One Fails: Perplexity's Orchestrator Wants to Be the Switchboard

On 17 November 2026, Perplexity launched the Orchestrator API: one interface reaching OpenAI, Anthropic, Google, xAI and open-weight models such as GLM, Kimi and DeepSeek, billed at the answering model's published rate with no platform fee. When one provider fails, the same model retries on another deployment, and preview routing assigns requests to models by task.

Developer WorkflowProduct LaunchModel Updates