Cloudflare Agents Review

Cloudflare Agents is a developer platform for building and hosting stateful agents, not a subscription to a ready-made AI employee. The buying question is whether its durable runtime removes enough infrastructure work to justify adopting Cloudflare's execution model and several separate usage meters.[1][26]

What Cloudflare Agents actually includes#

The official Agents site belongs to Cloudflare. Its documentation describes four layers: communication channels, an agent harness, the Agents SDK runtime and tools. Chat, voice, email, Slack and webhooks are entry points. The runtime gives an agent a durable identity, SQL state, real-time connections, scheduling and recovery. Project Think supplies an opinionated harness, or a developer can build a different loop.[1]

This distinction matters: a model chooses what to do; the runtime stores state and executes work; your application defines what the agent is allowed to do. Cloudflare documents Browser, Sandbox, AI Search and MCP integrations, but listing them together is not a promise that every service is included in one flat fee.[1][2][3]

• Best for: developers who want a durable entity per user, conversation or task, with bursts of activity and long waits between events.[1][6]
• Also useful for: teams already comfortable with Workers, TypeScript and Cloudflare's deployment model, who value integrated storage and scheduling over a general-purpose VM.
• Avoid for: buyers expecting someone else to design tools, resolve authorization policy, validate outputs and operate the application.
• Compare carefully for: existing container or Python-heavy systems where moving the execution model creates more work than it removes. The runtime and SDK are not a drop-in replacement for an arbitrary process.[1][6]

Our self-hosted versus hosted agent responsibility guide helps separate infrastructure ownership from application ownership. Cloudflare can manage the former without taking responsibility for every decision made by your agent.

Pricing: the $5 minimum is only the starting point#

The published Workers Paid plan has a minimum charge of $5 per month per account. Standard Workers usage includes 10 million requests and 30 million CPU milliseconds per month; excess requests cost $0.30 per million and excess CPU time costs $0.02 per million milliseconds. That is Workers pricing, not the complete cost of an Agents application.[2]

Durable Objects use their own compute and storage meters. The retrieved pricing page lists these paid-plan allowances and overages:[3]

• Requests: 1 million per month included, then $0.15 per million.
• Duration: 400,000 GB-seconds per month included, then $12.50 per million GB-seconds.
• SQLite rows read: first 25 billion per month included, then $0.001 per million rows.
• SQLite rows written: first 50 million per month included, then $1 per million rows.
• SQL storage: 5 GB-month included, then $0.20 per GB-month.

Rounding is material for small overages. The documentation says excess usage in each dimension is rounded up to the next billable unit before its rate is applied. Its example rounds 500,000 excess GB-seconds to 1 million GB-seconds. Under that rule, an illustrative account with the $5 minimum and only that duration overage would owe $17.50 before other usage and tax. This is a calculated scenario, not a bill we received or a forecast for your workload.[2][3]

The free plan is real but limited: Durable Objects list 100,000 requests and 13,000 GB-seconds per day, 5 million SQLite row reads and 100,000 row writes per day, and 5 GB total storage. On Free, exceeding a limit causes further operations of that type to fail; daily quotas reset at 00:00 UTC. That is not an automatic unlimited production allowance.[3]

Costs to add before approving a budget#

1. Inference: record which model/provider each agent calls. A Cloudflare runtime allowance is not an unlimited Claude, OpenAI or Workers AI allowance.[1][26]
2. Optional services: itemize browser execution, sandbox compute, retrieval/search, storage outside the agent and other APIs separately. The product architecture composes these services; it does not turn them into one SKU.[1][26]
3. Retries and reconnects: measure requests, writes and object creation during interrupted sessions, not just the happy path.[7]
4. Persistent storage: data continues to incur storage billing until removed, even when the agent is not doing useful work.[3]
5. Engineering: budget for authentication, tenancy isolation, evaluations, migrations, monitoring and incident response. These are responsibilities in our proposed deployment budget, not Cloudflare price-list line items.

