Cloudflare Agents SDK Hits 500K Weekly Downloads

Half a million developers every week are choosing a TypeScript-first, edge-native framework over traditional Python agent stacks — and that tells you where AI infrastructure is headed.

The Cloudflare Agents SDK hit 500,000 weekly downloads on npm. Not 500K total — 500K every single week, with 8.3 million total downloads since launch. The `agents` package (currently v0.9.0) is growing faster than most established frameworks, and it is doing it with a fundamentally different architecture.

Instead of running agents on long-lived servers that burn memory and money while idle, the Agents SDK runs each agent as a Durable Object on Cloudflare's edge network. That means zero cold starts, automatic proximity routing to the nearest data center, and hibernation when idle — you only pay for actual compute.

What Makes the Agents SDK Different

Most AI agent frameworks — LangChain, CrewAI, AutoGen — are Python libraries designed to run on traditional servers. They assume you have a long-running process, a database connection, and a server that stays on 24/7. The Agents SDK takes the opposite approach: every agent is a Durable Object with its own persistent state, its own SQLite database, and its own lifecycle.

How Agents Run on Cloudflare's Edge

The architecture is what sets this apart from every other agent framework. When a user connects to your agent, Cloudflare routes the request to the nearest edge location (out of 335+ data centers). The Durable Object that holds your agent's state is created in the region closest to the user — this is called proximity routing.

Once the Durable Object is active, it has:

• A single-threaded execution context — no race conditions, no locks, no distributed state bugs.
• Persistent storage — key-value pairs and a full SQLite database that survive across requests.
• WebSocket support — the agent can hold open connections with clients for real-time streaming.
• Hibernation — when no requests are active, the Durable Object hibernates. You stop paying. When the next request arrives, it wakes up with all state intact in milliseconds.

This is fundamentally different from running an agent on EC2 or a Kubernetes pod, where you pay for idle time and need to manage scaling yourself. AWS charges you whether your agent is thinking or sleeping.

Quick Start: 3 Commands

Getting a working agent deployed takes less than two minutes:

npm create cloudflare@latest -- --template agents
cd my-agents-project
npx wrangler deploy

That gives you a deployed agent with WebSocket support, state management, and a React frontend. No Docker, no infrastructure config, no database provisioning.

Code Example: A Minimal Agent

import { Agent } from "agents";

export class MyAgent extends Agent {
  // Called on every incoming message
  async onMessage(message: string) {
    // Access persistent state
    const count = (this.state.count || 0) + 1;
    this.setState({ count });

    // Reply to the client
    this.send(JSON.stringify({
      reply: "Message received",
      totalMessages: count
    }));
  }
}

Code Example: AI Chat Agent

import { AIChatAgent } from "agents/ai-chat-agent";
import { createOpenAI } from "@ai-sdk/openai";

export class ChatBot extends AIChatAgent {
  async onChatMessage(onFinish) {
    const openai = createOpenAI({
      apiKey: this.env.OPENAI_API_KEY,
    });

    return this.streamText({
      model: openai("gpt-4o"),
      system: "You are a helpful assistant.",
      messages: this.messages,
      tools: {
        getWeather: {
          description: "Get weather for a city",
          parameters: { city: { type: "string" } },
          execute: async ({ city }) => {
            return { temp: 22, condition: "sunny", city };
          },
        },
      },
      onFinish,
    });
  }
}

Code Example: React Client

import { useAgentChat } from "agents/react";

function Chat() {
  const { messages, input, handleInputChange, handleSubmit }
    = useAgentChat({ agent: "chat-bot" });

  return (
    <div>
      {messages.map((m) => (
        <div key={m.id}>
          <strong>{m.role}:</strong> {m.content}
        </div>
      ))}
      <form onSubmit={handleSubmit}>
        <input value={input} onChange={handleInputChange} />
        <button type="submit">Send</button>
      </form>
    </div>
  );
}

Agents SDK vs. Traditional Frameworks

The comparison is not Python-vs-TypeScript. It is stateless-vs-stateful, server-vs-edge, always-on-vs-hibernation.

The Full Cloudflare Agent Stack

The Agents SDK does not exist in isolation. It plugs into a complete serverless AI stack that Cloudflare has been building for years:

The key insight: all of these run on the same edge network. Your agent (Durable Object) can query D1 (SQLite), call Workers AI (LLM inference), trigger a Workflow (multi-step task), and search Vectorize (embeddings) — all without leaving Cloudflare's network. No cross-cloud latency, no API gateway hops, no egress fees.

Why 500K Developers Chose This

The adoption numbers are not accidental. Three things are driving it:

Managing Agent Data with MyD1

Agents built on the Cloudflare stack often use D1 for shared, queryable data — user profiles, conversation logs, analytics, tool outputs. The Durable Object's built-in SQLite is great for per-agent state, but when you need to query across agents or share data between services, D1 is the answer.

That is where MyD1 comes in. Instead of writing raw SQL in a terminal to inspect your agent's data, MyD1 gives you a native macOS interface to browse tables, run queries with autocomplete, and edit data inline. And MyD1's AI Agent helps you go further — ask it questions in plain English like "show me the 10 longest agent conversations this week" and it writes the SQL, optimizes the query, and surfaces insights you would never find without AI. Download MyD1 free.

What Is Next for the Agents SDK

The SDK is at v0.9.0, which means a 1.0 stable release is coming. Based on the public docs and Cloudflare's track record, expect:

• More model integrations — Workers AI already supports dozens of models including Kimi K2.5 and Llama 4, and the list grows monthly.
• Dynamic Workers — agents that can spawn and manage other Workers programmatically, enabling agent-to-agent coordination.
• Deeper MCP integration — the Model Context Protocol is becoming the standard for tool interoperability, and Cloudflare is investing heavily in it.

Related: EC2 vs Cloudflare Workers — Full Cost Comparison · Build a Full-Stack App on Cloudflare for Free · SQLite Can Handle Your Website · Why AWS Is So Slow