Using Cursor IDE with cto.new as Your Background Agent

Cursor is an incredible IDE for local, AI-assisted development, but there's a pricing problem - especially when it comes to background agents. The solution? Connect cto.new via MCP server. This approach lets you offload heavy lifting to a free, world-class coding agent right from your primary, local IDE experience, without adding bloat.

Here's how to build this workflow and why it's genuinely transformative.

The Problem: Why You Need a Background Agent

When you're building features, you inevitably hit moments where you need to delegate work. Maybe it's implementing a complex flow, refactoring a large module, or knocking out a series of related tasks. Cursor's native background agents are powerful, but they come with significant costs that add up quickly across multiple concurrent tasks.

cto.new solves this elegantly. It's completely free, runs on all the latest/best frontier models, and is designed specifically to handle the kind of delegated work that eats up token budgets in other systems.

Setting Up cto.new as an MCP Server in Cursor

The setup is pretty straightforward. cto.new exposes itself as an MCP server, which means Cursor can talk to it natively using OAuth authentication - no API keys to manage.

Step 1: Get Your Cursor Configuration Ready

Open your Cursor settings and locate your MCP configuration file. You'll usually find it at:

• macOS/Linux: ~/.cursor/mcp.json

• Windows: %APPDATA%\Cursor\User\mcp.json

If the file doesn't exist yet, just create an empty file.

Alternatively you can use a config file scoped to your project in `<path_to_project>/.cursor/mcp.json`. rather than using the global config.

Step 2: Add the cto.new MCP Server

Add the following to your mcp.json file:

{
  "mcpServers": {
    "cto.new": {
      "url": "https://mcp.enginelabs.ai/mcp"
    }
  }
}

This is the simplest configuration. Cursor handles OAuth authentication automatically - you'll be prompted to authorize on first use.

Step 3: Restart Cursor and Authenticate

Restart Cursor completely (quit and reopen). When you first try to use the cto.new MCP server in a Chat, you'll see an OAuth prompt. Click authorize, and you're connected. 

If that doesn’t happen for you, try heading to Cursor Settings -> Tools & MCP -> cto.new and click Connect. 

As an aside, we use Clerk for auth, so the URL will reflect that. 

Now you’re ready to go.

Step 4: Test the Connection

Open a Chat in Cursor and try mentioning the cto.new tool. Type something like:

"What projects do I have available in cto.new?"

If it responds with your project list, you're connected and ready to go.

The Workflow: From Cursor to cto.new and Back

Here's where this gets powerful. The workflow isn't linear - it's cyclical, and you control the tempo.

Phase 1: Planning and Scoping in Cursor

Start with what you do best: thinking. You can use Cursor's chat to talk through what you're building. Be specific about requirements, constraints, and context.

For example:

"I need to add a two-factor authentication flow to my app. The user should receive SMS codes via Twilio. Existing users have a phone_number field in the database. I want to follow the same pattern we used for email verification in AuthService.ts. New endpoint should be POST /api/auth/2fa/send and POST /api/auth/2fa/verify."

Cursor will ask clarifying questions, suggest approaches, and help you think through edge cases. This phase is fast because you're not waiting for code to compile or tests to run. You're just reasoning about the problem.

Note: You can also do this directly in cto.new, and we think it’s a fantastic option, but for those who prefer working from within the IDE environment, the above works well too.

Phase 2: Delegating to cto.new

Once you've got a clear plan (and you really should have one - vague tasks are the biggest killer of agent quality), it's time to delegate.

In Cursor, open the chat and say something like:

"@cto.new Send this task off to my 'auth-improvements' project: Implement two-factor authentication via SMS using Twilio. Full requirements in the conversation above."

The MCP integration handles the grunt work: it automatically extracts the project name, formats the task properly, and queues it in cto.new. It even injects your conversation history as context.

What happens next? cto.new takes over. The agent:

• Examines your codebase

• Understands your patterns and conventions

• Writes the implementation

• Runs your test suite

• Self-corrects if something breaks

