Cursor Reshapes AI Programming: Cloud Agents, the Origin Platform, and a Custom-Built Foundation Model

At its latest product launch event, Cursor CEO Michael systematically reviewed the company's journey since 2022 and dropped three major announcements: Cursor Mobile for mobile devices, Origin platform — a direct challenge to GitHub — and the first-ever disclosure of a brand-new custom-built foundation model. Together, these moves point to a single signal: AI programming is making a definitive shift from "assistive tool" to a new Agent-First paradigm.

From "Prehistoric Times" to Agent-First

Cursor's story began in January 2022, when four young programmers simply wanted to build a tool they'd actually want to use. Interestingly, they initially shied away from the AI coding space, believing "there was no room left" — after all, dozens of startups, big tech companies, and top AI labs were already in the game. But they ultimately "holed up and coded for two weeks," producing their first prototype.

Looking back, "not a single line of code, not a single pixel" from that prototype survives today. Michael emphasized that Cursor's core philosophy has always been "developers building for developers," with an intensely product-driven approach that doesn't hesitate to tear everything down and start over.

The biggest theme of the past three months has been making Cursor "simpler yet more powerful" while fully committing to Agent-First. Agent-First is a software architecture and product design philosophy that positions AI agents — rather than human operators — as the system's primary executors. Unlike traditional "AI-assisted" models, agent-first systems allow AI to autonomously complete multi-step tasks: formulating plans, invoking tools, executing code, validating results, and iterating based on feedback — all in a closed loop without requiring step-by-step human intervention.

The foundational support for this paradigm comes from breakthroughs in large language models' tool use and long-horizon reasoning capabilities, along with the maturation of several key frameworks: the ReAct framework (Reasoning + Acting), proposed by Google Research in 2022, allows models to alternate between generating chains of thought and concrete action instructions during reasoning steps, forming the theoretical basis for today's mainstream agent frameworks; Chain-of-Thought significantly improves complex task completion by guiding models through step-by-step reasoning; and tool calling (Function Calling), formally introduced by OpenAI in 2023, has since become an industry standard, enabling agents to invoke external systems like search engines, code interpreters, and databases, breaking through the action boundaries of pure language models. Notably, these three capabilities didn't evolve in isolation — the ReAct framework is built upon Chain-of-Thought's step-by-step reasoning ability, while Function Calling advanced the ReAct framework from "simulating actions via thought chains" to "real tool invocation." Together, they form the technical foundation that enables today's AI agents to reliably execute complex engineering tasks.

The data speaks volumes:

• Over 95% of Cursor users primarily use it as an agent
• By request volume, agent usage is roughly 5 times that of assistive features like Tab
• Measured by lines of code, the gap reaches orders of magnitude

With the release of Cursor 3, the interface has been redesigned as agent-first: agents on the left, agents in the center, while fully preserving all capabilities of a professional development environment — file editing, remote SSH, real-time lint from language servers, all intact. The new version also introduces Design Mode (point directly at page elements to instruct agents to modify them) and recursive sub-agents (sub-agents calling sub-agents, building entire agent teams).

Recursive sub-agents represent a core design pattern in multi-agent systems (MAS), with theoretical roots tracing back to distributed artificial intelligence research in the 1980s. In modern implementations, an "Orchestrator Agent" receives a high-level task, decomposes it, and dispatches subtasks to multiple specialized "Worker Agents," which can recursively decompose their subtasks further. This architecture draws on the "divide and conquer" strategy and "microservices" philosophy from software engineering, enabling parallel processing of complex tasks, failure isolation, and on-demand scaling of computational resources. From a systems engineering perspective, recursive sub-agents offer a key advantage: the context window at each layer is independent — the top-level orchestrator only needs to focus on task decomposition and result aggregation, while bottom-level workers focus on single subtasks, avoiding the performance degradation and error accumulation that come from cramming all intermediate state into a single context. It's worth noting that while open-source frameworks like LangGraph, AutoGen, and CrewAI have productized multi-agent patterns, they all require developers to manually configure agent topology. Cursor embeds this capability directly into the product, making multi-agent orchestration transparent to end users and dramatically lowering the barrier to entry — a key product-level differentiator.

Cloud Agents: Giving AI Its Own Development Environment

The core product philosophy behind this launch is enabling agents to "work like colleagues." Michael stated bluntly that most developers are still stuck running 3–5 agents locally, manually distributing half-hour to hour-long chunks of work — "this is clearly not the future." The real direction is handing over entire features, entire bug fixes, entire projects to agents, letting them work continuously for days and come back with completed, tested results.

