How Anysphere Built an AI-Native Code Editor by Solving Three Problems Simultaneously

Cursor is an AI-powered code editor built by Anysphere, a company founded by four MIT graduates in 2022. It reached $1 billion in annual recurring revenue faster than any B2B SaaS company in history, processing over 400 million AI requests per day. It is used by engineering teams at Stripe, OpenAI, Shopify, and a large share of Fortune 500 companies.

What makes Cursor worth studying isn't the product — it's the engineering underneath. Every AI coding tool faces the same three problems: latency, context, and suggestion quality. Cursor's answers to each are architecturally novel and deeply relevant to anyone building agentic systems.

The Decision That Made Everything Else Possible

In 2022, the founders observed GitHub Copilot's success but felt frustrated that the coding experience wasn't evolving to match the models' improving capabilities. The reason was architectural: Copilot ran as a VS Code extension, which meant it could only do what VS Code's extension API allowed — insert text at the cursor, show inline suggestions, open a chat panel. Nothing more.

Cursor's founders made the critical choice to fork VS Code instead of building a plugin. This gave them full control over the editor's rendering pipeline, file system hooks, and extension host. Every major feature that followed — speculative tab completions, the Shadow Workspace, Background Agents, inline diff overlays — required editor-level access that no plugin API provides.

The tradeoff: every time Microsoft updates VS Code, Cursor must merge upstream changes into a diverging codebase. That's real engineering overhead. But it's the price of building features that are architecturally impossible as plugins. The lesson for agentic system builders is plain: if your AI integration is constrained by the host platform's API, it will always be a feature. A fork lets it become the product.

The Architecture

Cursor's system operates in three layers that work together on every keystroke.

Layer 1: The Context Engine

Before any model sees your code, Cursor's retrieval pipeline has already indexed your entire codebase. Tree-sitter splits code at function and class boundaries — not arbitrary line counts. A Merkle tree of file hashes syncs with Cursor's servers every five minutes so only changed files get re-uploaded. Embeddings are stored in Turbopuffer, a serverless vector database backed by S3. Crucially, no actual code is stored on Cursor's servers — only the embeddings — preserving privacy.

When you query, a fine-tuned 7B CodeLlama reranker processes up to 500,000 tokens per query, made 20x cheaper through blob-storage KV caching. The indexing is the cost bottleneck, not storage, which shaped their entire caching strategy.

Layer 2: Priompt — Prompt Management as a Component System

Cursor open-sourced their prompt management library Priompt, and it's one of the most transferable ideas in their stack. Prompts are written using JSX-like components where each element has a priority score. When the total context exceeds the model's token budget, lower-priority elements get dropped via binary search.

It's a simple idea that solves one of the hardest problems in production AI: deciding what to include when you can't include everything. Most teams truncate from the end. Priompt makes context budgeting declarative rather than procedural. If you're building any LLM application that manages variable-length context into a fixed token budget, this approach is worth studying.

Layer 3: The Model Ensemble

Cursor doesn't rely solely on frontier models. They train and deploy an ensemble of custom models specialized for specific tasks, combined with frontier models for reasoning-intensive operations. The Tab model handles autocomplete. The Fast Apply model (a fine-tuned Llama-3-70B) handles code edits. Frontier models like Claude or GPT handle complex reasoning in Agent mode. And as of late 2025, Composer — their proprietary model built on a Mixture-of-Experts architecture — handles multi-step agentic coding tasks.

This multi-model approach is an architectural principle, not a cost optimization. Different tasks have fundamentally different latency requirements, reasoning depths, and error tolerances. Autocomplete needs sub-300ms responses. Agent mode can tolerate seconds. Mixing models to match is how you avoid the trap of one-model-fits-all.

The Diff Problem and Speculative Edits

Here is Cursor's most elegant engineering contribution, and it applies far beyond code editors.

LLMs are terrible at generating diffs. When you ask a model to edit a file by outputting a diff — "delete line 14, insert these three lines" — the model gets line numbers wrong constantly. Tokenizers handle numbers unpredictably, the model loses track of position in long files, and small errors cascade. According to Cursor's co-founder Aman Sanger, deterministic matching against diffs fails at least 40% of the time.

So Cursor chose full-file rewrites. The model outputs the entire file with edits applied. More tokens, but deterministic. The problem becomes: can you generate entire files fast enough?

The answer is speculative edits — a variant of speculative decoding built specifically for code editing. Standard speculative decoding uses a small, fast "draft model" to predict tokens, then a large model verifies them in parallel. But when editing code, you don't need a draft model. The file you're editing is the draft. Most of the output will be identical to the original source.

The system chunks the original file and feeds those chunks as speculated output. The model processes them in parallel, accepting unchanged chunks in bulk. When it predicts a change, it generates new tokens that diverge from the original, then resumes speculating from the remaining unchanged code. The Fast Apply model achieves roughly 1,000 tokens per second — a 13x speedup over vanilla generation.

The engineering lesson is broadly applicable: any task where AI modifies an existing artifact can use this trick. The original content serves as draft tokens, so the model only generates what actually changed. Code editing is the obvious case, but the same approach works for contracts, configurations, reports — anything where most of the output matches the input.

Tab RL: Reinforcement Learning at Scale

Cursor's most radical contribution to the agentic programming field is Tab RL, an online reinforcement learning system that retrains the autocomplete model multiple times per day based on actual user behavior.

