PluginBench
Skill
Official
Review
Audit score 70

agents-sdk

cloudflare/skills

Build stateful AI agents on Cloudflare Workers with persistent state, workflows, and real-time communication.

What is agents-sdk?

The Agents SDK enables you to create AI agents running on Cloudflare Workers with built-in state management, durable workflows, and WebSocket communication. Use it when building stateful agents, chat applications, scheduled tasks, MCP servers, voice agents, or browser automation tools.

  • Persistent SQLite-backed state with auto-sync to clients
  • Callable RPC methods invoked over WebSocket
  • Scheduling for one-time, recurring, and cron tasks
  • Durable multi-step workflows via AgentWorkflow
  • Built-in FIFO queue with retry support
  • MCP server integration and client connectivity

How to install agents-sdk

npx skills add https://github.com/cloudflare/skills --skill agents-sdk
Prerequisites
  • Node.js and npm installed
  • Cloudflare Workers account and wrangler CLI
  • TypeScript knowledge recommended
  • For chat agents: @cloudflare/ai-chat, ai, and @ai-sdk/react packages
Claude Code
Cursor
Windsurf
Cline

How to use agents-sdk

  1. 1.Install the agents package: npm install agents
  2. 2.Configure wrangler.jsonc with durable_objects bindings and migrations
  3. 3.Define your Agent class extending Agent<Env, State>
  4. 4.Set initialState and implement validateStateChange for state management
  5. 5.Add @callable() methods for RPC endpoints
  6. 6.Use routeAgentRequest to handle incoming requests
  7. 7.For chat agents, extend AIChatAgent and configure tools and streaming
  8. 8.Deploy with wrangler deploy

Use cases

Good for
  • Building a stateful chatbot that remembers conversation history and user preferences
  • Creating scheduled background tasks that process data at regular intervals
  • Implementing a multi-step workflow that coordinates between multiple agent steps
  • Connecting to external MCP servers to extend agent capabilities
  • Building a voice-enabled agent with speech-to-text and text-to-speech
Who it's for
  • Full-stack developers building AI applications on Cloudflare
  • Backend engineers implementing stateful agent systems
  • AI/ML engineers integrating LLMs with serverless infrastructure
  • Teams building chat applications with persistent conversation state
  • Developers creating scheduled automation and workflow systems

agents-sdk FAQ

When should I use Agents SDK vs. a regular Workers function?

Use Agents SDK when you need persistent state, durable workflows, scheduled tasks, or real-time WebSocket communication. For simple request-response APIs, regular Workers functions are sufficient.

How do I persist agent state across requests?

Use setState() to update state, which is backed by SQLite and auto-synced to clients. Implement validateStateChange to control state transitions and prevent invalid updates.

Can I use Agents SDK with existing Workers projects?

Yes. Follow the 'Add to existing project' guide in the Cloudflare docs to install into an existing Workers app without starting from scratch.

What's the difference between callable methods and regular endpoints?

Callable methods use @callable() decorator for RPC invocation over WebSocket with streaming support and timeouts. Regular endpoints are HTTP-based. Use callables for interactive, real-time communication.

How do I handle long-running tasks?

Use AgentWorkflow for durable multi-step tasks, runFiber() for work that survives Durable Object eviction, or queue() for FIFO task processing with built-in retries.

Full instructions (SKILL.md)

Source of truth, from cloudflare/skills.


name: agents-sdk description: Build AI agents on Cloudflare Workers using the Agents SDK. Load when creating stateful agents, durable workflows, real-time WebSocket apps, scheduled tasks, MCP servers, chat applications, voice agents, or browser automation. Covers Agent class, state management, callable RPC, Workflows, durable execution, queues, retries, observability, and React hooks. Biases towards retrieval from Cloudflare docs over pre-trained knowledge.

Cloudflare Agents SDK

Your knowledge of the Agents SDK may be outdated. Prefer retrieval over pre-training for any Agents SDK task.

Retrieval Sources

Cloudflare docs: https://developers.cloudflare.com/agents/

TopicDocs URLUse for
Getting startedQuick startFirst agent, project setup
Adding to existing projectAdd to existing projectInstall into existing Workers app
ConfigurationConfigurationwrangler.jsonc, bindings, assets, deployment
Agent classAgents APIAgent lifecycle, patterns, pitfalls
StateStore and sync statesetState, validateStateChange, persistence
RoutingRoutingURL patterns, routeAgentRequest
Callable methodsCallable methods@callable, RPC, streaming, timeouts
SchedulingSchedule tasksschedule(), scheduleEvery(), cron
WorkflowsRun workflowsAgentWorkflow, durable multi-step tasks
HTTP/WebSocketsWebSocketsLifecycle hooks, hibernation
Chat agentsChat agentsAIChatAgent, streaming, tools, persistence
Client SDKClient SDKuseAgent, useAgentChat, React hooks
Client toolsClient toolsClient-side tools, autoContinueAfterToolResult
Server-driven messagesTrigger patternssaveMessages, waitUntilStable, server-initiated turns
Resumable streamingResumable streamingStream recovery on disconnect
EmailEmailEmail routing, secure reply resolver
MCP clientMCP clientConnecting to MCP servers
MCP serverMCP serverBuilding MCP servers with McpAgent
MCP transportsMCP transportsStreamable HTTP, SSE, RPC transport options
Securing MCP serversSecuring MCPOAuth, proxy MCP, hardening
Human-in-the-loopHuman-in-the-loopApproval flows, needsApproval, workflows
Durable executionDurable executionrunFiber(), stash(), surviving DO eviction
QueueQueueBuilt-in FIFO queue, queue()
RetriesRetriesthis.retry(), backoff/jitter
ObservabilityObservabilityDiagnostics-channel events
Push notificationsPush notificationsWeb Push + VAPID from agents
WebhooksWebhooksReceiving external webhooks
Cross-domain authCross-domain authWebSocket auth, tokens, CORS
Readonly connectionsReadonlyshouldConnectionBeReadonly
VoiceVoiceExperimental STT/TTS, withVoice
Browse the webBrowser toolsExperimental CDP browser automation
ThinkThinkExperimental higher-level chat agent class
MigrationsAI SDK v5, AI SDK v6Upgrading @cloudflare/ai-chat

