Jason Lee

Posted on Aug 16

SpaceX's $60B Cursor Deal Just Closed. Origin, Not the Editor, Is What It Actually Bought.

#git #ai #github #cursor

On August 14, 2026, SpaceX filed an 8-K confirming it had closed an all-stock acquisition of Anysphere, the company behind the Cursor code editor, at a $60 billion valuation. Anysphere shareholders received roughly 389 million shares of SpaceX Class A stock. It is, by a wide margin, the largest acquisition an AI coding company has ever seen, and it closed roughly two months after the deal was first announced.

Most of the coverage since June has focused on the number. Sixty billion dollars for a company that was worth $2.5 billion nineteen months earlier is a genuinely wild trajectory, and it's easy to spend the whole story on that curve. But the acquisition isn't really the product news. The product news happened on the same day the deal was announced — June 16, 2026, at Cursor's first developer conference, called Compile — when Anysphere unveiled three things at once: a public iOS beta called Cursor Mobile, a 1.5-trillion-parameter frontier model trained on SpaceX's Colossus supercomputer, and a git-hosting platform called Origin that Anysphere is positioning as a direct challenger to GitHub.

Origin is the one worth actually reviewing, because it's the one making an architectural bet that will outlast whatever the SpaceX deal does to Anysphere's cap table. It doesn't have a shipping product yet — it's waitlist-only, with general availability promised for fall 2026 — so this is necessarily a review of an announced product, not a battle-tested one. But the bet itself, and the company now bankrolling it, are worth understanding now, before the waitlist opens and the marketing gets louder.

What Origin actually is

Origin is described by Anysphere as a Git-compatible code-hosting and collaboration platform "built for the agentic era" — meaning it assumes the primary actor pushing commits, opening pull requests, and resolving conflicts is an AI agent, not a human sitting at a keyboard. That's a real distinction, not just positioning copy. GitHub, GitLab, and Bitbucket were all designed around a workflow where a human writes code in bursts, commits a handful of times a day, and opens a PR when the feature is done. Origin is being built around a workflow where a dozen agents might be pushing dozens of small commits a minute across a dozen branches, all against the same repository, and where conflict resolution needs to happen without a human in the loop for most of it.

The product sits on top of the Graphite stack, which Anysphere acquired in December 2025. Graphite was a well-regarded, independently venture-backed code review tool built around stacked pull requests — the workflow where you break a large change into a chain of small, dependent PRs that review and merge in sequence rather than as one giant diff. Graphite had spent years building infrastructure specifically for handling large numbers of concurrent, interdependent branches, which turns out to be exactly the primitive you need when several agents are all modifying overlapping parts of a codebase in parallel. Anysphere didn't build Origin's core diff-and-merge engine from scratch; it bought a team that had already solved a version of this problem for humans and repointed it at agents.

How it's built

According to reporting from eesel AI and BigGo Finance, Origin's backend is a deeply refactored version of Graphite's stack, re-optimized for the operation frequency and pattern that agents generate rather than humans: much higher rates of clone, push, and commit calls, smaller and more frequent diffs, and a much higher expected rate of overlapping edits that need automatic reconciliation. The storage layer is described as a hybrid of NVMe and S3 — fast local storage for the hot path of active agent sessions, with S3 behind it for durability and, notably, for supporting a claim of unlimited repository replicas. On top of that, Origin carries over Graphite's stacked-PR model as a first-class primitive, adds AI-driven automatic merge-conflict resolution as a built-in feature rather than a plugin, and exposes the whole thing over both a conventional API and the Model Context Protocol (MCP), so that an agent — not just a human using a CLI or web UI — can drive repository operations programmatically.

The Git-compatibility claim matters more than it might look like at first glance. It means Origin is positioned as a drop-in host, not a replacement for the Git object model itself. Your existing tooling, your CI runners, your local git client — in principle, none of that has to change. That's a meaningfully different bet than what at least one other competitor is making, which I'll get to below.

For readers who haven't used a stacked-diff workflow: instead of building one large feature on a single long-lived branch and opening one large pull request at the end, you break the feature into a sequence of small, dependent branches — each one built on top of the last, each with its own small PR, each reviewable and mergeable independently as soon as it's ready. The chain updates automatically as earlier PRs in the stack land, so you're not stuck rebasing a giant branch by hand. Graphite built its whole product around making that chain manageable for human engineers, who found rebasing dependent branches painful enough that most teams never adopted the workflow without tooling. Origin's bet is that the same underlying primitive — lots of small, dependent, individually mergeable changes — is close to a perfect description of how a swarm of coding agents naturally produces work, whether or not anyone designed it that way on purpose. Where Graphite needed to convince humans to write code in this shape, Origin just needs to accept that agents already tend to.

