Agent code mode
Executing short programs written by an LLM against a narrow typed API instead of exposing dozens of individual tool calls.
Independent tool overview
Dynamic Workers at a glance
Cloudflare Dynamic Workers is an open-beta runtime primitive for loading code at request time into lightweight V8 isolate sandboxes. It gives developers control over bindings, outbound network access, resource limits and logs, making it useful for AI agent code mode, generated apps and user-supplied automations—but it is infrastructure, not a ready-made agent product.
Visit the official Dynamic Workers site ↗
- Current status
- Open beta and available to Workers Paid users
- Runtime
- Cloudflare Workers built on V8 isolates
- Supported code
- JavaScript, Python and WebAssembly modules
- Loading modes
- One-off `load()` or reusable `get(id, callback)`
- Base plan
- Workers Paid starts at $5 per account per month
- Dynamic Worker overage
- $0.002 per unique Dynamic Worker per day after inclusion
Overview
What Dynamic Workers is
A parent Cloudflare Worker uses the Worker Loader API to create a Dynamic Worker from code supplied at runtime. The `load()` mode creates a one-off sandbox, while `get(id, callback)` can reuse the same code under a stable ID across requests. Supported module types include JavaScript, Python and WebAssembly; TypeScript and npm dependencies must be compiled or bundled first.
The key security model is capability-based composition. The parent decides which bindings and RPC stubs the child receives, can block or intercept outbound network access, attaches observability through Tail Workers and can enforce custom CPU or subrequest limits. Durable Object Facets can add isolated SQLite-backed state when a sandbox needs persistence.
Cloudflare markets isolates as roughly 100 times faster to start and 10-to-100 times more memory efficient than typical containers. Those are architecture-level vendor comparisons, not a guarantee for every application. Isolates also have a different security and compatibility profile from hardware-isolated virtual machines, so the correct choice depends on the threat model and workload.
Use cases
Who Dynamic Workers is best for
The strongest fit depends on the job you need the product to complete, not the size of its feature list.
Generated app platforms
Running previews, prototypes and user-generated applications on demand with explicit bindings, egress rules and resource controls.
High-volume lightweight sandboxes
Workloads that need millisecond-scale startup and broad geographic placement without the full operating-system environment of a container.
Capabilities
Core Dynamic Workers features
Runtime code loading
Creates a new Worker from modules and configuration assembled dynamically by a parent Worker.
One-off or reusable workers
Uses `load()` for fresh execution or stable IDs with `get()` to reuse matching code and reduce repeated creation charges.
Capability-scoped bindings
Passes only the RPC services, data and platform bindings a sandbox should be allowed to use.
Egress control
Blocks all Internet access or intercepts outbound requests through a handler that can enforce host, method and path policy.
Resource controls
Applies custom CPU and subrequest limits to constrain runaway or abusive generated code.
Observability
Attaches Tail Workers to capture execution logs and events for individual Dynamic Worker runs.
Bundling and virtual files
Cloudflare publishes packages for resolving npm dependencies, bundling TypeScript and giving agents a persistent virtual file workspace.
Process
How the Dynamic Workers workflow works
Step 1
Define the threat model
Classify who supplies the code, what data it can see, the damage it could cause and whether isolate-based separation is sufficient for the risk.
Step 2
Create a parent Worker
Add a Worker Loader binding and keep code retrieval, authentication, policy and billing controls outside the dynamic sandbox.
Step 3
Expose minimal capabilities
Pass narrow RPC stubs rather than raw credentials or broad account bindings; validate every argument again at the capability boundary.
Step 4
Deny outbound access by default
Set `globalOutbound` to null unless the workload needs networking, then implement an explicit allowlist and protect against SSRF, redirects and DNS-based bypasses.
Step 5
Set resource and creation limits
Cap CPU and subrequests, use stable IDs where code is intentionally reusable and add application-level rate limits and budget alarms.
Step 6
Test hostile and broken code
Exercise infinite loops, excessive allocations, dependency attacks, prompt injection, secret exfiltration attempts and malformed outputs before production.
Step 7
Observe without leaking secrets
Capture execution events and cost metrics while redacting credentials, personal data and confidential payloads from logs.
Cost
Dynamic Workers pricing and free plan
Dynamic Workers requires the $5-per-month Workers Paid plan. That account plan includes 1,000 unique Dynamic Workers per month, 10 million requests and 30 million CPU milliseconds. Additional usage is billed across worker creation, requests and CPU time. Enterprise contracts may differ.
Workers Paid with Dynamic Workers
$5/month minimum plus usage
The required self-serve Cloudflare account plan with monthly included usage.
- 1,000 unique Dynamic Workers included per month
- 10 million requests included per month
- 30 million CPU milliseconds included per month
- No separate egress bandwidth charge under Workers Standard pricing
Additional Dynamic Workers usage
Usage-based
Charges apply after the account's included monthly amounts.
- $0.002 per unique Dynamic Worker per day
- $0.30 per additional million requests
- $0.02 per additional million CPU milliseconds
- Startup CPU and execution CPU are both billable for Dynamic Workers
Workers Enterprise
Contract pricing
Enterprise accounts are billed according to their contracted Workers usage model.
- Confirm Dynamic Workers availability and rates with the account team
- Contract controls and support can differ from self-serve Workers Paid
Pricing checked . Check current pricing at the source ↗
Assessment
Dynamic Workers strengths and limitations
Where it stands out
- Starts lightweight sandboxes in milliseconds, making per-request code execution practical for some workloads.
- Lets the parent Worker define exactly which bindings, RPC services and network routes child code can access.
- Supports one-off execution and stable-ID reuse in the same primitive.
- Runs across Cloudflare's global Workers footprint and uses standard Workers request and CPU accounting.
- Includes official starter, playground, code-mode SDK, bundler and virtual-filesystem building blocks.
- Published pricing makes the creation, request and CPU cost dimensions visible before adoption.
What to consider
- Dynamic Workers is an open-beta developer primitive, so APIs, limits, pricing and production behavior may change.
- It is not a hosted coding agent, model, orchestration UI or turnkey sandbox service; developers must build the parent application, policy and evaluation layer.
- Isolate sandboxes do not provide the same kernel and hardware boundary as a microVM. Cloudflare describes substantial defense-in-depth, but high-consequence hostile-code workloads still require an explicit security review.
- The current platform limit is four distinct Dynamic Workers with in-flight requests per Worker request, or ten across concurrent requests to the same Durable Object.
- JavaScript is the natural fast path. Python requires a compatibility flag, WebAssembly must be compiled, and TypeScript or npm dependencies require pre-bundling.
- A raw `load()` without a stable ID counts each invocation as a distinct Dynamic Worker for billing, which can create unexpected costs at high volume.
- Passing broad bindings, secrets or unrestricted network access can defeat the intended sandbox boundary and enable data exfiltration or destructive actions.
- Runtime bundling introduces package-registry and dependency supply-chain risk; pin, validate and restrict what generated code may import.
- The quoted 100x startup and memory comparisons come from Cloudflare's blog and are not an application-specific performance guarantee.
Compare
Dynamic Workers alternatives
The right alternative depends on the specific output, workflow, controls and budget your project requires.
Agents
Agent Builder
A higher-level visual system for composing and versioning multi-agent workflows when the goal is orchestration rather than hosting arbitrary runtime code.
Explore Agent Builder →Coding
Code Arena
An evaluation-oriented product for testing coding models in isolated environments rather than embedding a low-level sandbox in an application.
Explore Code Arena →Coding
Antigravity
A full agentic development environment for people who want coding agents and parallel workspaces instead of building their own execution platform.
Explore Antigravity →Questions
Dynamic Workers FAQs
What are Cloudflare Dynamic Workers?
They are Cloudflare Workers created from code and configuration supplied at runtime by another Worker. Each runs in a V8 isolate sandbox with developer-controlled bindings, network access and limits.
Are Dynamic Workers generally available?
No. Cloudflare describes the Worker Loader feature as open beta. It was available to Workers Paid users when reviewed on August 31, 2026.
How much do Dynamic Workers cost?
They require Workers Paid, which has a $5 monthly account minimum. The plan includes 1,000 unique Dynamic Workers per month, 10 million requests and 30 million CPU milliseconds; overages are $0.002 per unique Worker per day, $0.30 per million requests and $0.02 per million CPU milliseconds.
What is the difference between `load()` and `get()`?
`load()` creates a fresh Dynamic Worker for one-time execution. `get(id, callback)` uses a stable ID so matching code can remain warm and be reused, which also avoids counting every invocation as a new creation.
Which languages can Dynamic Workers run?
The current docs list JavaScript, Python and WebAssembly modules. TypeScript must be compiled to JavaScript, and Cloudflare's worker-bundler can resolve npm dependencies and package code before loading it.
Can Dynamic Workers access the Internet?
Only as configured by the parent. Developers can block outbound access entirely, pass a custom egress handler or permit the default network behavior. Default-deny is the safer starting point for untrusted code.
Are Dynamic Workers as isolated as containers or virtual machines?
No sandbox is risk-free, and V8 isolates use a different boundary from containers and microVMs. Cloudflare publishes multiple defense layers, but teams should match the isolation mechanism to the sensitivity and hostility of the workload.
What can developers build with Dynamic Workers?
Common patterns include AI agent code mode, generated application previews, user-uploaded apps, custom runtime automations and low-latency disposable code sandboxes.
Bottom line
Our Dynamic Workers verdict
Dynamic Workers is a compelling low-level option when an application needs thousands of fast, capability-scoped code sandboxes and already fits the Cloudflare Workers model. Its pricing is transparent and the security controls are thoughtfully placed at the parent-child boundary. The tradeoff is responsibility: open beta status, isolate-specific risk, bundling, egress, observability and billing behavior all demand production engineering that a turnkey sandbox product would otherwise absorb.
Visit Dynamic Workers website ↗Similar Agents Tools
View all Agents AI tools →
NemoClaw
NemoClaw - Nvidia's open-source security and privacy layer for OpenClaw autonomous agents
MolmoWeb
MolmoWeb - Ai2's open-source web browsing agent that navigates sites using screenshots
My Computer
My Computer - Manus' new desktop app bringing its AI agent to your local machine
Holo 3
Holo 3 - H Company's open-weight computer-use agent that navigates enterprise desktops with SOTA accuracy on 10B active params
AI training for the future of work.
Get access to all our AI courses, hundreds of real-world AI use cases, live expert-led workshops, an exclusive network of AI early adopters, and more.
AI Courses
Get unlimited access to all of our current & upcoming industry-specific AI courses for the duration of your subscription.
Daily Guides
To keep up with the rapid pace of AI, our team publishes AI implementation guides daily. Our library contains 300+ practical use cases to automate real-world work.
Workshops
Join weekly, live, interactive sessions with industry leaders who are at the forefront of AI for hands-on implementation guidance and exclusive insights.
Community
Network with an exclusive community of AI-first professionals who are working smarter with AI. Learn how early adopters are using AI in their work and businesses.