What happens to code hosting when people stop writing the code? That is exactly the question Cursor is answering with its new project. Cursor announced a platform called Origin on X. A place where teams and AI agents can store, browse, and collaborate on code. The post sparked a debate about what code approval and conflict resolution will look like, and whether Microsoft and its GitHub will finally face serious competition.
Let's take a look at what we really know about Origin.
How Cursor Got Us Here
Before Origin, there was Cursor. An AI-centric code editor that changed programmers' work more than anything since the arrival of VS Code itself. It launched publicly in 2023 and integrated a conversational model directly into the editor. No more copying answers from a chat and pasting them into a project. You write code, press Tab, and the model completes it. You select a block, press Ctrl+K, and describe what you want. No switching between windows.
The results were measurable. Early users reported a 30 to 50 percent increase in coding speed for routine tasks. More importantly, however, the nature of the work itself changed. Developers began delegating entire modules, not just individual lines. They described what they wanted in plain language and then reviewed the result instead of typing every character themselves. The code author gradually became its reviewer and director.
In 2025, Cursor added agents running in the background. Fully autonomous sessions that took a task from GitHub, programmed a feature, ran tests, and opened a pull request. All without a human. This turned the logic upside down. Code review was no longer about one person reading what another person had written. Increasingly, a person approved the work of a machine, or a machine reviewed the work of another machine and a person merely signed off on it.
Origin is a direct consequence of this change. Once agents are producing pull requests at scale, the place where those requests land becomes a bottleneck. And GitHub was not built for that.
What Origin Actually Is
At its simplest, it is a repository hosting service, a space for reviewing pull requests, and a place to collaborate on changes. It sounds like GitHub. It is supposed to sound that way, and then diverge from it in every important assumption.
The difference lies in whom the platform is built for. GitHub was created in 2008 for people. For programmers who write code, open pull requests, leave review comments, and merge branches after reading the differences between versions in a browser. Every interface you interact with there is optimized for a person making decisions based on text they have read.
Origin is being created in 2026, after the rise of agentic programming. In the world Cursor knows from the inside, a large portion of code is now written by agents running autonomously. They implement features, fix bugs, and open pull requests. And the people reviewing that code often do not read every line. They decide whether to approve the agents' work in bulk or delegate the review to another agent.
The Weakness GitHub Cannot Easily Patch
One comment under the announcement captured the real problem better than any product description. User @subramanya wrote: if agents are the primary users, the hard part is review, merge, and conflict state that machines can understand. Not another attractive repository interface.
And that is the heart of the matter. GitHub can add automated code review features, and it has done so repeatedly. But its entire pull request data model is based on human reasoning. A diff is a visual, line-by-line representation of changes. A merge conflict is a text file with <<<<<<< markers. A review comment is a string attached to a line number. None of this is easy for a machine to interpret semantically.
For an agent to resolve a merge conflict, it must understand why the conflict arose. Which intent from branch A is incompatible with the intent from branch B, and what the correct solution is in light of both changes. Markers in line-by-line diffs do not reveal this. And a comment such as "something about this doesn't feel right" certainly does not. That is why agentic code review would need several things at once:
- A structured, semantic representation of changes. Instead of a raw text diff, changes would be described as objects: a function signature changed, an interface was modified, a dependency was added, test coverage shifted. An agent can reason more reliably about such a description than about plain text.
- Machine-readable merge state. When two branches conflict, the system should be able to describe the issue semantically. For example, branch A changes the return type of the
processPayment()function toPromise<Result>, while branch B adds a synchronous call to the same function that assumes it does not return a Promise. The agent can then propose a solution based on intent rather than by comparing individual characters. - A predictable review interface. Human pull request review is vague. Reviewers approve changes after a cursory read, write ambiguous comments, and merge with unresolved threads. Agentic review needs clear criteria. Does the change meet the specified requirements? Does it satisfy all defined conditions? Did the tests pass? A machine can answer these questions reliably.
- Traceable authorship and a record of decisions. When an agent opens a pull request, the review system should capture not only the code change but also the context behind the decision. What instructions the agent received, what state of the code it considered, and which alternatives it evaluated. Only then does human oversight make sense, because the reviewer assesses the agent's reasoning, not just its output.
None of this requires inventing new Git protocols. It requires rethinking what a collaborative interface built on Git should look like when agents are full-fledged participants.
The Missing Link in the Chain
At the beginning of 2025, artificial intelligence tools were primarily assistants. Line completion, suggestions while typing, rewriting through chat. By the end of 2025, the focus had shifted to autonomous agents. Cursor's background agents, autonomous programmers in the style of Devin, and enterprise deployments of agentic pipelines. And by mid-2026, companies operating these pipelines are producing pull requests faster than people can review them. A single engineer may oversee dozens of agent-generated requests per day.
The bottleneck is no longer writing code. It is reviewing and merging. And that layer currently sits on GitHub, which was not built for this level of demand, this model of authorship, or this style of review.
Cursor, meanwhile, owns the editor. It sees up close how its users create code, what their agentic workflows look like, and where the friction occurs. Building Origin is a logical step from this position. It means taking control of the next bottleneck in the chain.
There is also a competitive dimension. GitHub belongs to Microsoft. VS Code belongs to Microsoft. GitHub Copilot belongs to Microsoft. And Cursor competes with all three. Building on GitHub means that Cursor users depend on a competitor at the exact code-hosting layer. The deeper agentic workflows extend into that layer, the more uncomfortable that dependency becomes. Origin is, among other things, a bet on integrating the entire stack. Owning the editor, owning the hosting, and owning the agentic workflow from beginning to end.
Community Reaction
The announcement on X prompted a wide range of reactions, from which several themes emerged. Some people immediately described Origin as a GitHub competitor. One comment called it an attempt to avoid dependence on Microsoft. That is probably accurate and probably intentional.
Then there were the technical skeptics. @subramanya's aforementioned comment that the hard part is machine-readable conflict state rather than another interface points to a genuine engineering challenge. Building a more attractive GitHub with a few smart features would not be Origin. Building a truly new data model for agentic collaboration is a multi-year undertaking. And the community is right to watch what Cursor ultimately delivers.
Some also noticed the play on the name. Origin overlaps with Blue Origin, Jeff Bezos's space company, and will probably bury it in search results. Perhaps it is a coincidence, or perhaps it is a cleverly chosen name evoking the "origin of the agentic era."
And the most substantive praise came from engineers who had already encountered the limits of GitHub's human-centric design while running agentic pipelines on it. They are not excited about another Git interface. They are excited about infrastructure that treats agents as full-fledged participants rather than as artificial intelligence bolted onto a system designed for people.
Who Origin Is For
For teams already deploying Cursor agents. If background agents in your organization generate pull requests, implement features from tickets, or run in test-and-fix loops, you are the primary target audience. Origin promises to close the loop. The same platform that creates the code also hosts it and guides it through review and merging, while preserving the context of the agent's work throughout the entire process.
It is also for companies drowning in AI-generated pull requests. Human review capacity is not growing at the same pace as code production. A system that can send agent-generated requests to another agent for preliminary review and involve a person only at the approval gate is a direct answer to this problem.
And finally, it is for companies concerned about their dependence on Microsoft. Microsoft's ownership of GitHub is a sensitive issue for some of them, especially where Microsoft is also a competitor or a factor in service procurement. Origin offers a path outside the world of VS Code, Copilot, and Azure.
Source: explainx.ai