The announcement in context

It's worth being precise about what happened on June 16, 2026, because the three announcements at Compile weren't separate stories that happened to land the same day — they were presented as one coherent pitch. Anysphere used its first developer conference to reveal Origin, a public iOS beta called Cursor Mobile for monitoring and steering agents from a phone, and a 1.5-trillion-parameter proprietary model trained from scratch on SpaceX's Colossus supercomputer cluster — the same infrastructure SpaceX and xAI have used for large training runs. The SpaceX acquisition was confirmed the same day. Reporting from MLQ News frames all three as pieces of a single strategic move: Anysphere using compute and capital access from its new parent to fund a vertically integrated stack — its own model, its own editor, and now its own hosting layer — in one afternoon, rather than shipping any of them as standalone milestones over separate quarters. Two months later, the closing 8-K on August 14 made the ownership half of that pitch official.

The valuation trajectory underneath all of this is worth sitting with on its own. Anysphere was valued at $2.5 billion in January 2025, $9 billion by that May, $29.3 billion after a $2.3 billion Series D in November 2025 led by Accel and Coatue, and reportedly was in discussions for a $50 billion pre-money round as recently as April 2026 — before SpaceX's $60 billion all-stock offer superseded it. That's roughly a 24x increase in nineteen months, for a company reported elsewhere to be approaching $1 billion in annual recurring revenue. Whatever you think of Origin as engineering, it's being built by a team whose access to capital, compute, and now a defense-and-aerospace-scale balance sheet has changed faster than almost any developer tool company's ever has. That pace is part of why Origin can credibly promise NVMe-class performance and "unlimited" replicas for a product that doesn't have paying customers yet — and part of why it's worth asking harder questions about governance and pricing than you would of a bootstrapped competitor.

Why this is happening now: GitHub is genuinely straining

The instinct to be skeptical of "we rebuilt X because it's the agentic era" pitches is a healthy one — plenty of 2026 SaaS marketing has bolted the word "agentic" onto features that don't need it. But in this case there's independent reporting backing up the premise. The New Stack reported that Cursor, GitLab, and Zed all independently arrived at the same diagnosis in mid-2026: the most popular git hosts are buckling under load that has nothing to do with human developer growth. It's not more engineers cloning and branching — it's dozens or hundreds of agents hitting the same repository simultaneously, each one wanting to clone, branch, push, and query far more often than a human ever would, and often wanting to interrogate the full history and structure of a repo without needing a full local checkout to do it.

That's a real, load-bearing infrastructure problem, and it's genuinely useful that three separate, well-funded teams converged on "the current git-hosting model doesn't hold up under agent-scale traffic" independently. What's more interesting is that they didn't converge on the same fix.

Three different bets on what comes after GitHub

Cursor's Origin keeps the Git object model and the pull-request mental model, but rebuilds the hosting layer underneath for agent-frequency operations and makes stacked diffs and automated conflict resolution native rather than bolted on.
GitLab's "Project Switch," reported to be in private beta as "Next Generation Source Code Management," takes a more conservative approach: it keeps the Git protocol itself intact but reworks the architecture so agents can query and interrogate a repository's contents without pulling a full local copy first. GitLab's public claim, per the same New Stack reporting, is up to 50x faster per-agent task execution as a result.
Zed's DeltaDB is the radical option. It throws out the commit as the atomic unit of history entirely and replaces it with a continuous stream of fine-grained deltas, each one linked directly to the agent conversation that produced it. That's a genuine break from forty years of how source control has represented change, and it implies real migration cost for anyone who adopts it.

Put next to each other, this is a legitimate architecture debate playing out in public, not a marketing skirmish. Origin is the middle path: more disruptive to the underlying storage and merge model than GitLab's approach, but far less disruptive to your existing mental model and tooling than Zed's. That middle position is probably Origin's strongest single selling point — you get agent-scale performance without needing your CI pipeline, your git blame habits, or your existing GitHub Actions workflows to understand a fundamentally new unit of history.

Why developers should actually care