To this end, Cursor equips cloud agents with independent development environments, including: cloning repositories, installing dependencies, and obtaining credentials for build systems and internal toolchains. This unlocks capabilities like: running tests, validating work products, and generating interactive screenshots for humans to annotate and mark up. According to product lead Kevin, cloud agent speed has improved 3x over the past few months, reaching three nines (99.9%) reliability.

"Three nines (99.9%)" is the standard availability metric in internet infrastructure, meaning approximately 8.76 hours of allowed downtime per year, or about 43.8 minutes per month. For traditional web services, this can be achieved through mature solutions like load balancing and multi-availability-zone deployment. However, AI agent platforms face challenges far beyond traditional API services — agent tasks are stateful, long-running operations that may last hours or even days, where mid-execution failure means wasted compute and time; checkpointing mechanisms need to persist the complete agent state at any execution node, including conversation history, tool call results, and intermediate filesystem state; furthermore, agent tasks typically depend on external services (code execution sandboxes, third-party APIs), whose own reliability boundaries must be factored into SLA calculations. Mature fault recovery techniques from traditional distributed systems — such as Saga pattern compensating transactions and idempotency design — face new challenges in AI agent scenarios: LLM reasoning itself is non-deterministic, meaning the same input may produce different intermediate paths upon retry. This requires agent infrastructure to design reasonable "semantic idempotency" guarantees beyond state persistence. Cursor's simultaneous achievement of 3x speed improvement and 99.9% reliability within three months indicates significant accumulated expertise in task persistence, error recovery, and distributed scheduling.

A notable case comes from customer Amplitude: they're automatically migrating 20,000 React components in the background, replacing them with Tailwind equivalents, entirely through a custom migration agent built on Cursor. Since the Automations product launched, the platform has run over 6 million automated tasks.

Cursor Mobile (iOS Beta) launched simultaneously. Users can check all running agents anytime, anywhere, discover blocked tasks, review screenshots produced by agents, and even re-instruct agents by annotating screenshots. It also supports triggering and collaborating with agents through Slack, Microsoft Teams, Jira, Linear, and other tools — truly enabling "collaboration with agents from anywhere."

Origin: An Agent-Native Git Platform Built from Scratch

The second major announcement came from the Graphite team, acquired by Cursor in January. Co-founder Tomas pointed out that building software is far more than writing code — it also includes testing, reviewing, merging, and deploying. As AI tools turn every developer into a "10x or even 100x engineer," traditional Git toolchains are becoming overwhelmed.

GitHub was born in 2008, and its core workflow (Fork→Branch→PR→Review→Merge) was designed around "human asynchronous collaboration," built on Git's decentralized version control model. When AI agents enter the picture, this architecture faces three pressures: dramatically scaled concurrency (thousands of agents may simultaneously commit to a single repository), PR granularity changes that severely degrade Review interface readability, and explosive growth in CI/CD trigger frequency. Existing tools like GitHub Actions support automation, but their scheduling primitives still assume the trigger is a human or simple script, not an agent with dynamic planning capabilities. At the data model level, Git's object storage design (the three-layer blob-tree-commit structure) faces severe contention at the ref lock level when thousands of concurrent agents operate on the same repository — this is an architectural constraint that cannot be fully resolved through application-layer optimization and must be addressed through redesigned scheduling primitives at the storage layer. Origin's choice to rebuild from scratch rather than wrap around GitHub is essentially a bet that "the agent era requires different underlying data models and scheduling primitives" — logic similar to how Docker's containerization restructured traditional VM deployment paradigms.

They launched Origin — an agent-native Git platform — positioned directly against GitHub, designed around three keywords:

Scale

Facing the explosion of code lines, commits, and PRs, Origin employs an entirely new Git architecture that fully leverages cloud provider primitives to improve scalability, reliability, and performance. In early stress tests, the team simulated thousands of agents simultaneously reading from and writing to a single repository, validating its ability to handle current and future demands.

Extensible

Echoing Michael's assertion that "Cursor is a platform," Origin enables both humans and agents to build freely on top of it through APIs, MCP, and a third-party app platform, offering generous rate limits and complete data control.

MCP (Model Context Protocol) is an open protocol standard proposed by Anthropic in November 2024, designed to define a unified interface specification for interactions between large language models and external tools and data sources — essentially the "USB-C port" of the AI world. Before MCP, every AI application needed to develop a separate adapter layer for each external tool, causing integration costs to grow quadratically with the number of tools. MCP defines three standardized primitives — Resources, Tools, and Prompts — enabling any tool that follows the specification to be plug-and-play invoked by any MCP-supporting AI application. Multiple developer tool companies including Zed, Replit, and Sourcegraph have announced support. From a protocol design perspective, MCP uses JSON-RPC 2.0 as its transport layer, supporting both stdio and HTTP/SSE communication methods, allowing tool servers (MCP Servers) to run as independent processes fully decoupled from the main application process — this design makes security isolation and permission control easier to implement and provides clear boundaries for enterprises integrating internal tools. Cursor's adoption of MCP as the core interface for Origin's open ecosystem means that third-party developer tools and enterprise internal systems can all be invoked by Cursor agents through a standardized protocol — a critical infrastructure choice in Cursor's evolution toward "platform" rather than "product."