For a broader budgeting framework, see our agent cost calculator guide. Do not compare an infrastructure minimum with the retail price of a fully operated assistant.

The important limitation: durable is not always running#

Cloudflare's long-running-agent documentation is unusually explicit: an agent is a durable identity, not an always-on process. SQL data, persisted state, schedules and fiber checkpoints survive hibernation and restarts. In-memory variables, JavaScript timers, open fetch requests and local closures do not survive eviction.[6]

That makes it a strong architecture for resumable, event-driven work, provided the application actually persists what matters. It does not make every side effect transactional. If an external tool sends an email and the process stops before saving the result, your recovery logic still needs to know whether retrying will send another email. Use idempotency keys or an external operation record where the tool supports them; that is our engineering recommendation, not a tested guarantee.

The platform documents 10 GB storage per SQLite-backed Durable Object, a default 30-second active CPU limit configurable to five minutes, and six simultaneous outgoing connections per request. These constraints are different from total elapsed task time. Splitting work across durable steps is not the same thing as raising the CPU limit indefinitely.[4]

Idle compute and stored data are different bills#

The product site's CPU-time explanation refers to Workers. Durable Objects bill active wall-clock duration, including time idle in memory but unable to hibernate. Eligible hibernation avoids duration charges, but stored data has a separate meter. Ordinary WebSocket acceptance can keep an object billable; the pricing documentation recommends the WebSocket Hibernation API.[2][3][26]

Before approving a cost claim such as “almost free while waiting,” test the exact connection and lifecycle behavior. An LLM request in flight, a non-hibernating socket and a fully dormant agent are not interchangeable billing states.[3]

Cancellation, refunds and leaving the platform#

Cloudflare's cancellation documentation says changes take effect at the end of the current billing period, with paid access retained until then. Fees are non-refundable and unused time does not receive a refund under the stated policy. Billing dates are UTC; the documentation advises making changes at least 24 hours before the billing date.[5]

The dashboard path is Billing → Subscriptions → the relevant subscription → Cancel → Confirm. Some products require turning off the feature first; some cancellations use a switch to Free. Changing DNS does not cancel an account or active subscriptions. A website plan and Workers-related products should not be assumed to be the same subscription.[5]

A practical exit checklist:

• Export the state, SQL data and configuration you need before deleting resources.
• Inventory product subscriptions and external model accounts separately.
• Stop application traffic and recurring work deliberately rather than relying on a DNS change.
• Check the effective downgrade date and final usage charges in the account.
• If an old application uses key-value-backed Durable Object namespaces, investigate the documented requirement to remove them before a downgrade to Workers Free; do not delete production data without a backup and migration plan.[3]

We did not test cancellation or obtain a negotiated enterprise contract. Enterprise remedies and account-specific billing exceptions remain unverified; the public self-service policy is not a substitute for your signed terms.

Independent community evidence: a reconnect bill, not a benchmark#

In GitHub issue #1083, opened March 7, 2026, developer remorses described a free Framer MCP plugin and reported a $676 bill instead of an expected roughly $60. The original report blamed unexpected Durable Object storage. The follow-up is essential: the author later said repeated reconnects were creating a new Durable Object each time and that they switched to the MCP SDK directly as an immediate workaround.[7]

This is a named developer report, not an audited invoice, representative average or proof that today's SDK always has that failure. The discussion also raised using a simpler handler when state is unnecessary. The useful lesson is to justify each persistent session and inspect reconnect behavior before scaling, rather than automatically choosing the richest agent abstraction.[7]

We did not find a controlled, independent current-version performance comparison in the evidence reviewed. The issue establishes a concrete billing failure mode worth testing, not a population-wide reliability score. Our MCP versus API guide covers the separate question of whether a reusable MCP server is needed at all. For the personal-agent side of that comparison, the Hermes tool-use overview describes the application layer rather than a hosted SDK.

Current release check: pin versions and read migrations#