Cost. Anysphere has not published Origin pricing, and given the company's track record on pricing communication this year — more on that below — that absence is worth flagging rather than glossing over. Everything currently public is architecture and positioning, not a price sheet.

Latency and scale claims. The NVMe-plus-S3 hybrid and the "unlimited replicas" framing are real engineering choices aimed at a specific bottleneck: agent workloads generate far more read/write operations per unit of human-authored code than traditional development does. If you're running even a handful of coding agents against a large monorepo today, you've probably already felt GitHub or GitLab rate-limit you or slow to a crawl during a burst of automated activity. Origin is explicitly built to not do that. GitLab's 50x figure for Project Switch, even if you discount it as a vendor benchmark, tells you the whole industry now considers this a solved-badly problem worth quoting big numbers about.

Developer experience. Native stacked diffs plus automatic conflict resolution is a genuinely useful pairing for the failure mode agentic coding produces most often: five agents each touching adjacent files, generating a pile of small, overlapping, individually reasonable diffs that a human then has to untangle. Graphite's team built years of tooling specifically for "many small dependent changes," and folding automatic resolution into that instead of leaving it to a human reviewer is a sensible use of the acquisition.

Lock-in. This is the part the announcement glosses over and the part I'd weight most heavily. If you adopt Origin, you are putting your source code, your AI coding model, your editor, and increasingly your compute all under one corporate roof — a roof that, as of August 14, 2026, belongs to SpaceX. Git-compatibility means you could in theory migrate your repository history elsewhere without a rewrite, which is a real mitigation. But the stacked-diff workflow, the MCP integration your agents are wired into, and any CI you build against Origin's API are not portable the same way. The more of Cursor's stack you adopt — editor, model, and now host — the more expensive leaving any single piece becomes.

Security and maintainability. A single vendor now controls the editor that writes your code, the model that suggests your code, and (soon) the host that stores your code. That's operationally convenient and also a genuine concentration-of-risk story: one outage, one policy change, or one acquisition-related restructuring touches your entire toolchain at once rather than one link in it. It's also worth sitting with the fact that this vendor is now a subsidiary of a company whose core business is aerospace and defense-adjacent infrastructure — a very different regulatory and reputational profile than Microsoft-owned GitHub or an independent GitLab. Nobody involved has said anything public yet about what that ownership structure means for teams outside the US, or for companies with any sensitivity about whose balance sheet their source code sits on. That's not a claim that there's a problem — it's a claim that the question hasn't been answered, and it's a reasonable one to ask before you put a production repo on a waitlist.

Practical use cases

Origin's pitch is most compelling for teams already running multiple coding agents in parallel against the same codebase — AI-native startups, agencies doing heavy Cursor-based development, or any team that's already hit GitHub rate limits from automated activity. A few concrete shapes this takes in practice:

Multi-agent feature squads. A team runs several agents against the same repo simultaneously — one refactoring a module, one writing tests against it, one updating docs — and needs the resulting diffs to land as a reviewable, dependency-ordered stack rather than three colliding PRs against the same files.
Overnight batch agent runs. Teams that queue up dozens of small, independent agent tasks (dependency bumps, lint fixes, migration scaffolding) overnight need a host that can absorb a burst of hundreds of small pushes without rate-limiting or queuing them behind human traffic the next morning.
Agent-driven CI feedback loops. Where an agent needs to read CI results, patch a failing test, and re-push in a tight loop dozens of times per task, the API/MCP surface matters more than the web UI — this is a workflow optimized for a program talking to the host, not a person clicking around it.

If your current workflow is one or two developers occasionally using GitHub Copilot or Cursor's own autocomplete, none of Origin's architecture is solving a problem you have. The product is squarely aimed at the "we have a dozen agents committing all day and our git host can't keep up" segment, which in mid-2026 is a real and growing segment, but still a specific one — most individual developers and small teams are nowhere near the traffic pattern Origin is built for.

What the marketing leaves out

A few things are worth naming plainly:

