Short answer: Cursor’s current model documentation lists Composer 2.5 (model ID composer-2.5). Cursor documents programmatic agent workflows through its TypeScript SDK, and its SDK example explicitly selects Composer 2.5. That is an agent interface—not a raw model-inference or chat-completions API. The SDK requires a Cursor API key; its agent sends a prompt and exposes run results and streamed events. (Cursor TypeScript SDK)
What is the Cursor Composer model?
“Composer” is a model family, so the version matters. Cursor’s current model documentation describes Composer 2.5 as a model for agentic coding; the listed model ID is composer-2.5 and the documented context window is 200k. Cursor describes the model as suited to longer coding tasks and tool use. These are product descriptions, not independent comparative results. (Composer 2.5 model documentation)
Older reports about Composer 1 should not be treated as specifications or benchmark evidence for Composer 2.5. Likewise, the model’s documented context window does not by itself guarantee that every agent workflow will use the full context on every run.
Can you use Composer through a production API?
Yes, through Cursor’s programmatic agent SDK; not as a documented raw-inference endpoint in the materials reviewed here. Cursor’s TypeScript SDK example selects composer-2.5 in Agent.create, supplies a Cursor API key, sends a prompt with agent.send(...), and streams run events. The SDK documentation says inference goes through Cursor-hosted models, including when the agent loop runs locally. (Cursor TypeScript SDK; Cursor SDK announcement)
That distinction matters for integration design:
- Supported agent route: The TypeScript SDK documents Composer 2.5 selection and programmatic agent runs. It accepts Cursor user API keys for local and cloud runs; user-key usage bills to that user’s plan. The SDK documentation lists the TypeScript SDK as available to all users. (Cursor TypeScript SDK; Cursor APIs overview)
- Team credentials: The SDK also accepts service-account API keys, but Cursor documents service accounts as an Enterprise-plan feature. Service-account usage bills to the team that owns the account. (Cursor TypeScript SDK; Service Accounts)
- Plan wording: Plus is listed as having no Cloud Agents and no “your own API keys.” That wording appears alongside restrictions on third-party models; Cursor separately describes adding your own API key for a supported provider. Do not read that plan phrase as a restriction on Cursor-issued SDK user keys. Plus’s Cloud Agents restriction is separate from the SDK’s documented local-agent route. (Models & Pricing; Regions; Cursor TypeScript SDK)
- Agent contract: Provide a task prompt to the agent, then consume the run’s result or stream its events. This is a coding-agent harness, not a simple prompt-in/response-out model endpoint. The SDK documents local and Cursor-hosted cloud runtimes; confirm that the specific runtime and account setup you intend to deploy meet your requirements. (Cursor TypeScript SDK)
- Raw model inference: The reviewed Cursor materials document agent runs, not a standalone Composer chat-completions endpoint. Do not treat SDK access or model pricing as proof of a raw inference API. (Cursor APIs overview)
Integration decision: If your application can use Cursor’s agent harness, the TypeScript SDK documents a Composer 2.5 route. The documentation lists the SDK as available to all users and accepts Cursor user API keys; service-account keys are an Enterprise option. If you need only a raw Composer response, the reviewed documentation does not establish that route. Verify the exact runtime and account requirements before committing to the integration.
Composer 2.5 pricing in Cursor
Cursor lists the following usage rates per million tokens. These are Cursor model-usage rates, not a separately documented raw-inference API tariff. Paid plans include a usage pool for Cursor models; what applies to a particular run depends on the plan and route. (Composer 2.5 model documentation; Models & Pricing)
| Composer 2.5 variant | Input | Cache read | Output |
|---|---|---|---|
| Standard | $0.50 / million tokens | $0.20 / million tokens | $2.50 / million tokens |
| Fast | $3.00 / million tokens | $0.50 / million tokens | $15.00 / million tokens |
The model page shows no separate cache-write rate for these variants. Do not assume Fast is the automatic default: Cursor’s plan documentation says Plus uses Composer 2.5 with Fast off at fixed settings. Check the model picker and the terms for your plan and integration route rather than assuming a variant or eligibility. (Models & Pricing)
Illustrative calculation: For a run with 100,000 input tokens and 20,000 output tokens, with no cache-read tokens, the listed standard rates give (0.1 × $0.50) + (0.02 × $2.50) = $0.10. At Fast rates, the same token counts give (0.1 × $3.00) + (0.02 × $15.00) = $0.60. This is arithmetic from the listed rates, not a measured run or a prediction of typical usage. Actual agent runs can use different token volumes, and plan-included usage may apply.
When should you choose Composer?
Consider Composer 2.5 if you want to evaluate Cursor’s agent for repository work, file edits, terminal operations, or longer coding tasks. Those are the workflows Cursor associates with Composer. (Composer 2.5 model documentation)
Compare it with another model when your work is unusually specialized, has ambiguous requirements, or carries strict quality, latency, or cost constraints. A product description does not establish that Composer will outperform alternatives on your codebase. Older Composer 1 claims and 2025 user anecdotes are not evidence of Composer 2.5’s comparative performance.
A practical evaluation is to run the same representative tasks through each candidate: one routine change, one multi-file task that includes tests, and one less-defined debugging or planning task. Compare completion time, test results, human corrections, and usage cost. Review the diffs; response speed alone is not a quality measure.
Bottom line
Cursor documents Composer 2.5 as a selectable model in its TypeScript agent SDK, with Cursor-hosted inference and SDK runs subject to the applicable Cursor plan and usage rules. The SDK runs an agent, not a raw Composer chat-completions endpoint. Cursor user API keys are accepted for SDK runs; service-account keys are documented for Enterprise, and Plus’s “your own API keys” wording should not be confused with those Cursor-issued SDK credentials. Standard and Fast have different listed usage rates; Cursor’s plan documentation says Plus fixes Composer 2.5 to Fast off. Confirm the exact runtime and account setup you need before building around it.
Sources
Build programmatic agents with the Cursor SDK
Models & Pricing | Cursor Docs