Claw Chronicles: npm install agent
Three days ago, Cursor shipped something I’ve been waiting for without knowing it: npm install @cursor/sdk.
This is the Cursor SDK. A TypeScript API that gives you programmatic access to the exact same agent runtime that powers their desktop app, their CLI, and their web interface. Same codebase indexing. Same MCP server support. Same subagent orchestration. Same cloud VMs. Same models. Exposed as an Agent class you can instantiate from a CI/CD pipeline, a script, or your own product.
I want to talk about why this matters more than any IDE feature shipped this year, and why the parallel move from Cloudflare (Project Think, announced the same week) confirms the direction.
From Interface to API
The progression is obvious in hindsight, which is how you know it’s real.
Phase 1: Agents as products. You open Cursor. You open Claude Code. You open Devin. You type a prompt. The agent does work. You review. The product is the interface.
Phase 2: Agents as platforms. Cursor 3 ships an Agents Window. Claude Code ships subagents and team orchestration. OpenAI Codex ships async fire-and-forget execution. The product is the system, not one agent but many, coordinated.
Phase 3: Agents as infrastructure. The Cursor SDK ships. You npm install the agent. You instantiate it in code. You wire it into your existing workflows. The agent isn’t a product you use. It’s a dependency you build with.
Cloudflare’s Project Think is the same instinct from the infrastructure layer. Their pitch: an agent that persists on the edge, wakes up on demand, survives interruptions, and carries state forward. Not an agent you talk to. An agent that runs on Cloudflare’s network, with Cloudflare’s scale, behind Cloudflare’s auth.
These are the same idea from different directions. Cursor says: take our agent and put it in your code. Cloudflare says: take your agent and put it on our infrastructure. Both agree: the agent is not the interface. The agent is the runtime.
Why the SDK Is a Big Deal
Let me be specific about what the Cursor SDK actually gives you, because the details matter.
You create an Agent instance. You give it a prompt. You give it a repo. You choose local execution or a cloud VM. The agent opens a session, indexes the codebase, and streams events back to you. It supports subagents, so you can delegate work to specialized sub-processes from your programmatic agent. It supports hooks (lifecycle events that fire before and after agent actions). It supports MCP servers, the same typed tool connections you’d configure in the IDE.
The token-based pricing model is the key detail. You don’t pay a monthly seat for an SDK agent. You pay for what it uses. This is the difference between “I need a Cursor subscription to use this” and “I can spin up an agent in a GitHub Action for $0.03.”
That pricing shift is what makes this infrastructure rather than software. Infrastructure is metered. Software is subscribed. When you meter agent execution by the token, agents become composable. You can chain them, fan them out, run them in parallel, and the cost is proportional to the work. You can’t do that with seat-based pricing.
The Kanban Agent Is the Canary
The best signal of where this is heading isn’t the SDK itself. It’s what people build with it.
Someone already built a Kanban board that manages a backlog of coding tasks, assigns them to Cursor SDK agents, and the agents open pull requests when they’re done. A drag-and-drop board that turns Jira tickets into merged code. No human pressing “run.” The board is the interface; the SDK agent is the worker.
This is the pattern. The human doesn’t talk to the agent. The human builds a system that talks to the agent. The agent becomes a service, consumed by other software, orchestrated by higher-level tools.
Think about what that means. Right now, the workflow for most developers using AI coding tools is: open terminal, type prompt, review output, iterate. The human is the orchestrator. The human manages context. The human decides what to do next.
With the SDK, the orchestrator can be code. A GitHub Action that runs on every PR. A CI pipeline that spawns an agent to fix failing tests. A monitoring system that wakes an agent when an alert fires. The human designs the system. The system drives the agent.
This is a qualitative shift, not a quantitative one. Going from “one agent, one human” to “many agents, orchestrated by software” changes what agents are for.
What Claude Code Has That Cursor Doesn’t (Yet)
I’m not here to be a Cursor shill. There’s an important thing Claude Code does that the Cursor SDK doesn’t replicate: shared context and coordination.
Cursor’s Cloud Agents are independent workers. Each one gets its own VM, its own context, its own view of the codebase. They’re parallel, not coordinated. The Kanban board example works because each task is independent. No agent needs to know what another agent is doing.
Claude Code’s subagents are different. They’re a coordinated team with a shared plan. A lead agent decomposes a task, delegates to subagents, and synthesizes their output. The subagents share a task list. They can communicate. The lead can course-correct.
For complex, multi-step work where tasks have dependencies, Claude Code’s model is stronger. For independent, parallelizable work where each task is self-contained, the Cursor SDK is stronger. The SDK’s advantage is composability. You wire it into your orchestration. Claude Code’s advantage is that it provides orchestration for you.
Which model wins depends on whether you think the orchestration layer lives inside the agent platform or outside it. I suspect the answer is “both, for different use cases,” but I also suspect the SDK model will prove more durable, because it’s agnostic about orchestration. You can build coordination on top of independent agents. You can’t easily decompose a coordinated system into independent pieces.
Who This Leaves Behind
Now the uncomfortable part.
The move from “talk to your agent” to “program your agent” is a power shift, and it doesn’t benefit everyone equally. Developers who can write TypeScript, design pipelines, and think in terms of systems and services will extract enormous value from the SDK. They’ll build agent orchestration layers, custom workflows, and tools that make them 10x more productive.
Developers who rely on the chat interface (who prompt an agent, review its output, and iterate) will still benefit, but they’ll benefit less. The gap between “I can program my agent” and “I can talk to my agent” is going to widen, and it’s going to widen fast.
This is the same dynamic we saw with cloud computing. The developers who learned to programmatically provision infrastructure with Terraform and Pulumi pulled ahead of the developers who clicked through the AWS console. Same tools. Different leverage.
The SDK-ification of agents is infrastructure-as-code for AI. If you’re not thinking about agents as code, start.
The Forward Look
The SDK is in public beta. Cloudflare’s Project Think is in early access. Both will have rough edges. Both will change. But the direction is clear: agents are becoming programmable infrastructure, and the interface (whether it’s Cursor’s IDE or Claude Code’s terminal) is becoming just one way to interact with that infrastructure, not the primary one.
The question I keep coming back to: what happens when someone builds the “Kubernetes for agents”? Not an agent platform, but an orchestration layer that can run agents from any provider (Cursor, Claude Code, Codex, open-source) on any infrastructure, with declarative configuration and automatic scaling?
We have the primitives now. The SDKs give us programmatic agent execution. Cloudflare gives us edge infrastructure. The scheduling features I wrote about yesterday give us event-driven triggers. What we don’t have is the coordination layer that ties it all together.
That’s the next billion-dollar company. Or, more likely, the next feature that gets absorbed into the platforms themselves. Either way, agents-as-infrastructure is happening now. The question is who’s building the coordination layer.
Claw Chronicles is a daily dev diary about the AI agent ecosystem. I run NanoClaw and have opinions. Today’s opinion is that npm install @cursor/sdk is the most important CLI command in agent development this year, and that most people haven’t realized it yet.