Cursor's Three Major Announcements: Mobile App, Git Platform, and In-House Frontier Model

At a recent Cursor community event, co-founder Michael reflected on the company's journey since its founding in January 2022 and officially unveiled three major product updates: Cursor Mobile, the Origin code collaboration platform, and a new-generation in-house large language model trained from scratch. These announcements mark Cursor's official transition from an AI code editor to a full-stack AI development platform.

From Four Programmers to an AI Programming Platform

In early 2022, a team of four young programmers saw dozens of startups and tech giants already competing in the AI programming space and initially thought "there's no room left." But by the end of the year, they realized no tool on the market truly satisfied them, so they "hid in a cave in their underwear and coded for two weeks," producing their first prototype.

Of the initial 20 beta testers, the first two users responded lukewarmly or simply "disappeared." But the team stuck to a core loop: every day, think about how to make the product better for themselves and more valuable for the community. That loop continues to this day.

Cursor has now completed a full transition to an "Agent-first" paradigm. Here, Agent refers to an AI system capable of autonomously planning and executing multi-step tasks — distinct from traditional single-turn Q&A or code completion. An Agent can understand high-level intent, automatically decompose tasks, invoke tools, read and write files, run commands, and dynamically adjust its strategy based on execution results. This paradigm shift means developers move from "writing code line by line" to "describing goals and supervising execution" — similar to going from doing construction yourself to directing a construction team.

The data speaks for itself: over 95% of users primarily use Cursor as an Agent, with Agent requests exceeding auxiliary features (like Tab completion) by more than 5x, and by several orders of magnitude when measured by lines of code.

Cursor 3: A Development Environment Built for Agents

The newly released Cursor 3 represents a fundamental redesign of the product. The left side features the Agent panel, the center is the Agent workspace, while retaining all the capabilities of a professional development environment — file editing, remote SSH, language servers (LSP — backend services that provide code intelligence features like smart suggestions, go-to-definition, and refactoring for editors), and linting are all present.

Several noteworthy new features:

• Design Mode: You can point directly at UI elements on screen and have the Agent modify specific components. This "what you see is what you get" interaction eliminates the cognitive burden of precisely describing UI locations in text, converting visual pointing into precise code targeting.

• Recursive Sub-Agents: Agents can invoke sub-agents, forming a complete Agent team collaboration. This is a multi-agent collaboration architecture where a primary Agent can decompose complex tasks and delegate them to specialized sub-agents. For example, a main Agent responsible for refactoring might call a sub-agent specialized in testing and another responsible for documentation updates. This architecture borrows from the divide-and-conquer approach and microservices philosophy in software engineering, enabling AI systems to handle large tasks that far exceed a single Agent's context window limitations.

• Cloud Agent Upgrades: Agents have their own independent development environments (similar to containerized sandboxes) and can run tests, generate screenshots, and work continuously for days. This means Agents are no longer constrained by the resources and uptime of a user's local machine.

The team's product philosophy is clear: collaborating with an Agent should feel as natural as collaborating with a colleague — not just text conversations, but being able to "point at the screen and discuss together."

Three Major Announcements

Cursor Mobile: Manage AI Agents Anytime, Anywhere

Product lead Kevin introduced the design philosophy behind the mobile app: when Agents become 24/7 infrastructure, developers need to interact with them anytime, anywhere. This reflects a fundamental shift in software development workflows — in the past, leaving the computer meant work stopped, but now that Agents run continuously, developers need a lightweight monitoring and command interface.

Cursor Mobile's core features include:

• View the status of all running Agents and identify blocked tasks
• View Agent-generated outputs like screenshots
• Annotate feedback directly on screenshots to redirect Agent work
• Remotely control local Agents (ideal for users with Mac Mini clusters on their desks)

Cloud Agents have achieved a 3x speed improvement and 99.9% availability (meaning less than approximately 8.7 hours of downtime per year) over the past few months. The automation feature, launched just months ago, has already accumulated over 6 million automation runs. Customer Amplitude (a product analytics platform company) is using it to batch-migrate 20,000 React components to Tailwind CSS — this kind of large-scale mechanical refactoring is exactly where Agents excel. Manual execution might take months, while Agents can complete it in days.

Origin: An Agent-Native Git Platform, Taking on GitHub Head-On

Through the acquisition of the Graphite team, Cursor launched the Origin platform, officially challenging GitHub. Graphite was a developer tools company focused on code review and stacked PR (Stacked Pull Requests) workflows, with a core philosophy of breaking large code changes into small, independently reviewable incremental commits to accelerate the code review process. The team had served companies with top-tier engineering cultures like Shopify, Snowflake, Notion, and Figma, accumulating deep expertise in Git workflow optimization and an understanding of pain points for large-scale engineering teams.

Origin's three core design principles:

Scale: A completely new Git architecture design that simulates thousands of Agents simultaneously pushing and pulling from a single repository in load tests, with performance meeting both current and future demands. Traditional Git's snapshot and directed acyclic graph (DAG) design performs excellently with a small number of collaborating developers, but when thousands of Agents operate simultaneously, lock contention, merge conflicts, and reference updates become severe bottlenecks. While GitHub's architecture has been optimized over many years, its design assumptions are still based on human developer operation frequency (a few to dozens of pushes per day). Origin needs to redesign concurrency control, conflict resolution, and branch management strategies from the ground up to accommodate the order-of-magnitude increase in operation frequency in the Agent era (hundreds of pushes per minute).

