What are Cloudflare Dynamic Workers?

Cloudflare Dynamic Workers, launched in open beta in May 2026, are V8 isolate-based runtimes purpose-built to execute AI-generated code in milliseconds inside a sandboxed environment. Each invocation runs in its own isolate with no shared state, making them safer than traditional FaaS for arbitrary AI-generated code. They sit alongside Workers, Workers AI, Vectorize, and Workflows V2 as part of Cloudflare's Agent Cloud platform.

Why does this matter for AI agents?

AI agents increasingly generate code at runtime — they write SQL, generate Python, build small tools, then execute them. Running untrusted AI-generated code in a normal serverless function is risky (shared filesystem, persistent process, blast radius). Dynamic Workers isolate every invocation in V8, so an agent that generates malicious code can't escape its sandbox. Combined with Cloudflare Sandboxes (now GA), agents get safe, fast, cheap code execution at the edge.

How are Dynamic Workers different from regular Cloudflare Workers?

Regular Workers are designed for predictable, deployed code that you write and ship via Wrangler. Dynamic Workers are designed for unpredictable, AI-generated code that needs to spin up and tear down per request. Cold start, isolation, and security model are all tuned for the AI-generated case. Both run on the same Cloudflare edge infrastructure.

How do Dynamic Workers compare to AWS Lambda for agent workloads?

Dynamic Workers cold-start in milliseconds (V8 isolates) vs Lambda's 100-500ms typical cold start. Dynamic Workers are cheaper per request at scale. Lambda has longer max execution (15 minutes vs 30 minutes paid) and more memory. For short, sandboxed agent code execution at the edge — Dynamic Workers win. For long-running enterprise agent jobs with heavy memory — Lambda + Bedrock AgentCore wins.

Quick Answer

What is Cloudflare Dynamic Workers? (Agents Week May 2026)

Published: May 17, 2026

What is Cloudflare Dynamic Workers? (Agents Week, May 2026)

During Agents Week 2026, Cloudflare shipped Dynamic Workers in open beta — a new runtime built specifically to execute AI-generated code safely, quickly, and cheaply. Here’s the full picture.

Last verified: May 17, 2026

The one-paragraph answer

Cloudflare Dynamic Workers are isolate-based runtimes purpose-built to execute AI-generated code in milliseconds, inside a per-invocation sandbox, with no shared state between calls. They launched in open beta during Agents Week (May 2026) as part of Cloudflare’s expanded Agent Cloud platform. Where regular Cloudflare Workers are built for code you deploy, Dynamic Workers are built for code an agent generates at runtime — making them the AI-native execution layer for agents that write and run their own tools, APIs, and snippets.

Why Dynamic Workers exist

In 2024-2025, agentic AI hit a wall: agents could generate code well but couldn’t safely run the code they generated.

Traditional FaaS (Lambda, Cloud Functions) has 100-500ms cold starts and slow per-request sandboxing.
Long-running containers share state and have a large blast radius if AI-generated code goes sideways.
Local execution on the user’s machine is fast but unsafe and not always available.

Dynamic Workers solve this by giving agents an edge-native, isolate-per-request, millisecond-cold-start runtime designed from the ground up for short-lived, sandboxed AI code.

How Dynamic Workers fit into Cloudflare’s Agent Cloud

Cloudflare’s Agent Cloud (expanded heavily during Agents Week 2026) now includes:

Primitive	Purpose
Workers	Deploy your own code at the edge
Dynamic Workers	Execute AI-generated code per-request in isolates
Workers AI	Inference for open and partner LLMs at the edge
AI Gateway	Route, cache, observe LLM calls across providers
Vectorize	Vector database
KV / D1 / R2	Key-value, SQL, object storage
Durable Objects	Stateful per-key compute
Workflows V2	Stateful, long-running multi-step workflows (50K concurrent)
Artifacts	Git-compatible storage for agent code and data
Sandboxes (GA)	Full OS environments for heavier agent tasks
Mesh	Private network access to internal databases via Workers VPC
agents-sdk	Build agents that deploy directly to Workers

Dynamic Workers slot in as the per-request code execution primitive that the broader stack composes around.

The architecture

