How to Use Cursor Composer 2: Setup, Model Selection and Real Workflows

Cursor Composer 2 is available in the Cursor IDE model selector as of March 19, 2026. It scores 61.7% on Terminal-Bench 2.0 — beating Claude Opus 4.6's 58.0% — at $0.50 per million input tokens. This tutorial covers exactly how to select the model, configure speed tiers, start your first session, and structure real workflows for the tasks Composer 2 handles best.

Prerequisites

Before starting, confirm you have:

• Cursor IDE installed (download from cursor.com if not)
• A Cursor Pro or Business subscription active — Composer 2 is not available on the free tier
• Cursor version 0.44 or later — earlier versions do not include Composer 2 in the model selector

To check your Cursor version: open the Command Palette (Cmd+Shift+P on macOS, Ctrl+Shift+P on Windows/Linux) and type Cursor: Check for Updates.

Step 1: Select Composer 2 in the Model Selector

1. Open the Cursor IDE
2. Press Cmd+I (macOS) or Ctrl+I (Windows/Linux) to open the Composer panel
3. Click the model name in the top-left corner of the Composer panel — it defaults to your previously selected model
4. In the dropdown, locate cursor-composer-2 under the "Cursor Models" section
5. Select either cursor-composer-2 (Standard) or cursor-composer-2-fast (Fast)

You can also set a default model to avoid selecting it each session:

1. Open Settings (Cmd+, or Ctrl+,)
2. Navigate to Cursor Settings → Models
3. Set Default Composer Model to cursor-composer-2

Step 2: Choose the Right Speed Tier

Composer 2 offers two billing tiers that run identical model weights:

Use Standard when you are starting an agentic task and walking away — multi-file refactors, test generation sweeps, codebase-wide bug fixes. Latency does not matter when you are not watching.

Use Fast when you are actively iterating — prompt, review output, adjust, repeat. The 3x price premium is worth it when latency between your prompt and the model's first token is part of your feedback loop.

Step 3: Configure Context for Your First Session

Composer 2 has a 200K token context window. For most tasks, you do not need to manage context manually — the IDE feeds relevant files automatically. For complex multi-repository or large monorepo tasks, manage context explicitly:

Add files to context

In the Composer panel, click the + button or use @ mentions to add specific files:

@src/auth/middleware.ts @src/auth/session.ts @tests/auth.test.ts

Add a directory

@src/payments/

Composer 2's self-summarization technique handles long sessions by compressing prior context into structured code-aware summaries. You do not need to restart sessions at arbitrary token limits — the model manages this internally and reduces errors by 50% versus standard context compression in sessions exceeding 100K tokens.

Exclude files you do not want modified

Create or update .cursorignore at the project root:

# .cursorignore
.env
.env.local
node_modules/
dist/
*.lock

Files listed in .cursorignore are excluded from Composer's read and write access.

Step 4: Run Your First Real Task

Composer 2 was trained with reinforcement learning on long-horizon tasks — multi-file edits, test creation, terminal command sequences. The prompts that work best are specific, scoped, and state the acceptance criteria.

Effective prompt structure

[What to do] + [Where] + [Acceptance criteria]

Weak prompt:

Fix the auth bug

Strong prompt:

The login endpoint at src/auth/routes.ts line 47 throws a 500 when
the session token is expired instead of returning 401. Fix it so that
an expired token returns {\"error\": \"session_expired\", \"status\": 401}.
All existing tests in tests/auth.test.ts must still pass after the fix.

The specific file path, line reference, expected behavior, and test constraint give the model a clear success condition it can verify autonomously.

Real Workflow 1: Multi-File Refactor

This is where Composer 2's RL training shows most clearly. A multi-file refactor involves reading the existing structure, planning the changes, applying edits across files in the right order, and verifying consistency.

Example prompt:

Refactor the user authentication flow to replace JWT tokens with
opaque session tokens stored in Redis. Changes needed:
- src/auth/tokens.ts: replace jwt.sign/verify with Redis set/get
- src/auth/middleware.ts: update token validation logic
- src/config/redis.ts: add session TTL config (default 7 days)
- tests/auth.test.ts: update tests to mock Redis instead of JWT

Do not change the public API shape of any exported functions.
Run the test suite after changes and fix any failures before finishing.

Composer 2 will:

1. Read all four files into context
2. Plan the edit sequence to avoid dependency ordering issues
3. Apply changes file by file
4. Run npm test or your configured test command
5. Fix any test failures before marking the task complete

This is a task that typically takes a senior developer 30–90 minutes. Composer 2 completes it in one autonomous session, typically under 10 minutes at Standard tier.

Real Workflow 2: Codebase Bug Fix from Error Log

Composer 2 handles error-log-to-fix workflows efficiently because Terminal-Bench 2.0 — the benchmark it leads at 61.7% — specifically tests terminal-native debugging.

Example prompt:

This error appeared in production logs:

TypeError: Cannot read properties of undefined (reading 'userId')
    at validateRequest (src/middleware/validate.ts:23:18)
    at Layer.handle [as handle_request] (express/lib/router/layer.js:95:5)

Find the root cause in src/middleware/validate.ts, fix it, add a
null check or early return where appropriate, and add a unit test
that covers the undefined input case.

Composer 2 will locate the file, read the function, identify the missing null guard, apply the fix, and generate the test — a task that otherwise requires a developer to context-switch from whatever they were working on.

Real Workflow 3: Test Generation for Uncovered Code

Composer 2 is effective at coverage-driven test generation, particularly when you provide the coverage report as context.

Example prompt:

The following functions in src/payments/processor.ts have 0% test coverage:
- processRefund()
- validateCardExpiry()
- calculateFees()

Generate unit tests in tests/payments/processor.test.ts covering:
- Happy path for each function
- Edge cases: expired card, zero amount, negative fees
- Error handling: network timeout, invalid card format

Use the existing test patterns in tests/payments/charge.test.ts as style reference.

What Composer 2 Is Not For

Composer 2 is a code-only model. Using it for tasks outside programming produces noticeably weaker output:

Monitoring Token Usage

Cursor displays token usage per Composer session in the session footer. For cost management on long agentic runs at Standard tier:

1. Open Settings → Usage to see your monthly token consumption by model
2. Set a monthly spend alert at your target threshold — Cursor sends an email notification when you cross it
3. Review the session token count before starting a new task if you are approaching your budget — a 200K token session at Standard output pricing costs $0.50 maximum

Parallel Agents: Running Multiple Composer 2 Sessions

Cursor Pro supports 8 parallel Composer agents. To use this effectively with Composer 2:

1. Split a large task into independent subtasks with no file overlap
2. Open 8 Composer panels (Cmd+I eight times, or use the split panel view)
3. Assign one subtask per panel with explicit file scope in the @ context
4. Monitor all 8 sessions from the Composer sidebar

Avoid running parallel sessions that write to the same files — merge conflicts from simultaneous agents require manual resolution.

FAQ

Does Composer 2 work with non-JavaScript/TypeScript codebases?

Yes. Composer 2's SWE-bench Multilingual score of 73.7% covers Python, TypeScript, JavaScript, Java, Go, and Rust. Performance is strong across all six languages. Cursor has not published per-language breakdowns.

Can I use Composer 2 via the Cursor API outside the IDE?

No. As of March 2026, Composer 2 is only accessible through the Cursor IDE. There is no public API endpoint for direct model access outside the Cursor interface.

How do I roll back changes Composer 2 made?

Cursor applies all Composer changes as standard file edits tracked by your version control system. Run git diff to review all changes and git checkout . to revert everything, or use git checkout <file> to revert specific files.

What happens when Composer 2 hits the 200K context limit?

The self-summarization technique compresses earlier session context before the hard limit is reached. You will see a notice in the session footer when summarization activates. In practice, most tasks complete well within 200K tokens — a 200K session at Standard tier costs a maximum of $0.55 in combined input/output.

Is Composer 2 available on the Cursor free tier?

No. Composer 2 requires a Cursor Pro ($20/month) or Business subscription. Free tier users have access to third-party models via the standard Cursor interface but not to Cursor's proprietary Composer 2 model.

---

Next step: Open Cursor right now, switch the Composer model to cursor-composer-2 Standard, and paste in the last bug report from your issue tracker as a prompt using the strong prompt structure above — file path, expected behavior, and acceptance criteria. Run it and review the output before your next meeting.