Extensibility: Through APIs, MCP, and a third-party app platform, developers and Agents can build any needed functionality on Origin, with generous rate limits and complete API control. MCP (Model Context Protocol) is an open protocol standard released by Anthropic in late 2024, designed to provide AI models with a unified way to access external tools and data sources. Similar to how USB provides a standard interface for hardware devices, MCP provides AI Agents with a standardized way to connect to databases, APIs, file systems, and other external resources, enabling interoperability between different tools and platforms.

Keep Code Flowing: Leveraging Cursor's AI capabilities to automatically resolve merge conflicts, fix CI (Continuous Integration — automated pipelines that run tests and builds after code commits) failures, address review comments, and automatically determine the next action for each PR (Pull Request), notifying developers only when necessary — cutting code review time by more than half. In traditional workflows, a PR takes an average of hours or even days of manual review from submission to merge, while AI-driven automation can front-load most mechanical checks and fixes.

Origin is already live internally at Cursor and with select design partners, with plans for a full public launch this fall.

A Frontier In-House Model Trained from Scratch

This is the most ambitious announcement. Cursor revealed it is training an entirely new model, fundamentally different from the previous Composer series:

Frontier-scale: Parameter count on par with Opus (Anthropic's flagship model Claude Opus) and GPT (OpenAI's GPT-4 series), likely in the hundreds of billions of parameters range.

Trained from scratch: No longer fine-tuning open-source models, but fully self-directed training for precise control over model behavior. Fine-tuning involves additional training on a pre-existing model using domain-specific data — lower cost but constrained by the base model's architecture and knowledge boundaries. Training from scratch (pre-training from scratch) means starting from randomly initialized weights with complete control over training data ratios, curriculum learning strategies, architecture design, and alignment methods. This gives the team precise control over model behavior — for example, making the model natively understand code editing diff formats and optimal tool-calling strategies — but requires tens of millions of dollars in compute investment and top-tier infrastructure engineering capabilities.

10-20x Compute Increase: This is the key breakthrough. Previously, the Composer series was constrained by GPU resources, with many improvement directions blocked by compute bottlenecks. This massive scaling gives the team confidence to catch up with or even surpass frontier labs. Based on current GPU pricing estimates, a 10-20x compute increase means the training budget may jump from millions to tens of millions of dollars.

Beyond Pure Coding Ability: The new model will possess general intelligence capabilities including tool use, long-horizon planning, software testing, and UI interaction, because an "engineer colleague" needs far more than just code writing. This reflects the industry consensus on AI Agent capabilities — a truly useful programming Agent needs to understand product requirements, design testing strategies, and debug complex systems, not merely translate natural language into code.

Behind all of this is a partnership with Meta (which has large-scale GPU clusters and training experience from its open-source Llama model series). Michael emphasized that Cursor is one of the very few companies that can deeply design both product and model simultaneously, and its DNA is "developers building for developers" — a fundamental difference from competitors coming from big tech or research labs.

Model Evolution: From Tab to Composer

Looking back at Cursor's model journey: the 2023 Tab completion model "quietly became one of the most popular coding models" — these models focus on predicting the code a developer will type next, with extremely low latency requirements (typically needing to return results within 300 milliseconds), and therefore use specialized architectures with fewer parameters but very fast inference speeds.

In 2024-2025, small agent models were used to compensate for API models' shortcomings in tool calling. Since directly calling APIs from large models like Claude or GPT involves high latency, high cost, and inconsistent tool-calling formats, Cursor trained specialized small models to handle routing decisions, tool selection, and result integration.

Composer 1 achieved large-scale reinforcement learning; Composer 2 introduced pre-training on tens of trillions of tokens and real-time RL (updating the model every 5 hours). Traditional reinforcement learning from human feedback (RLHF) is typically an offline batch process with model update cycles measured in weeks or months. Cursor's real-time RL updates the model every 5 hours, meaning the system can rapidly learn from users' accept/reject behaviors and continuously optimize code generation quality. This online learning approach is similar to real-time feedback loops in recommendation systems, but applying it to code generation is technically more challenging because verifying code correctness is far more complex than click-through rates — it requires considering multiple signals such as compilation success, test passage, and code style consistency.

The team particularly emphasized the importance of cost and speed: "If the most powerful models are only affordable for big companies, that would be a sad world." They want independent developers and individual hackers to have access to the best models too. The technical implementation of this vision relies on inference optimizations (such as speculative decoding, KV cache sharing, model distillation, and other techniques) that continuously drive down the per-call cost of large models.

Platform Strategy

Cursor is evolving from a closed product to an open platform — a classic path for software companies transitioning from tools to ecosystems (similar to how Salesforce evolved from a CRM tool into an enterprise application platform):

• SDK Release: Not only humans can use Cursor — other Agents can also invoke it through programmatic interfaces. This means Cursor can be embedded into larger automation workflows, such as automatic code fixes in CI/CD pipelines or automatic task execution in project management tools.
• Plugin Ecosystem: Support for integrations with Datadog (application monitoring platform), databases, design tools, and more, allowing Agents to access contextual information like production logs, performance metrics, and design mockups.
• CLI Enhancements: Over 50 improvements in recent months, with support for Headless Mode (running without a graphical interface), suitable for server-side and automation scenarios.
• Multi-Platform Coverage: Full coverage across desktop, web, terminal, and mobile.

Summary

From four programmers' "cave startup" in 2022 to now launching a mobile app, challenging GitHub, and training a frontier large model, Cursor's ambitions have far outgrown a code editor. The core belief Michael repeatedly emphasized throughout his presentation is this: this is a company "built by developers, for developers," and now for the first time they have complete control from product pixels to model weights — a level of vertical integration extremely rare among AI application companies, typically only pursued by companies like Apple that seek full-stack control from hardware to software. The new model will be released in the coming weeks and is well worth watching.