Capabilities

The Agents SDK provides:

  • Persistent state — SQLite-backed, auto-synced to clients via setState
  • Callable RPC@callable() methods invoked over WebSocket
  • Scheduling — One-time, recurring (scheduleEvery), and cron tasks
  • Workflows — Durable multi-step background processing via AgentWorkflow
  • Durable executionrunFiber() / stash() for work that survives DO eviction
  • Queue — Built-in FIFO queue with retries via queue()
  • Retriesthis.retry() with exponential backoff and jitter
  • MCP integration — Connect to MCP servers or build your own with McpAgent
  • Email handling — Receive and reply to emails with secure routing
  • Streaming chatAIChatAgent with resumable streams, message persistence, tools
  • Server-driven messagessaveMessages, waitUntilStable for proactive agent turns
  • React hooksuseAgent, useAgentChat for client apps
  • Observabilitydiagnostics_channel events for state, RPC, schedule, lifecycle
  • Push notifications — Web Push + VAPID delivery from agents
  • Webhooks — Receive and verify external webhooks
  • Voice (experimental) — STT/TTS via @cloudflare/voice
  • Browser tools (experimental) — CDP-powered browsing via agents/browser
  • Think (experimental) — Higher-level chat agent via @cloudflare/think

FIRST: Verify Installation

npm ls agents  # Should show agents package

If not installed:

npm install agents

For chat agents:

npm install agents @cloudflare/ai-chat ai @ai-sdk/react

Wrangler Configuration

{
  "compatibility_flags": ["nodejs_compat"],
  "durable_objects": {
    "bindings": [{ "name": "MyAgent", "class_name": "MyAgent" }]
  },
  "migrations": [{ "tag": "v1", "new_sqlite_classes": ["MyAgent"] }]
}

Gotchas:

  • Do NOT enable experimentalDecorators in tsconfig (breaks @callable)
  • Never edit old migrations — always add new tags
  • Each agent class needs its own DO binding + migration entry
  • Add "ai": { "binding": "AI" } for Workers AI

Agent Class

import { Agent, routeAgentRequest, callable } from "agents";

type State = { count: number };

export class Counter extends Agent<Env, State> {
  initialState = { count: 0 };

  validateStateChange(nextState: State, source: Connection | "server") {
    if (nextState.count < 0) throw new Error("Count cannot be negative");
  }

  onStateUpdate(state: State, source: Connection | "server") {
    console.log("State updated:", state);
  }

  @callable()
  increment() {
    this.setState({ count: this.state.count + 1 });
    return this.state.count;
  }
}

export default {
  fetch: (req, env) => routeAgentRequest(req, env) ?? new Response("Not found", { status: 404 })
};

Routing

Requests route to /agents/{agent-name}/{instance-name}:

ClassURL
Counter/agents/counter/user-123
ChatRoom/agents/chat-room/lobby

Client: useAgent({ agent: "Counter", name: "user-123" })

Custom routing: use getAgentByName(env.MyAgent, "instance-id") then agent.fetch(request).

Core APIs

TaskAPI
Read statethis.state.count
Write statethis.setState({ count: 1 })
SQL querythis.sql`SELECT * FROM users WHERE id = ${id}`
Schedule (delay)await this.schedule(60, "task", payload)
Schedule (cron)await this.schedule("0 * * * *", "task", payload)
Schedule (interval)await this.scheduleEvery(30, "poll")
RPC method@callable() myMethod() { ... }
Streaming RPC@callable({ streaming: true }) stream(res) { ... }
Start workflowawait this.runWorkflow("ProcessingWorkflow", params)
Durable fiberawait this.runFiber("name", async (ctx) => { ... })
Enqueue workthis.queue("handler", payload)
Retry with backoffawait this.retry(fn, { maxAttempts: 5 })
Broadcast to clientsthis.broadcast(message)
Get connectionsthis.getConnections(tag?)

React Client

import { useAgent } from "agents/react";

function App() {
  const [state, setLocalState] = useState({ count: 0 });

  const agent = useAgent({
    agent: "Counter",
    name: "my-instance",
    onStateUpdate: (newState) => setLocalState(newState),
    onIdentity: (name, agentType) => console.log(`Connected to ${name}`)
  });

  return (
    <button onClick={() => agent.setState({ count: state.count + 1 })}>
      Count: {state.count}
    </button>
  );
}

References

Core

Chat & Streaming

Background Processing

Integrations

Experimental