Cursor, the AI-powered code editor, is opening up the core technology behind its coding agents to developers everywhere. The Cursor team announced the public beta of the Cursor SDK — a TypeScript library that gives engineers programmatic access to the same runtime, harness, and models that power Cursor’s desktop app, CLI, and web interface.
This signals a meaningful shift in how AI coding tools are being positioned: not just as interactive assistants sitting alongside a developer, but as deployable infrastructure that organizations can wire into their existing systems.
From Interactive Tool to Programmable Infrastructure
If you’ve used Cursor before, you know it as an IDE where you interact with an agent in real time — asking it to write functions, fix bugs, or explain code. The Cursor SDK changes the access model. Instead of a developer sitting at a keyboard, the agent can now be invoked programmatically: from a CI/CD pipeline trigger, a backend service, or embedded directly inside another product.
Think of it this way: previously, you had to be “in” Cursor to use its agents. Now, you can call those same agents from anywhere in your stack with a few lines of TypeScript.
Getting started is a single command:
Copy CodeCopiedUse a different Browsernpm install @cursor/sdk
From there, you create an Agent instance, send it a task, and stream the response back — all in TypeScript. Here’s the minimal example from Cursor’s announcement:
Copy CodeCopiedUse a different Browserimport { Agent } from “@cursor/sdk”;
const agent = await Agent.create({
apiKey: process.env.CURSOR_API_KEY!,
model: { id: “composer-2” },
local: { cwd: process.cwd() },
});
const run = await agent.send(“Summarize what this repository does”);
for await (const event of run.stream()) {
console.log(event);
}
The Agent.create() call accepts an apiKey, a model field (where you specify which model to run), and either a local or cloud configuration depending on where you want execution to happen.
Why Building Your Own Agent Stack is Hard
Before diving into what the SDK offers, it’s worth understanding the problem it solves. Building fast, reliable, and capable coding agents that run safely against your data requires meaningful engineering effort: secure sandboxing, durable state and session management, environment setup, and context management. And when a new model ships, dev teams often have to rework their agent loops entirely just to take advantage of it. The Cursor SDK eliminates this complexity so teams can focus on building useful agents instead of maintaining the underlying infrastructure.
https://cursor.com/blog/typescript-sdk
The Agent Harness: What “Same Runtime” Actually Means
SDK agents use the same harness that powers Cursor’s own products. ‘Harness’ here refers to the full set of supporting infrastructure that makes an agent effective beyond just the LLM call itself. In Cursor’s case, that includes:
Intelligent context management — Codebase indexing, semantic search, and instant grep so agents retrieve the right code context before generating responses. This is critical because LLMs are only as good as the context they receive; poor retrieval leads to hallucinated or irrelevant outputs.
MCP servers — Agents launched through the SDK can connect to external tools and data sources over stdio or HTTP, either via a .cursor/mcp.json config file or passed inline in the API call. MCP (Model Context Protocol) is an open standard for wiring tools into agent runtimes.
Skills — Agents automatically pick up reusable behavior definitions from a .cursor/skills/ directory in the repository.
Hooks — A .cursor/hooks.json file lets you observe, control, and extend the agent loop across cloud, self-hosted, and local runtimes — useful for logging, guardrails, or custom orchestration.
Subagents — The main agent can delegate subtasks to named subagents with their own prompts and models via the Agent tool, enabling multi-agent workflows without custom orchestration code.
Cloud Deployment: Persistent, Sandboxed, and Resumable
One of the more practical features of the SDK is cloud execution. When configured to run in Cursor’s cloud, each agent gets its own dedicated VM with strong sandboxing, a clone of the target repository, and a fully configured development environment. Critically, the agent keeps running even if the initiating machine goes offline — the developer can reconnect and stream the conversation later.
Cloud agents integrate with Cursor’s existing Agents Window and web app, so a task started programmatically via the SDK can be inspected or taken over manually inside the Cursor interface. When the agent finishes, it can open a PR, push a branch, or attach demos and screenshots — making them suitable for asynchronous, unattended workflows:
Copy CodeCopiedUse a different Browserconst agent = await Agent.create({
apiKey: process.env.CURSOR_API_KEY!,
model: { id: “gpt-5.5” },
cloud: {
repos: [{ url: “https://github.com/cursor/cookbook”, startingRef: “main” }],
autoCreatePR: true,
},
});
const run = await agent.send(“Fix the auth token expiry bug”);
console.log(`Started ${run.id}`);
// …check back in later, from anywhere:
const result = await (
await Agent.getRun(run.id, { runtime: “cloud”, agentId: run.agentId })
).wait();
console.log(result.git?.branches[0]?.prUrl);
For dev teams with security requirements, the SDK also supports self-hosted workers, where both code and tool execution remain inside the organization’s own network.
Model Flexibility and Composer 2
The SDK exposes every model supported in Cursor. Switching models is a single field change in the model parameter, letting teams route tasks to the best model for a given combination of cost and capability. Cursor’s own Composer 2 — described as a specialized coding model achieving frontier-level performance at a fraction of the cost of general-purpose models — is positioned as the default recommendation for most coding agent tasks.
Getting Started
To accelerate adoption, Cursor has published a public cookbook repository on GitHub with four starter projects: a minimal quickstart (a Node.js example that creates a local agent, sends one prompt, and streams the response), a web-based prototyping tool for scaffolding new projects in a sandboxed cloud environment, an agent-powered kanban board that automatically opens PRs when engineers drag a card, and a lightweight coding agent CLI for spawning Cursor agents from the terminal.
Cursor has also released a Cursor SDK plugin in the Cursor Marketplace to help developers start building directly from within the editor.
Key Takeaways
Cursor SDK is now in public beta — Cursor has released a TypeScript SDK (npm install @cursor/sdk) that gives developers programmatic access to the same runtime, harness, and models that power the Cursor desktop app, CLI, and web interface.
Eliminates the hard parts of building coding agents — Teams no longer need to engineer secure sandboxing, durable state and session management, environment setup, and context management from scratch — and won’t need to rework agent loops every time a new model ships.
Runs locally or on Cursor’s cloud — Agents can execute on a developer’s local machine for fast iteration, on Cursor’s cloud against a dedicated VM with strong sandboxing, or on self-hosted workers for teams with strict network security requirements.
Full harness included out of the box — SDK agents inherit Cursor’s complete infrastructure: intelligent context management (codebase indexing, semantic search, instant grep), MCP server support, Skills, Hooks, and Subagents — the same stack powering Cursor’s own products.
Check out the Cookbook and Technical details. Also, feel free to follow us on Twitter and don’t forget to join our 130k+ ML SubReddit and Subscribe to our Newsletter. Wait! are you on telegram? now you can join us on telegram as well.
Need to partner with us for promoting your GitHub Repo OR Hugging Face Page OR Product Release OR Webinar etc.? Connect with us
The post Cursor Introduces a TypeScript SDK for Building Programmatic Coding Agents With Sandboxed Cloud VMs, Subagents, Hooks, and Token-Based Pricing appeared first on MarkTechPost.