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- 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
How to use agents-sdk
- 1.Install the agents package: npm install agents
- 2.Configure wrangler.jsonc with durable_objects bindings and migrations
- 3.Define your Agent class extending Agent<Env, State>
- 4.Set initialState and implement validateStateChange for state management
- 5.Add @callable() methods for RPC endpoints
- 6.Use routeAgentRequest to handle incoming requests
- 7.For chat agents, extend AIChatAgent and configure tools and streaming
- 8.Deploy with wrangler deploy
Use cases
- 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
- 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
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.
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.
Yes. Follow the 'Add to existing project' guide in the Cloudflare docs to install into an existing Workers app without starting from scratch.
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.
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/
| Topic | Docs URL | Use for |
|---|---|---|
| Getting started | Quick start | First agent, project setup |
| Adding to existing project | Add to existing project | Install into existing Workers app |
| Configuration | Configuration | wrangler.jsonc, bindings, assets, deployment |
| Agent class | Agents API | Agent lifecycle, patterns, pitfalls |
| State | Store and sync state | setState, validateStateChange, persistence |
| Routing | Routing | URL patterns, routeAgentRequest |
| Callable methods | Callable methods | @callable, RPC, streaming, timeouts |
| Scheduling | Schedule tasks | schedule(), scheduleEvery(), cron |
| Workflows | Run workflows | AgentWorkflow, durable multi-step tasks |
| HTTP/WebSockets | WebSockets | Lifecycle hooks, hibernation |
| Chat agents | Chat agents | AIChatAgent, streaming, tools, persistence |
| Client SDK | Client SDK | useAgent, useAgentChat, React hooks |
| Client tools | Client tools | Client-side tools, autoContinueAfterToolResult |
| Server-driven messages | Trigger patterns | saveMessages, waitUntilStable, server-initiated turns |
| Resumable streaming | Resumable streaming | Stream recovery on disconnect |
| Email routing, secure reply resolver | ||
| MCP client | MCP client | Connecting to MCP servers |
| MCP server | MCP server | Building MCP servers with McpAgent |
| MCP transports | MCP transports | Streamable HTTP, SSE, RPC transport options |
| Securing MCP servers | Securing MCP | OAuth, proxy MCP, hardening |
| Human-in-the-loop | Human-in-the-loop | Approval flows, needsApproval, workflows |
| Durable execution | Durable execution | runFiber(), stash(), surviving DO eviction |
| Queue | Queue | Built-in FIFO queue, queue() |
| Retries | Retries | this.retry(), backoff/jitter |
| Observability | Observability | Diagnostics-channel events |
| Push notifications | Push notifications | Web Push + VAPID from agents |
| Webhooks | Webhooks | Receiving external webhooks |
| Cross-domain auth | Cross-domain auth | WebSocket auth, tokens, CORS |
| Readonly connections | Readonly | shouldConnectionBeReadonly |
| Voice | Voice | Experimental STT/TTS, withVoice |
| Browse the web | Browser tools | Experimental CDP browser automation |
| Think | Think | Experimental higher-level chat agent class |
| Migrations | AI SDK v5, AI SDK v6 | Upgrading @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 execution —
runFiber()/stash()for work that survives DO eviction - Queue — Built-in FIFO queue with retries via
queue() - Retries —
this.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 chat —
AIChatAgentwith resumable streams, message persistence, tools - Server-driven messages —
saveMessages,waitUntilStablefor proactive agent turns - React hooks —
useAgent,useAgentChatfor client apps - Observability —
diagnostics_channelevents 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
experimentalDecoratorsin 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}:
| Class | URL |
|---|---|
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
| Task | API |
|---|---|
| Read state | this.state.count |
| Write state | this.setState({ count: 1 }) |
| SQL query | this.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 workflow | await this.runWorkflow("ProcessingWorkflow", params) |
| Durable fiber | await this.runFiber("name", async (ctx) => { ... }) |
| Enqueue work | this.queue("handler", payload) |
| Retry with backoff | await this.retry(fn, { maxAttempts: 5 }) |
| Broadcast to clients | this.broadcast(message) |
| Get connections | this.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
- references/state-scheduling.md — State persistence, scheduling, SQL
- references/callable.md — RPC methods, streaming, timeouts
- references/routing.md — URL patterns, custom routing,
getAgentByName - references/configuration.md — Wrangler config, bindings, Vite setup
Chat & Streaming
- references/streaming-chat.md — AIChatAgent, resumable streams, tools
- references/client-sdk.md —
useAgent,useAgentChat,AgentClient - references/server-driven-messages.md — Trigger patterns,
saveMessages - references/human-in-the-loop.md — Approval flows,
needsApproval
Background Processing
- references/workflows.md — Durable Workflows integration
- references/durable-execution.md —
runFiber,stash, surviving eviction - references/queue-retries.md — Built-in queue, retry with backoff
Integrations
- references/mcp.md — MCP client and server, transports, securing
- references/email.md — Email routing and handling
- references/webhooks-push.md — Webhooks, push notifications
- references/observability.md — Diagnostics-channel events
Experimental
- references/think.md —
@cloudflare/thinkhigher-level chat agent - references/voice.md —
@cloudflare/voiceSTT/TTS - references/codemode.md — Code Mode for tool orchestration
- references/browse-the-web.md — CDP browser tools
Related skills
More from cloudflare/skills and the wider catalog.
cloudflare
Comprehensive Cloudflare platform skill for Workers, Pages, storage, AI, networking, security, and infrastructure-as-code.
wrangler
Cloudflare Workers CLI for deploying and managing serverless functions, KV, R2, D1, AI, and more.
workers-best-practices
Reviews and authors Cloudflare Workers code against production best practices.
web-perf
Analyzes web performance metrics and identifies optimization opportunities using Chrome DevTools.
durable-objects
Create and manage Cloudflare Durable Objects for stateful, coordinated edge applications.
sandbox-sdk
Build secure, isolated code execution environments on Cloudflare Workers.