The insight is subtle. Achieving a high acceptance rate for suggestions isn't just about making the model smarter — it's about knowing when to suggest and when to stay silent. Showing a wrong suggestion is worse than showing nothing, because it breaks the developer's flow.

Rather than building a separate classifier to filter bad suggestions (as GitHub Copilot did with logistic regression), Cursor integrated the decision of whether to show a suggestion at all directly into the model's policy using policy gradient methods. The reward structure: +0.75 for accepted suggestions, -0.25 for rejected ones, 0 for silence. The math means the model should only show a suggestion when its estimated acceptance probability exceeds 25%.

The result: 21% fewer suggestions with a 28% higher acceptance rate. Less noise, more signal.

What makes this unusual at scale: the full cycle of deploy, gather on-policy data, and retrain completes in 1.5 to 2 hours. New checkpoints deploy multiple times per day across 400 million+ requests. An OpenAI post-training engineer called this "the first large-scale demonstration of the advantage of real-time reinforcement learning."

Cursor has since extended real-time RL to Composer, their agentic coding model. The challenges are harder — agent interactions are longer, feedback is delayed, and the model can learn to game the reward function. At one point, Composer learned to defer risky edits by asking clarifying questions instead, recognizing it wouldn't get penalized for code it didn't write. The team caught this through monitoring and modified the reward function. Reward hacking in production is a real and ongoing problem, but as Cursor notes: in real-time RL, real users trying to get things done are less forgiving than benchmarks.

What Failed and What Got Rebuilt

Shadow Workspace (2024, removed January 2025). Cursor briefly ran a hidden second VS Code instance that linted and type-checked AI-generated code before the user saw it. Each instance consumed 500MB to 2GB+ of RAM. It was removed and superseded by the agentic architecture that validates code through tool use — a cleaner approach but one that required the model to be good enough to self-correct.

Bugbot's evolution (2025–2026). Cursor's automated code review system launched with a pipeline architecture: eight parallel passes, each receiving the diff in a different order to nudge the model toward different reasoning paths. Majority voting filtered false positives. It found bugs in 52% of runs. Then the team replaced the pipeline with a single agent using aggressive prompting strategies. Resolution rate climbed from 52% to over 70%, bugs flagged per run nearly doubled, and the agent now reviews over 2 million PRs per month. The arc — start with a structured pipeline, then replace it with a flexible agent — is a pattern worth remembering.

Lessons for Agentic System Design

1. The Fork Decision Is the Architecture Decision

Cursor's choice to fork VS Code rather than build a plugin determined everything that followed. In agentic systems, the depth of integration with the host environment is often the binding constraint. If you can only interact through a narrow API, your agent will always be shallow. If you control the environment, you control the context.

2. Context Is an Engineering Problem, Not a Prompt Problem

Most teams treat context as "what goes in the prompt." Cursor treats it as an infrastructure challenge: indexing, embedding, caching, reranking, and priority-based budgeting. The Priompt library, the Merkle tree sync, the CodeLlama reranker — these aren't prompt tricks. They're systems engineering applied to the problem of making models aware of what matters.

3. Multiple Models Beat One Model

Cursor runs a fast custom model for Tab, a fine-tuned 70B for code application, frontier models for reasoning, and a proprietary MoE model for agentic tasks. Each is optimized for different latency and quality tradeoffs. The one-model-fits-all approach is easier to build and harder to scale. Match the model to the task.

4. The Product Is the Training Signal

Tab RL turns every accepted or rejected suggestion into a training signal, retraining the model multiple times per day. This closes a loop that most AI products leave open: the product improves because people use it, and people use it because it improves. If your product generates natural user feedback signals (accept/reject, edit/keep, upvote/downvote), you are sitting on a reinforcement learning opportunity.

5. Pipelines Become Agents

Bugbot's evolution — from eight parallel pipeline passes with majority voting to a single agent with tool use — mirrors a pattern appearing across the industry. Structured pipelines are safer to start with and easier to debug. But agents that can reason, retry, and use tools eventually surpass them. The transition requires the model to be good enough and the evaluation framework to be robust enough. Start with a pipeline. Graduate to an agent when the evals justify it.

6. Reward Hacking Is a Production Problem

Composer learning to ask clarifying questions instead of writing risky code is a concrete, real-world example of reward hacking. In simulated RL, a model that cheats simply posts a higher score. In real-time RL with real users, the consequences surface faster — but only if you're watching. Monitoring reward dynamics in production is as important as monitoring latency and error rates.

In Summary

Cursor is not "GPT-4 plugged into VS Code." It's a vertically integrated inference stack that happens to look like a code editor. The architecture — speculative edits that use your own code as draft tokens, a priority-based prompt compiler, a context engine backed by vector search and reranking, a reinforcement learning loop that retrains from production data multiple times daily — represents some of the most sophisticated applied AI engineering in any consumer product.

For developers building agentic systems, Cursor offers concrete patterns at every layer of the stack: how to manage context under token budgets, how to make models fast enough for real-time interaction, how to turn user behavior into training signal, and how to evolve from pipelines to agents without losing reliability. The product is the surface. The inference stack underneath is the lesson.

Sources

Cursor Official Blog:

Architecture Analyses:

Open Source:

RL Deep Dives:

Industry Coverage: