Short answer
Composer 2.5 is Cursor’s agentic coding model. This guide covers the version identified in Cursor’s model documentation, which lists the model ID composer-2.5 and a 200,000-token context window. Cursor describes it as intended for coding-agent tasks involving tools such as file edits and terminal operations. (Cursor model docs)
You can run Cursor’s agent programmatically with Composer 2.5, but that is different from calling a standalone Composer chat-completions API. Cursor documents an agent SDK and a Cloud Agents API; its SDK documentation describes running agent workflows, rather than a generic model-inference endpoint. (Cursor API overview, Python SDK docs)
What is Composer 2.5?
Composer 2.5 is Cursor’s agentic model for software development. Cursor’s model documentation describes it as building on Composer 2, but the available documentation excerpts do not establish specific comparative improvements. (Cursor model docs)
The documented model ID is composer-2.5. Cursor lists a 200k context window and describes the model as tuned for tool use, file edits, and terminal operations inside Cursor. (Cursor model docs)
Can you use Composer through a production API?
Cursor documents programmatic agent access, including a Python SDK and a Cloud Agents API. The SDK is an agent integration, not a documented standalone Composer text-generation endpoint. Use this route if your application can work with Cursor’s agent interface; don’t assume it is interchangeable with a generic chat-completions API. (Cursor API overview, Python SDK docs)
The Python SDK documentation shows Composer 2.5 selected with model="composer-2.5". It requires Python 3.10 or later, installs with pip install cursor-sdk, and lists user and service-account API keys. The documented example sends a prompt with agent.send(...) and reads the text using .text(). (Python SDK docs)
pip install cursor-sdk
export CURSOR_API_KEY="your_cursor_api_key"
import os
from cursor_sdk import Agent, LocalAgentOptions
with Agent.create(
model="composer-2.5",
api_key=os.environ["CURSOR_API_KEY"],
local=LocalAgentOptions(cwd=os.getcwd()),
) as agent:
result = agent.send("Summarize this repository and identify its main entry points.")
print(result.text())
This example runs the agent against local files. Cursor says SDK runs follow the same pricing, usage-pool, and Privacy Mode rules as IDE and Cloud Agent runs. Its documentation describes local as where the agent loop and file access run—not where model inference happens. Check Cursor’s applicable terms and settings for your deployment rather than treating “local” as a privacy guarantee. (Python SDK docs, TypeScript SDK docs)
Composer 2.5 pricing
Cursor lists these additional-usage rates per million tokens. Additional usage is charged beyond the applicable included pool. Cursor says paid-plan usage pools are shared across subscription surfaces, including Agent in the editor, CLI, and Cloud Agents. Included allowances and reset periods depend on the applicable plan, so check its current terms. (Composer model pricing, Models & Pricing)
| Composer 2.5 option | Input | Cache read | Output |
|---|---|---|---|
| Standard | $0.50 / 1M tokens | $0.20 / 1M tokens | $2.50 / 1M tokens |
| Fast | $3.00 / 1M tokens | $0.50 / 1M tokens | $15.00 / 1M tokens |
Worked example: if all tokens in a request mix are billable at the uncached listed rates, 10 million input tokens and 1 million output tokens cost $7.50 at Standard rates: (10 × $0.50) + (1 × $2.50). The same mix costs $45 at Fast rates: (10 × $3.00) + (1 × $15.00). These totals exclude any usage covered by an included pool and assume no cache-read billing. Actual charges depend on cache use and applicable plan usage. (Composer model pricing)
These are Cursor-listed rates for Composer usage in Cursor’s product and agent workflow; they are not evidence of a separate standalone model API price. Cursor says the SDK follows the same pricing and usage-pool rules as IDE and Cloud Agent runs. (Composer model pricing, Python SDK docs)
What is Composer good at—and what should you test?
Cursor positions Composer 2.5 for long-running agentic coding tasks. Its published product page includes results for Terminal-Bench 2.0, SWE-Bench Multilingual, and CursorBench v3.1. Cursor also notes that some competing scores on public evaluations are self-reported. Treat the figures as one input to model selection, then evaluate tasks representative of your own repository, tools, and review requirements. (Cursor Composer page)
A November 2025 review offers an older, version-specific anecdote—not a Composer 2.5 benchmark. In one task, the reviewer said an unguided Composer run took about two minutes but needed refinement; a structured run with planning and testing took about eight minutes and was judged more robust. That is one author’s experience, not a general speed or quality guarantee for Composer 2.5. (Codeaholicguy review)
For production code, assess the whole workflow, not just the model’s first draft: run tests, inspect diffs, check security-sensitive changes, and verify behavior in your environment. Cursor’s product descriptions and benchmark results do not substitute for those checks. (Cursor model docs, Cursor Composer page)
When should you choose Composer?
- Consider Composer 2.5 if you want a Cursor-integrated coding agent or an SDK workflow that works against a repository and uses coding tools. Test representative tasks and track correctness, review effort, latency, and billed usage. (Cursor model docs, Python SDK docs)
- Consider a different integration if you specifically need a standalone text-generation endpoint. Cursor documents agent workflows; its API materials do not establish a raw Composer inference endpoint. (Cursor API overview)
- Estimate cost using your token mix and plan. Standard and Fast have different listed rates, and included usage and caching affect charges. Compare prices only when version, access channel, billing unit, and date match. (Composer model pricing, Models & Pricing)
Bottom line: Composer 2.5 has a documented model ID, context window, Cursor-listed usage rates, and programmatic access through Cursor’s agent SDK. It is a candidate when an agent-oriented workflow fits your application. If you require a standalone model-inference API, Cursor’s published API materials do not establish Composer availability in that form; use the SDK only if its agent interface meets your production requirements. (Cursor model docs, Python SDK docs, Cursor API overview)
Sources
Cursor Python SDK | Cursor Documentation
Cursor TypeScript SDK | Cursor Documentation
Models & Pricing | Cursor Docs