┌───────────────────────────────────────────────────────────────┐
│  Agent (Claude / GPT-5.5 / Qwen) generates code              │
│              ↓                                                │
│  Workflows V2 (or your orchestrator)                         │
│              ↓                                                │
│  Dynamic Worker (V8 isolate, sandboxed, ms cold start)       │
│   ├── reads from KV / D1 / R2 / Vectorize                    │
│   ├── calls Workers AI for inference                         │
│   ├── network egress via Mesh (with policy)                  │
│   └── returns result + telemetry                             │
│              ↓                                                │
│  Result returned to agent → next step                        │
└───────────────────────────────────────────────────────────────┘

Each Dynamic Worker invocation:

Spins up a fresh V8 isolate.
Has no access to other invocations’ state.
Has scoped permissions (network, KV, D1) defined by the calling agent’s policy.
Tears down when the invocation ends.

For heavier tasks (building code, running shell commands, iterating on a large repo), Dynamic Workers hand off to Sandboxes — which give the agent a full OS environment with the same edge-native deployment.

What you can build with Dynamic Workers

AI-generated SQL execution — agent writes a query, Dynamic Worker runs it against D1.
AI-generated API mash-ups — agent writes JS that calls 3 APIs and combines results.
Per-request agent tools — agent dynamically generates a tool implementation for a one-shot use case.
Workflow steps inside Workflows V2 — each step can be a Dynamic Worker running AI-generated code.
Code interpreter for chat agents — like ChatGPT’s Code Interpreter, but at the edge and per-request.

Strengths

Millisecond cold starts — V8 isolates beat container-based FaaS by orders of magnitude.
Per-invocation isolation — true sandboxing for AI-generated code.
Cheap at scale — Workers pricing is among the lowest in serverless.
Edge-native — 300+ cities, low latency globally.
Tight integration with the rest of Cloudflare’s agent primitives (Workflows, Mesh, Sandboxes, Vectorize).
No infrastructure to manage — no servers, no clusters.

Weaknesses / caveats

Open beta — production SLAs may not be there yet.
Memory limits lower than Lambda (typically 128MB-1GB per isolate).
Max execution capped at 30 seconds on free / 30 minutes paid — for hours-long jobs, use Sandboxes or Workflows V2.
Not for arbitrary native code — V8 isolate means JavaScript / WebAssembly / Python (beta).
Compliance regimes (FedRAMP, certain HIPAA workloads) may still prefer AWS.

Dynamic Workers vs the alternatives

	Cloudflare Dynamic Workers	AWS Lambda + Firecracker	Vercel Functions	E2B / Modal / Daytona sandboxes
Cold start	ms	100-500ms	50-300ms	seconds
Sandboxed per request	✅	✅	partial	✅
Edge / global	✅ (300+ cities)	regional	edge runtime	regional
Max execution	30s / 30m paid	15m	60s / 15m enterprise	hours
Cost at scale	cheapest	mid	most expensive	mid
Best for	AI-generated code at edge	Enterprise long-running	UI + APIs	Heavy interactive workloads

What changed in Agents Week 2026

Dynamic Workers — open beta launch.
Sandboxes — GA (was beta).
Workflows V2 — supports 50K concurrent workflow instances.
Artifacts — Git-compatible storage primitive for agent code.
Mesh — secure VPC-style access for agents to reach private databases.
agents-sdk — framework refresh for building agents directly on Workers.

How to try it

Sign up for a Cloudflare account, enable Workers Paid ($5/mo for 10M requests).
Opt into the Dynamic Workers beta in the Cloudflare dashboard.
Use the agents-sdk to spawn a Dynamic Worker invocation from your agent code.
Pair with Workers AI for inference, Vectorize for memory, Workflows V2 for orchestration.

The official quickstart is in the Cloudflare Agents Week 2026 docs and the agents-sdk repository.

What’s next

GA expected H2 2026.
Python Dynamic Workers in deeper beta.
Tighter Sandbox integration — seamless promotion from Worker isolate to full Sandbox OS when an agent needs more headroom.
Cross-edge state primitives via Durable Objects + Workflows V2 for very long-running agent runs.

TL;DR

Dynamic Workers are Cloudflare’s bet that AI-generated code is going to dominate runtime in the next few years — and that the right runtime is edge-native, isolate-per-request, sandboxed, and cheap. If you’re building agents that generate and execute code, Dynamic Workers should be on your short list.

Sources: Cloudflare press releases (May 2026), Cloudflare Agents Week site, InfoWorld on Dynamic Workers, blog.cloudflare.com — May 2026.