It isn't shipped. Everything above is Anysphere's own description of an architecture, plus reporting on that description. There's no independent benchmark of Origin under real agent load, no GA pricing, and a waitlist rather than a product. Fall 2026 is the stated target, which as of this writing is a few weeks away — but "a few weeks away" has slipped before in this industry.
Stacked diffs have a real adoption cost. Graphite spent years as an independent product trying to get teams to adopt stacked PRs, and it's a workflow with genuine learning curve for engineers used to single, unified pull requests. Making it the default primitive for Origin doesn't remove that learning curve — it just means you inherit it the moment you sign up, whether or not your team has used Graphite before.
Anysphere's pricing communication track record is rough. Independent of Origin, Cursor spent much of 2025 and 2026 dealing with user backlash over confusing, credit-based pricing changes — including a Reddit post from Anysphere itself acknowledging that "our recent pricing changes for individual plans were not communicated clearly" after users reported bills jumping unpredictably. Anysphere restructured Teams pricing again as recently as June 2026, splitting usage into separate first-party and third-party model pools with a new $120/month Premium seat, explicitly to address the predictability complaints. None of this is disqualifying on its own, but it's relevant context for how much trust to extend a "pricing coming later" promise on a product that will host your source code.
The vertical integration story cuts against the "open, git-compatible" framing. Anysphere is simultaneously telling developers "your code stays portable because we kept Git compatibility" while building an editor, a proprietary 1.5-trillion-parameter model, and now a host that all work best together and are all owned by the same company. Those two messages aren't contradictory exactly, but they're in tension, and it's worth watching which one wins out as Origin actually ships pricing and default settings.

Competitive read

Against GitHub, Origin's advantage is architectural focus on a workload GitHub wasn't designed for, backed by a well-regarded acquired team. GitHub's advantage is everything Origin doesn't have yet: a functioning product, a mature security and compliance track record, and a network effect built over 18 years that a waitlist product can't touch on day one.

Against GitLab's Project Switch, Origin is making a bigger architectural change (new storage and merge model) for a bigger claimed payoff, while GitLab is making a smaller, protocol-preserving change that's easier for existing GitLab customers to adopt incrementally. GitLab's approach is the safer bet for a team that doesn't want to re-learn its git host; Origin's is the higher-ceiling bet for a team already comfortable inside the Cursor ecosystem.

Against Zed's DeltaDB, Origin looks conservative. DeltaDB is the only one of the three actually proposing to replace the commit as the unit of history, which is either the correct long-term answer or a bet that asks for far more migration pain than most teams will tolerate. Origin's Git-compatibility is a hedge against that risk that DeltaDB explicitly declines to take.

Independent read

Strip away the SpaceX headline and Origin is a reasonable, well-resourced answer to a real infrastructure problem: git hosting genuinely wasn't built for agent-scale traffic, and buying Graphite's team to solve it is a sound piece of technical strategy. What's less reasonable is treating this as simply "GitHub, but for agents." It's the third leg of a vertically integrated stack — editor, model, host — being assembled by a company that went from a $2.5 billion valuation to a $60 billion all-stock acquisition by a rocket company in under twenty months, and that spent a meaningful chunk of that same period apologizing to its own users for unclear pricing. The technology is credible. The trust required to hand it your entire source-control layer, sight unseen, with no public price and an ownership structure nobody's fully reckoned with yet, is a separate question, and the announcement doesn't answer it.

Who should try it, wait, or ignore it

Try the waitlist if you're already deep in the Cursor ecosystem, running multiple agents against a shared repo, and have already felt GitHub or GitLab choke under automated load. You have the most to gain and the least additional lock-in to absorb, since you're already committed to Cursor's model and editor.

Wait if you're a small team or solo developer whose git usage is still human-paced. Nothing about Origin's architecture solves a problem you currently have, and waiting costs you nothing while pricing, GA stability, and the SpaceX-ownership questions get answered by people ahead of you on the waitlist.

Ignore it if code custody, data residency, or vendor concentration are things your organization has to answer for — regulated industries, government-adjacent work, or any team that already has a policy against single-vendor lock-in across its toolchain. Git-compatibility gives you a technical exit ramp; it doesn't give you an answer to who owns the company holding your keys in the meantime.

If you want to watch this space without committing anything, the three-way architecture fight between Origin, GitLab's Project Switch, and Zed's DeltaDB is worth tracking on its own merits — it's the first time in years that "how should a git host actually work" has been a genuinely open, actively contested question instead of a solved problem everyone just uses GitHub for.

Discussion: If you're running multiple coding agents against a shared repository today, what's actually broken first for you — git host rate limits, merge-conflict volume, CI queue time, or something else entirely? And does a Git-compatible rebuild like Origin fix that, or does the fix have to look more like Zed's clean break from commits?

Sources:

DEV Community