Tech

Cursor 3.0 AI Agent Orchestration: Rewritten in Rust

Jonathan Versteghen — Senior tech journalist covering AI, software, and digital trends3 min read
Cursor 3.0 AI Agent Orchestration: Rewritten in Rust

Key Takeaways

  • •Cursor 3.0 is a full Rust rewrite — no longer a VS Code fork — built around orchestrating multiple AI agents simultaneously rather than assisting with manual coding.
  • •Composer 2, Cursor's flagship new model, was quietly built on Moonshot's Kimmy K2, not developed in-house as initially implied — Cursor later apologized and released a technical report.
  • •The new interface lets developers run parallel agents handling architecture, UI, and remote server tasks at once, with a dot-based status system to flag when human input is needed.

From VS Code Fork to Something Else Entirely

Cursor started as a VS Code fork with smarter autocomplete. That was version 1.0. Version 2.0 added a chat interface that could touch the terminal and build features. Cursor 3.0 is a different product category. The application has been completely rewritten in Rust and TypeScript, and the VS Code editor is now just the substrate underneath a new interface designed for something closer to project management than programming. In Cursor ditches VS Code, but not everyone is happy..., Fireship frames the pitch as developers becoming 'air traffic controllers' — directing AI agents rather than writing code themselves.

The underlying VS Code editor is still there, but it's no longer the point. That's a significant philosophical shift for a tool that built its reputation on making coding faster, not replacing it.

The Composer 2 Situation

What Cursor Said vs. What Was Actually True

When Cursor announced Composer 2, the framing was confident. Benchmarks showed it outperforming Claude Opus on intelligence, speed, and cost. The implication was that Cursor had built something genuinely new. Then the AI community started poking around and found that Composer 2 is built on Moonshot's Kimmy K2 model. Cursor apologized for the lack of transparency and released a technical report explaining what enhancements they'd made on top of the base model.

The apology came, the report came, and technically the model may still be good — but the sequence of events is exactly the kind of thing that makes developers distrust AI tool companies, and Cursor handed that distrust to critics on a plate.

Our Analysis— Jonathan Versteghen, Senior tech journalist covering AI, software, and digital trends

Our Analysis: The Composer 2 situation is the part of this story that deserves more scrutiny than it's getting. Cursor didn't just fail to mention the base model — they released benchmark comparisons designed to make Composer 2 look like an original creation. That's not an omission, it's a positioning choice. The technical report they released afterward may be accurate and detailed, but it arrived after the community caught them, not before. That ordering matters when you're asking developers to trust your tool with their entire codebase.

The Rust rewrite is the more interesting long-term signal. Abandoning a VS Code fork is a real commitment — it closes off a huge compatibility surface and forces Cursor to own every part of the experience. If the agent orchestration model lands, that bet pays off. If developers decide they'd rather have a familiar editor with good AI plugins, Cursor has made itself harder to fall back on.

There's also a bigger question lurking underneath all of this: what is the actual value proposition of an AI dev tool company in 2025? When the models themselves are commodities — or close enough that you can quietly license one from Moonshot and benchmark it against Anthropic — the differentiation has to come from workflow, trust, and integration depth. Cursor's agent orchestration vision is a credible answer to that question. But trust is exactly what took a hit with the Composer 2 rollout. You can have the right product strategy and still fumble the execution badly enough that it colors how developers interpret every future announcement. That's the real risk Cursor is managing right now — not whether the Rust rewrite works, but whether the community gives them enough benefit of the doubt to find out.

Frequently Asked Questions

What is Cursor 3.0 AI agent orchestration and how is it different from a regular code editor?
Cursor 3.0 shifts the developer's role from writing code to directing AI agents — Fireship's 'air traffic controller' framing is apt here. The VS Code editor is still underneath, but the new interface is built around managing parallel AI agent workflows rather than editing files directly. It's a meaningful category change, not just a feature update.
Why did Cursor ditch its VS Code fork for the 3.0 rewrite?
The VS Code fork was a practical starting point for a smarter code editor, but it became a constraint once Cursor's ambitions moved toward AI agent orchestration and project-level automation. Rewriting in Rust and TypeScript gave the team a foundation that isn't built around a text editor's assumptions. Whether that tradeoff is worth it for developers who loved the VS Code familiarity is a fair question the update doesn't fully answer.
What is Composer 2 actually built on, and does the Moonshot Kimmy K2 connection matter?
Composer 2 is built on Moonshot's Kimmy K2 model, not an in-house Cursor model as the initial announcement implied. Cursor has since apologized and released a technical report on their enhancements, but the damage to trust is real — benchmarks beating Claude Opus were presented without disclosing the base model, which is the kind of omission that sticks. The model may still perform well, but developers evaluating Cursor 3.0 should weigh that transparency gap. (Note: the extent of Cursor's proprietary enhancements on top of Kimmy K2 has not been independently verified.)
Can you still use Cursor 3.0 as a normal AI development environment without using the agent workflow?
The underlying VS Code editor remains intact, so traditional coding workflows aren't removed. That said, the entire new interface is designed around agent orchestration, which means the product's direction is clearly not toward making conventional coding faster. Developers who want a straightforward AI-assisted editor may find Cursor 3.0 over-engineered for their needs.
How does Cursor's parallel AI agent workflow actually function in practice?
The core idea is that multiple AI agents can run simultaneously on different parts of a project, with the developer reviewing and directing rather than writing. Think less pair programming, more delegating tasks across a team of automated contributors. The practical reliability of this at scale is still an open question — Fireship presents the concept compellingly, but real-world performance across complex codebases hasn't been widely stress-tested yet. (Note: independent developer benchmarks on the parallel agent workflow are limited at this stage.)

Based on viewer questions and search trends. These answers reflect our editorial analysis. We may be wrong.

āœ“ Editorially reviewed & refined — This article was revised to meet our editorial standards.

Source: Based on a video by Fireship — Watch original video

This article was created by NoTime2Watch's editorial team using AI-assisted research. All content includes substantial original analysis and is reviewed for accuracy before publication.