I started building an agent operating system ten weeks ago. I do not have an eighteen-month track record. What I have is a short runway, a close view of the wrapper class about to get cut, and ten weeks of watching the same architecture decisions land the same way for me as they're landing for everyone else.
This is the version I see now, with the standardization-window clock ticking against my burn.
The receipt that broke the wrapper thesis
Cursor crossed a billion dollars in annualized revenue in seventeen months. That is the fastest run to a billion in the history of business-to-business software. The previous record-holder, Wiz, took twenty-two. By February of this year the number had doubled to two billion, against roughly three hundred employees.
That works out to about $6.7 million in revenue per employee.
Apple does $2.4 million. The median private SaaS company does $129,000. WhatsApp at acquisition, long the gold standard for what a small team with a great product could produce, did $1.6 million.
The story everyone is telling about why Cursor's numbers look like this is wrong. They say it's the harness — the diff gate, Plan Mode, .cursor/rules. They say the model layer commoditized and the wrapper layer captured the surplus. They are half right. The other half is that Cursor stopped being a wrapper.
Composer 2.0 shipped earlier this year. Composer 2.5 is in production. Cursor is on xAI's inference infrastructure. The company that built its first billion in revenue wrapping Anthropic's API is now training its own substrate.
If the wrapper layer was the whole story, you do not start a model-training program.
Cursor did. So the wrapper thesis is incomplete. The cognition era does not pay for one bet. It pays for three.
Three bets, in order
Software in the 1980s required one bet. You wrote the application — Excel, Photoshop, dBase — and you won or lost on the application. The hardware underneath was Intel. The OS was Microsoft. Both were generic, both were someone else's problem, and you did not have to think about either.
Software in the 2000s required two bets. The application and the distribution. iOS lock-in. App Store ranking. Network effects on the consumer side. You wrote the app and you owned a channel. Pick one and you became a feature. Pick both and you became a category.
Software in the cognition era requires three. Distribution. Workflow. Model. Pick one and you are a demo. Pick two and you build a real company for two years before the substrate gets pulled out from under you. Pick three, in the right order, with the right cash to fund the third on the back of the first two — and your cap table looks like Cursor's.
The reason is the substrate. In every prior wave of software, the substrate underneath you was generic. Intel sold the same chips to everyone. AWS rented the same servers to everyone. You did not have to control silicon to ship Excel, because Excel did not need anything specific from silicon. You did not have to control data centers to ship Instagram, because Instagram did not need anything specific from the data center.
The substrate in this era is cognition. Cognition is not generic. The shape of work you sell determines the shape of inference you need. The model vendor cannot ship every shape, so the vendor ships the average. Your product is forever bottlenecked by the vendor's average — unless you start producing your own.
This is the first wave of software in fifty years where the substrate is not generic. That is the whole shift. Everything else is a consequence.
Bet one: distribution
In March 2022, two engineers named Michael Truell and Sualeh Asif released the first build of an AI code editor. Three months earlier, GitHub had launched Copilot. Microsoft's distribution. Microsoft's capital. An exclusive partnership with OpenAI. By every theory of how software markets work, that fight was over before it started.
Then Cursor forked VS Code.
Switching cost: zero.
Your keyboard shortcuts still work. Your extensions still load. Your settings sync over. Your Git pane sits where it sat yesterday. You install Cursor and you are shipping in sixty seconds, because you have been using Cursor for three years — you just called it VS Code.
By the time the model-warrior cohort understood what had happened, Cursor had inherited Microsoft's seventy-five million developer install base for free. The fork was not a feature decision. The fork was the strategy.
GitHub Copilot bolted an AI panel onto VS Code. Cursor rebuilt VS Code around the AI panel. From the user's keyboard, the difference was invisible. From the cap table, the difference was a couple of billion dollars in annualized revenue.
The startups racing to ship "AI-native" rewrites of every tool in the developer's stack — new IDEs, new shells, new browsers, new email clients — are running into the same wall every Slack-killer hit in 2017 and every Office-killer hit in 1995. Users do not want a better tool. Users want a better version of the tool they have. Forks ship that. Rewrites do not.
The graveyard of ground-up AI-native IDEs from 2022 to 2024 is the receipt. Nobody can name three of them.
Cognitive switching cost is the single most underpriced variable in 2026 startup strategy. The fork was the lever. The lever bought time. The time funded what came next.
Bet two: workflow
Cursor's surface is easy to clone. Every feature Cursor ships gets cloned by someone within six weeks. Plan Mode? Cloned. .cursor/rules? Cloned. Diff gate? Cloned. Parallel agents on worktrees? Cloned within a quarter.
The clones do not work.
The thing the clones miss is the integration discipline between the features. The eval cadence that catches regressions before they ship. The model routing that puts the right inference on the right slice of work. The patience to keep the autonomy levels matched to the task instead of cranking them to maximum because the demo looks better that way. The features are public. Cursor's engineering blog documents most of them. The discipline is not, because you cannot copy it by reading about it. You can only build it by running it, and the running is what makes Cursor faster on production and slower on commit than every competitor with the same underlying model.
Linear's product team has been saying this since 2024: the magic isn't the model, it's how you build the frame around it so the median outcome is consistently great. Linear optimizes for the median, not the peak. The harness is what produces the median. The model is what produces the variance.
BCG put a number on it: ten percent of AI deployment value comes from the model, twenty percent from the infrastructure, seventy percent from the workflow design and the organizational processes around it. The companies that internalize the 10-20-70 ratio get 2.1× greater ROI than the companies that don't.
Cursor spent three years pouring engineering hours into the seventy percent while the surface-clones were still polishing the ten. By the time the clones realized which game was being played, Cursor was at two billion in annualized revenue and the door was closed.
This is the part of the story the wrapper thesis gets right. The harness is where the surplus lands during the standardization window. The standardization window is a real thing and it is open right now.
It is also closing.
Bet three: model
This is the part that breaks if you read the Cursor story too cleanly.
If the harness is where value is captured, why does Cursor train its own models?
Because the harness is where value is captured for now. The substrate underneath — the model — is commoditizing on a monthly cycle, faster than any prior platform layer in software history. Once the substrate finishes commoditizing, the wrapper companies that don't own a piece of the substrate become customers of whoever does. Customers do not capture surplus. Customers pay for surplus.
Wrappers, structurally, are customers. Wrappers pay API rates. Wrappers depend on the vendor's roadmap. Wrappers cannot ship features the vendor's API does not expose. Wrappers cannot run their inference at the latency they want, because the vendor is queuing inference for ten thousand other wrappers on the same physical hardware. Wrappers do not own their unit economics.
And the vendor watches.
Anthropic ships Claude Code. OpenAI ships Codex. Both compete directly with Cursor on the same work. The wrapper-versus-vendor relationship is not stable, because the vendor has the model and the wrapper does not, and the vendor concludes — correctly — that they could capture the wrapper's revenue themselves by removing the wrapper.
The way a wrapper survives the endgame is to stop being a wrapper.
Composer is not a moat. Composer is permission to keep playing. Once you train your own substrate for the slice of work you sell, the upstream vendor's competing product is no longer existential. You can use commodity models when they're better. You can use your own when they're cheaper. You can swap inference partners when the latency shifts. You are no longer at the upstream vendor's mercy.
This is the bet most of the wrapper class is about to miss. They spent the standardization window optimizing the workflow, and now they have neither the engineering capacity nor the cash to start a model-training program with twelve-to-twenty-four-month payoff cycles. The vendors are about to ship the competing products. The clock starts.
Watch the price of wrapper companies that don't have a model program land hard somewhere in late 2026 or 2027. The receipts are coming.
What skipping each bet costs
Skip distribution. You spend three years teaching users a new editor while a competitor with the same model grafts onto the surface you didn't take. Every AI-native IDE startup from 2022 to 2024 made this mistake. None of them are household names. The fork was free. The rewrite cost the company.
Skip workflow. Your distribution advantage evaporates the day a better-funded entrant ships the same product on the same model. Every GPT wrapper that won the first ninety days and then got eaten when the next model release shipped made this mistake. The harness was the difference between a one-quarter window and a five-year compounding curve. They did not build it. They did not get the years.
Skip model. You become a permanent customer of someone whose business model includes competing with you. This is the bet the wrapper class is about to learn the hard way, and the timing is going to be brutal because the wrappers found out about the bet at exactly the moment they could no longer afford it.
There are also companies walking the order backwards. Anthropic and OpenAI both have the model. Both are building the workflow. Both are now trying to graft onto IDE distribution through VS Code and JetBrains integrations. They might pull it off. The integration cycle for distribution is shorter than the integration cycle for in-house inference, so the backwards walk is structurally easier than skipping a step forwards. But the surface they're trying to graft onto is already grafted, and the operator who got there first is now training models. Watch which way that race goes.
The window
I have not personally made every wrong bet in this essay. Ten weeks is not enough time to. What I have done is watch the wrapper class around me make the real version of these mistakes with seven and eight figures of capital, and read the cap-table receipts that compile when they do.
The clearest argument anyone in this space can make right now is the one made by someone whose runway is short enough that they cannot afford to be wrong about which layer holds value and which one evaporates. The cognition era pays for three bets, in order, on the same cap table. Skip one and you do not get a smaller version of the prize. You get cut.
The defaults of the next decade get set in the next three years. The standardization window for cognition is on a five-year clock, not a fifty-year clock. Cursor is one of maybe twenty companies that are going to come out of this window owning a piece of the substrate, a piece of the workflow layer, and a piece of the surface developers actually use. The rest of the wrapper class is going to be feature-of-the-week on whichever vendor's roadmap absorbed them.
The wrappers ate the world. Now they're eating themselves. The ones that own a piece of every layer are the ones that survive their own appetite.
If you are building in this space, the only honest question is which bet you are on right now, which one is next, and whether you have the runway to make all three before the window closes. That is the entire game. Everything else is a story we tell ourselves while the receipts compile.
The wand is in your hand. The acts are open. The clock is running.