• Opens a PR when it's done

All of this happens in the background. You don't have to wait, you can go work on other things.

Phase 3: Review and Iterate

A little later (or overnight if you prefer), check the cto.new web interface. You'll see a PR waiting for you.

This is critical: actually review it. Don't just merge AI-generated code. Read it. Test it locally if it's complex. Comment on it. Request changes via comments on the PR if something doesn't align with your vision.

Why? Two reasons. First, you maintain code quality and architectural integrity. Second, cto.new learns. It sees your feedback, remembers your preferences, and applies them to the next task. After a few iterations, it becomes less like a generic tool and more like a teammate who knows your codebase.

Phase 4: Refining with Cursor

If the PR needs changes, you can go back to cto.new immediately or use Cursor locally to make tweaks, understand the intent, and add missing pieces. Then you can either:

• Merge what cto.new did and follow up with a separate task

• Iterate on the cto.new PR by adding comments with refinements

• Spin up a new task with specific fixes

Practical Patterns That Work

Pattern 1: The Overnight Queue

Queue up 3-5 well-scoped tasks in cto.new before you leave for the day. While you sleep, the agent works through them. In the morning, you've got a stack of PRs to review instead of code to write. This is a very effective way to get massive productivity gains from AI.

The key: make sure each task is discrete and well-described. No vague requests like "fix bugs" or "improve performance." Tasks need explicit scope.

Example:

• ❌ "Refactor the authentication module"

• ✅ "Refactor AuthService.ts to split OAuth handling into OAuthProvider.ts following the factory pattern used in PaymentProviders/"

Pattern 2: Hybrid Implementation

Use Cursor for the skeleton and decision-making. Use cto.new for depth and scale.

Start a Chat in Cursor: "I'm building a dashboard with charts. Which charting library fits our tech stack?" Work through the architecture. Then delegate: "@cto.new Implement the dashboard layout and integrate Chart.js according to the spec in the conversation above."

Cursor excels at iterative exploration. cto.new excels at execution (it also excels in planning, but for those that prefer local, Cursor is a great option). Use both.

Pattern 3: The Feedback Loop

After cto.new merges a few PRs, you'll have patterns. Codify them. Update your cursor rules with explicit style guidance, architectural patterns, and naming conventions. Or just ask the Cursor chat to suggest updates based on your conversations.

What To Avoid

Don't queue massive, ambiguous tasks. If you can't explain it in 2-3 sentences without waving hands, it's too big. Break it down.

Don't treat it like magic. Review the code. The agent is good, but it's not omniscient. It works from what you give it.

Don't ignore context. If cto.new is working with a large, unfamiliar codebase, spend 10 minutes adding context in the task description. Or better yet: if you’re working with the MCP in Cursor, ask the chat to include that context for you! Point it to key files, explain architectural decisions, highlight patterns it should follow. The investment pays off immediately.

Why This Approach Wins

Cost. cto.new is free. Cursor's background agents cost real money. You save thousands per month.

Speed. Fire off a task, move on. No waiting, no blocking. Your development speed decouples from how fast you can code.

Quality. cto.new's agent is world-class. It produces PR-ready code more often than not. Your review cycle is faster.

Control. You stay in Cursor for local creative, exploratory work. The agent handles execution. You're not fighting with a tool; you're directing it.

Learning. Every time cto.new works on your codebase, it gets better at understanding your style. After a few tasks, it becomes genuinely smart about your project.

Getting Started

1. Set up the MCP connection (takes less than a minute)

2. Start with a small task-something you could do yourself in 15 minutes, but you're curious to see how the agent handles it

3. Review the PR, leave feedback

4. Do it again with slightly more complex work

5. After 3-4 tasks, you'll understand the rhythm

Once you do, the payoff is enormous. You're no longer bottlenecked by how fast you can type or how long you can focus on implementation. You're working at the speed of planning and review.

That's the promise of background agents. Using cto.new with Cursor or your MCP-compatible IDE of choice is a great way to upgrade your workflow.