Cursor, an AI-powered code editor, opens up the underlying technology behind its programming agents to developers everywhere. The Cursor team has announced the public beta for the game Indicator SDK – The TypeScript library gives engineers programmatic access to the same runtime, tools, and templates that power the Cursor desktop application, CLI, and web interface.
This signals a tangible shift in how AI coding tools are positioned: not just as interactive assistants sitting alongside the developer, but as deployable infrastructure that organizations can plug 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 in front of a keyboard, the agent can now be called programmatically: from a CI/CD pipeline trigger, a backend service, or embedded directly within another product.
Think of it this way: Previously, you had to be “in” the indicator to use its agents. Now, you can call those same agents from anywhere in your cluster using a few lines of TypeScript.
Getting started is one thing:
From there, you can create Agent For example, send it a task, and send the response back – all in TypeScript. Here’s the simple example from the Cursor ad:
import { 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() Accepts contact apiKeyA model field (where you specify the form to run), or a local or cloud Configuration depending on where you want the execution to occur.
Why is creating your own proxy group difficult?
Before diving into what the SDK offers, it’s helpful to understand the problem it solves. Creating fast, reliable, and capable encoders that operate securely on your data requires purposeful engineering effort: secure sandboxing, state management, persistent session, environment setup, and context management. When a new model is released, development teams often have to completely rework their agent loops to take advantage of it. The Cursor SDK eliminates this complexity so teams can focus on building useful agents rather than maintaining the underlying infrastructure.
Proxy Harness: What “same runtime” actually means
The SDK agents use the same belt that powers Cursor’s own products. “Harness” here refers to the entire set of supporting infrastructure that makes the agent effective beyond just the LLM call itself. In the case of the indicator, Includes:
Intelligent context management – Code base indexing, semantic search, and instant grep so agents can retrieve the correct code context before generating responses. This is crucial because LLMs are only as good as the context they receive; Poor recall results in hallucinatory or irrelevant output.
MCP servers – Agents launched through the SDK can connect to external tools and data sources stdio Or HTTP, either via a file .cursor/mcp.json Configuration file or passed inline in the API call. MCP (Model Context Protocol) is an open standard for couplings in agent runtimes.
skills – Agents automatically capture reusable behavior definitions from a file .cursor/skills/ The directory is in the warehouse.
Hooks – A .cursor/hooks.json File lets you monitor, control, and scale the agent loop across cloud, self-hosted, and on-premises runtimes – useful for logging, guardrails, or custom orchestration.
Sub-agents – The master agent can delegate subtasks to specific subagents using their own prompts and forms Agent A tool that enables multi-agent workflows without custom orchestration code.
Cloud deployment: continuous, sandbox, and resumable
One of the most practical features of the SDK is cloud implementation. When configured to run in the Cursor cloud, each agent gets its own virtual machine with a robust sandbox, target repository replication, and a fully configured development environment. Most importantly, the agent continues to work even if the initiator’s device is offline – the developer can reconnect and broadcast the conversation later.
Cloud agents integrate with Cursor’s existing agents window and web application, so a programmatically started task can be inspected via the SDK or captured manually within the Cursor interface. When an agent is finished, it can open a PR, push a branch, or attach demos and screenshots – making it suitable for asynchronous and unattended workflows:
const 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 development teams with security requirements, the SDK also supports self-hosted workers, where code and tool execution remain within the organization’s network.
Flexibility of model and composer 2
The SDK displays every model supported in Cursor. Toggle forms is to change one field in model parameter, allowing teams to target tasks to the best model for a given combination of cost and capacity. Private cursor Composer 2 – It is described as a specialized cryptographic model that achieves frontier-level performance at a fraction of the cost of general-purpose models – and is positioned as the default recommendation for most cryptographic agent tasks.
Never
To accelerate adoption, Cursor published a public cookbook repository on GitHub with four prototype projects: a minimal quickstart (a Node.js example that creates a local agent, sends a single prompt, and broadcasts the response), a web-based prototyping tool to support new projects in an isolated cloud environment, an agent-backed kanban board that automatically opens PRs when engineers pull a ticket, and a lightweight CLI coding agent to create cursor agents from the terminal.
The indicator also released a Indicator SDK plugin in the Cursor Marketplace to help developers start building directly from within the editor.
Key takeaways
- The Cursor SDK is now in public beta – Cursor released TypeScript SDK (
npm install @cursor/sdk) which gives developers programmatic access to the same runtime, tools, and templates that power the Cursor desktop application, CLI, and web interface. - Removes hard parts from building coding proxies – Teams no longer need to design secure sandboxing, state and session management, environment setup, and context management from scratch – nor will they need to rework proxy loops every time a new model ships.
- The indicator works locally or on the cloud – Agents can execute on a developer’s own local machine for rapid iteration, on the Cursor cloud against a dedicated VM with robust sandboxing, or on self-hosted workers for teams with stringent network security requirements.
- Complete belt included out of the box – The SDK agents inherit the entire infrastructure of Cursor: intelligent context management (code base indexing, semantic search, instant grep), MCP server support, skills, hooks, and sub-agents – the same stack that powers Cursor’s own products.
verify Cookbook and Technical details. Also, feel free to follow us on twitter Don’t forget to join us 130k+ ml SubReddit And subscribe to Our newsletter. I am waiting! Are you on telegram? Now you can join us on Telegram too.
Do you need to partner with us to promote your GitHub Repo page, face hug page, product release, webinar, etc.? Contact us
