Cloudflare Dynamic Workers: V8 Isolates Spun Up at Runtime

Containers take seconds to start and megabytes to run — Dynamic Workers give you isolated V8 environments in milliseconds at a fraction of the cost, and they are now in open beta.

What Are Dynamic Workers?

Regular Cloudflare Workers are deployed ahead of time. You write code, run wrangler deploy, and it runs globally. Dynamic Workers flip that model: you create isolated V8 environments at runtime, feed them code, and execute it on demand.

Think of them as the lowest-level compute primitive on the Cloudflare platform. A Dynamic Worker is a sandboxed V8 isolate spun up programmatically from a parent Worker. No containers. No VMs. No cold-start penalty. Your code creates another piece of code and runs it in isolation — in milliseconds.

The open beta announcement positions Dynamic Workers as the foundation for a new generation of AI-powered applications — agents that generate and execute code rather than calling predefined tools.

Two Loading Modes

Dynamic Workers offer two ways to load and execute code, each optimized for a different use case. Both are documented in the getting started guide.

import { DynamicWorker } from "cloudflare:workers";

export default {
  async fetch(request, env) {
    const script = 'export default { async fetch(req) { return new Response("Hello from dynamic code!"); } }';
    const worker = await DynamicWorker.load(script);
    return worker.fetch(request);
  }
};

import { DynamicWorker } from "cloudflare:workers";

export default {
  async fetch(request, env) {
    const userId = new URL(request.url).searchParams.get("user");
    const worker = await DynamicWorker.get(userId, async () => {
      // This callback runs only on first creation
      const code = await env.R2.get(`workers/${userId}.js`);
      return { code: await code.text() };
    });
    return worker.fetch(request);
  }
};

Code Mode: 81% Fewer Tokens for AI Agents

This is the headline feature for AI builders. Code Mode fundamentally changes how LLMs interact with tools. Instead of making sequential tool calls (ask the model, get a tool call, execute it, return the result, ask again), the LLM writes a single JavaScript program that orchestrates multiple operations in one shot.

Cloudflare provides three helper libraries to support Code Mode:

• @cloudflare/codemode — Core library for Code Mode integration. Handles the LLM prompt engineering, code extraction, and execution lifecycle.
• @cloudflare/worker-bundler — Bundles multi-file Dynamic Workers with dependencies, so LLM-generated code can import real npm packages.
• @cloudflare/shell — Interactive shell environment for Dynamic Workers. Useful for building REPL-style developer tools and debugging.

Security Model

Running arbitrary code is dangerous — unless your runtime was designed for it. Dynamic Workers inherit the same V8 isolate sandboxing that powers all Cloudflare Workers. Each isolate gets its own memory space, cannot access the filesystem, and runs with strict resource limits.

This security model is a significant advantage over container-based code execution. Containers share a kernel, require careful seccomp/AppArmor configuration, and have a much larger attack surface. V8 isolates were purpose-built for running untrusted code.

Configuration

Enabling Dynamic Workers requires adding the dynamic_workers binding to your wrangler.jsonc configuration:

{
  "name": "my-dynamic-app",
  "main": "src/index.ts",
  "compatibility_date": "2026-03-15",
  "dynamic_workers": {
    "enabled": true
  }
}

That is the entire configuration. No provisioning, no capacity planning, no scaling rules. The parent Worker creates Dynamic Workers on demand, and Cloudflare handles the rest across its global network.

Use Cases

If your Dynamic Workers connect to Cloudflare D1 databases, MyD1's AI Agent helps you write advanced queries, optimize database performance, and discover insights you would never find without AI — all from a native macOS app.

Why JavaScript?

Dynamic Workers run JavaScript (and TypeScript) exclusively. This is a deliberate choice, not a limitation:

• Natively sandboxable — JavaScript was designed to run untrusted code in browsers. V8 isolates inherit decades of security hardening from Chrome.
• TypeScript interfaces are 4x more token-efficient than OpenAPI — When an LLM needs to understand available APIs, a TypeScript interface definition is dramatically more compact than the equivalent OpenAPI JSON schema. Fewer tokens in the prompt means more room for reasoning.
• Universal language for LLMs — JavaScript is the most widely represented language in LLM training data. Models generate more accurate, idiomatic JavaScript than almost any other language.
• Instant execution — No compilation step. Raw source code goes in, results come out. This is critical for sub-second agent workflows.

Pricing

Dynamic Workers follow a simple pricing model:

Standard Workers usage fees (CPU time, requests) still apply to both the parent Worker and each Dynamic Worker. But the Dynamic Worker creation cost itself is minimal — and free while the beta lasts.

Dynamic Workers vs Containers vs Lambda

Getting Started

The fastest path from zero to a running Dynamic Worker:

1. Make sure you are on the Workers Paid plan ($5/month)
2. Add "dynamic_workers": { "enabled": true } to your wrangler.jsonc
3. Import DynamicWorker from "cloudflare:workers" in your parent Worker
4. Call DynamicWorker.load(code) or DynamicWorker.get(id, callback)
5. Deploy with npx wrangler deploy

Full walkthrough: Dynamic Workers — Getting Started.

Related: AWS EC2 vs Cloudflare Workers Stack · Build a Full-Stack App on Cloudflare for Free · Cloudflare's Edge Security Paradigm · Why AWS Is So Slow