The GitHub release listing retrieved on October 4 showed agents@0.26.0, released October 2, updating pi-durable and pi-ai to ^1.0.0. The immediately preceding 0.25.0 release notes say native asynchronous RPC now starts lifecycle initialization first and that agents should be addressed by name: raw IDs from newUniqueId() or idFromString() fail their first asynchronous RPC.[8]

The same release notes list fixes for agent-tool chunks duplicated or dropped on reconnect, reattachment and fiber recovery. That is evidence of active maintenance, but also a reason to pin an SDK version and rerun recovery tests. An old tutorial using a different lifecycle API is not sufficient migration guidance.[8]

Paid-ad evidence: what we checked and what it cannot prove#

Our local September 22 advertiser export contains Cloudflare creative IDs, but labels them as Video/YouTube while leaving headlines and destinations empty. We did not treat that exporter classification as authoritative. On October 4, Google's public preview for creative CR17888994750158077953, under Cloudflare, Inc., reported Format: Text and Last shown: Oct 3, 2026.[27]

This corroborates a public advertising record, not spend, conversion rate, profitability or agent performance. We did not click through an ad, attribute customer outcomes to it, or conclude that every Cloudflare creative is advertising the Agents SDK specifically. The product verdict above rests on product documentation and scoped community evidence, not ad longevity.

Alternatives: choose the layer you actually need#

• A model and agent library rather than an edge runtime: the Claude for AI Agents review separates API access, a self-operated SDK and subscription entitlements. Claude and Cloudflare can be complementary layers, not mutually exclusive purchases.
• A visual workflow backbone: the n8n AI Agent Builder review is a better starting point when a repeatable business workflow matters more than implementing an application runtime.
• A personal agent you can operate yourself: our Hermes Agent review addresses a different ownership model. It should not be read as a claim of feature-for-feature equivalence with Cloudflare infrastructure.
• A hosted personal-agent experience: compare the managed option on our cloud guide if the real goal is using an assistant rather than building a multi-user product.

Before production: a proposed acceptance test#

These are tests we recommend, not tests we performed:

1. Use one read-only tool and one state-changing tool in a staging account with a small spend allowance.
2. Interrupt the agent before and after the external write. Confirm recovery does not duplicate the side effect.
3. Disconnect and reconnect clients repeatedly. Check that object identity, session rows and storage growth remain intentional.
4. Leave a connection idle. Compare actual duration and storage meters rather than assuming hibernation happened.
5. Trigger free-plan or configured resource limits. Verify the user sees a recoverable failure, not a falsely successful result.
6. Upgrade the pinned SDK in staging and repeat the same cases before production rollout.

Verdict: Cloudflare Agents is a credible developer infrastructure choice with well-documented state and recovery primitives. Its strongest appeal is durable, bursty application execution. Its main buying risk is confusing a $5 Workers minimum and hibernation savings with a predictable all-in agent bill. Evaluate the workload and exit path before committing; buyers who simply want an assistant should compare finished products instead.

Sources#

[1] https://developers.cloudflare.com/agents — Cloudflare Agents documentation [2] https://developers.cloudflare.com/workers/platform/pricing — Workers pricing [3] https://developers.cloudflare.com/durable-objects/platform/pricing — Durable Objects pricing [4] https://developers.cloudflare.com/durable-objects/platform/limits — Durable Objects limits [5] https://developers.cloudflare.com/billing/manage/cancel-subscription — Cloudflare cancellation and refunds [6] https://developers.cloudflare.com/agents/concepts/agentic-patterns/long-running-agents — Cloudflare long-running agents [7] https://github.com/cloudflare/agents/issues/1083 — Developer reconnect and billing report [8] https://github.com/cloudflare/agents/releases — Cloudflare Agents SDK releases [26] https://agents.cloudflare.com — Cloudflare Agents product page [27] https://adstransparency.google.com/advertiser/AR10379917531786772481/creative/CR17888994750158077953 — Cloudflare public ad preview