Keeping Code Flowing

Powered by the same intelligent core that drives Cursor, Origin can automatically resolve merge conflicts, fix CI failures, handle comments, and advance each PR to its next step, only @-mentioning you when truly necessary. This reportedly cuts code review time by more than half. Origin is already live internally at Cursor.com and with select design partners, with a full public launch planned for this fall.

Custom Foundation Model: 10–20x Compute Increase, Targeting the Frontier

The third announcement — and the one with the most far-reaching implications — is that Cursor is training its own next-generation foundation model from scratch.

The previous Composer series (Composer 1 through 2.5) already achieved multiple breakthroughs at the model level, including: running RL at scale on target workloads, continuous pre-training on tens of trillions of tokens, and real-time online RL updated every 5 hours.

Real-time online RL (Online Reinforcement Learning) is a model update paradigm as opposed to offline RL. Traditional model training freezes weights after deployment, relying on manual periodic releases for updates; online RL allows models to continuously learn from feedback signals generated by user interactions in production — such as whether users accepted the agent's code suggestions, whether CI tests passed, or whether human reviews requested changes. Updates every 5 hours means Cursor has built a highly automated data flywheel: collect production feedback → automatically construct training samples → update model weights online → canary validation → full deployment. This cycle is far faster than the quarterly model iteration cadence at most companies and is the key mechanism behind the Cursor Composer series' sustained competitiveness in code scenarios.

The Composer series' differentiation strategy focuses on speed and cost. Michael articulated a clear value proposition: if powerful model capabilities are only gatekept by well-capitalized large companies, it would be a "sad world" — he wants individual developers and indie hackers to have access to the best models on the market.

This new custom model represents three fundamental shifts:

• Massive scale: Comparable in size to Claude Opus and the GPT-4 series
• Trained from scratch: Not based on any open-source foundation, fully self-trained for complete control over model behavior
• Compute leap: Using 10 to 20 times more compute than before, in deep partnership with SpaceX

To understand the significance of "training from scratch," it helps to compare the three paths AI application companies use to acquire model capabilities: calling closed-source APIs (such as GPT-4, Claude), fine-tuning on open-source foundations (such as LLaMA, Mistral), and pre-training from scratch. The first two paths are less expensive but carry fundamental limitations — calling APIs means being subject to vendor control over data privacy, latency, and pricing; fine-tuning on open-source foundations is limited by the inherent behavioral patterns formed during the base model's pre-training phase, with constrained room for subsequent alignment adjustments. The core advantage of training from scratch lies in complete control over model architecture, training data, and alignment strategy — for Cursor, this means massively incorporating code execution traces, agent action sequences, test feedback, and other data during the pre-training phase, rather than "patching" a general-purpose model's behavioral boundaries through fine-tuning after the fact. This strategy aligns closely with DeepMind's approach to training the AlphaCode series: rather than bolting programming capabilities onto a general language model, they design data construction and training objectives to prioritize "writing executable, testable code" from the start, enabling the model to form internal representations oriented toward "execution results" during pre-training, rather than merely learning superficial statistical patterns in code text. Pre-training costs for GPT-4-class models are estimated at tens of millions to hundreds of millions of dollars. Cursor's 10–20x compute leap and deep partnership with SpaceX reflect a strategic, high-stakes bet on model sovereignty.

This compute increase is expected to bring Cursor to or beyond frontier capabilities. More importantly, the new model will possess "general intelligence beyond programming" — not just writing code, but using the tools engineers rely on, performing long-horizon planning, actually testing software, and clicking buttons to verify. The model is currently in training, with a release expected soon.

Conclusion: Dual Mastery of Product and Model

Looking across all three announcements, Cursor is completing a full-stack leap from "IDE tool" to "AI programming platform + infrastructure + foundation model."

Michael particularly emphasized that few organizations in AI can design both products and models — most players either come from big tech or start from a research lab and then "reverse-engineer" their way into developer scenarios. Cursor is "developers building for developers" at its core, and for the first time, it's giving this product-driven team the ability to edit not just the pixels on screen, but the underlying capabilities of the model itself.

For the AI programming industry as a whole, this launch signals that competition has entered its next phase: whoever can truly realize the "agents as colleagues" collaboration paradigm will define the future of software development.