Origin – Cursor's AI-Native Code Hosting Platform

1. What is Origin

Origin is an AI-native code hosting platform launched by Cursor, specifically designed for the Agent era. In addition to providing core functionalities such as standard Git repository management, PR review and merging, and GitHub bidirectional synchronization, Origin pioneers Agent-native features such as stacked PRs, AI-powered automatic conflict resolution, and machine-readable review statuses. Its infrastructure is built from scratch using NVMe + S3 + global replicas, supporting up to 22 commits per second and global synchronization latency under 400ms. The goal is to become the code infrastructure of the Agent era. Currently in Beta, it is open to Cursor's paying users. In the short term, it will coexist with GitHub, while its long-term objective is to replace traditional code hosting platforms and become the core hub for AI-driven development. The design philosophy of Origin is "Agent First," with all features prioritizing the user experience of AI Agents.

Image source: Official article
Image source: official article

Technical positioning and domain: Origin belongs to the AI-native code hosting domain, designed specifically for high-frequency and concurrent operations by AI Agents. It is fundamentally different from traditional code hosting platforms (such as GitHub and GitLab) that are oriented toward human developers. Its core positioning is to become the code infrastructure of the Agent era, with both the underlying protocols and upper-layer workflows optimized for the automation and batch operation characteristics of AI Agents, rather than simply adding AI-assisted features on top of existing platforms. Origin emphasizes Agent-Native, meaning the platform's design assumes that the primary users are AI Agents, not humans. Therefore, its APIs, workflows, and performance metrics are all built around the needs of AI Agents, such as machine-readable review statuses and event-driven Automations.

Development background: Origin was developed by the Cursor team. Cursor itself is a widely popular AI programming assistant, with extensive experience in Agent-based coding and a large base of paying users. As AI Agents become more autonomous in coding tasks, traditional Git platforms are gradually becoming bottlenecks in areas such as PR management, conflict resolution during merging, and the machine-readability of review status. Origin is a natural extension of Cursor into the realm of code infrastructure, aiming to address these pain points and fill the gap in Agent-native hosting platforms, providing full-stack infrastructure from coding to deployment for Agents. The release of this product also reflects the Cursor team's forward-looking judgment on the trend of Agent-based development.

Core value: Origin addresses three major pain points that traditional Git platforms face in the Agent era. First, a single PR contains too many changes, making it difficult for humans to review. Origin solves this by using stacked PRs to break down large changes into multiple smaller PRs with dependency relationships, and visualizes these dependencies with a dependency graph, facilitating step-by-step review by both Agents and humans. Second, when multiple Agents submit concurrently, merge conflicts frequently occur and require manual intervention. Origin's merge queue automatically sorts PRs, detects conflicts, and performs CI checks, and in the case of complex conflicts, AI resolves them automatically without the need for human involvement. Third, review results presented in natural language are difficult for Agents to parse. Origin outputs review statuses in a structured API format, allowing Agents to directly query and write to it, achieving full automation of the review process. These features enable Agents to autonomously complete the entire development process from coding to merging, significantly improving efficiency.

Technical features: Origin is built from scratch using an NVMe + S3 + global replicas architecture, supporting up to 22 commits per second and global synchronization latency under 400ms, capable of handling the operational pressure of large-scale Agent activities. The platform natively supports the MCP protocol and event-driven Automations, allowing Agents to directly call platform functions without needing to go through traditional REST APIs, thereby reducing integration complexity. Deeply integrated with Cursor, Agents can complete code modifications, PR updates, and branch pushes within the same platform, achieving a fully closed-loop workflow. In addition, the platform has already connected with Vercel (preview deployment), Depot, and Buildkite (CI), and supports running existing GitHub Actions workflows, offering good ecosystem compatibility and reducing user migration costs.

2. Key Features

• Stacked PRs: This is one of Origin's most innovative features. It breaks down large changes into multiple smaller PRs with dependencies and displays their sequence in a visual dependency graph. Reviewers can examine each small PR step by step according to the dependency relationships, avoiding being overwhelmed by a large volume of changes at once. For bulk code changes generated by Agents, this feature significantly reduces the cognitive load on human reviewers while enabling Agents to precisely modify specific sections based on review feedback.

• Merge Queue: When multiple Agents or developers submit PRs simultaneously, the Merge Queue automatically sorts the PRs, detects conflicts, and performs CI validation. When encountering complex cross-file conflicts, AI automatically analyzes and resolves them without requiring human intervention. This ensures the main branch remains always "green," greatly improving the efficiency of multi-Agent collaboration.

• Machine-Readable Review Status: Traditional review results are presented in natural language comments and green checkmarks, which are difficult for Agents to parse automatically. Origin outputs review results in a structured API format, including fields such as pass/fail status, issue location, and suggested modifications, allowing Agents to directly query and write to it. This enables the entire review process to be fully automated, allowing Agents to automatically adjust the code and resubmit based on the review results.

• GitHub Bidirectional Sync: Users can一键 mirror a GitHub repository, and Origin maintains real-time bidirectional synchronization with GitHub for code, PRs, and comments. This feature reduces migration costs and allows users to adopt Origin incrementally. When users are ready for a full migration, they can disconnect at any time, making Origin an independent authoritative data source while keeping the original GitHub repository as a read-only backup.

• High-Performance Infrastructure: Origin is built on NVMe SSDs and S3 object storage, with global multi-replica deployment, achieving 22 commits per second and global synchronization latency below 400ms. These performance metrics far exceed those of traditional Git platforms, specifically designed for the high-frequency and concurrent operations of Agents, ensuring smooth performance even under heavy Agent load.

• Ask Cursor Integration: Within the PR review interface, users can directly select a code snippet and ask Cursor AI a question or request line-by-line explanation. This feature embeds AI assistance directly into the review process, helping human reviewers quickly understand code generated by Agents and improving both review efficiency and quality.

• Application Ecosystem Integration: Origin has integrated with Vercel (providing preview deployment), Depot and Buildkite (providing CI services), and supports running existing GitHub Actions workflows. This means users can continue using their existing CI/CD configurations within Origin without rewriting pipelines, reducing migration resistance.

• Code Repository Management: Origin provides full Git repository management capabilities, supporting the creation, cloning, pushing, and pulling of repositories directly in the web interface. While this is a basic feature, its user experience is optimized for Agents, with a streamlined CLI tool that is easy for Agents to automate.

3. How to Use

1. Prerequisites and Activation: Confirm that your Cursor account is on a Pro, Teams, or Enterprise paid plan, as Origin is only available to paid users and is being rolled out in phases, requiring you to wait for the feature to be activated. Visit the Origin official website (https://cursor.com/codebase), click the "Get Started" button, and claim a codebase name to activate the Origin service. The entire process requires no additional installation—just logging in to your Cursor account.

2. Creating and Pushing Repositories: Click "+ New" under the Codebase tab in Cursor to create a repository. The page will automatically display the CLI installation command and instructions for pushing a local project. Users need to install the Origin CLI in their local terminal and then use the command line to clone or push their local project to an Origin repository. The CLI tool is compatible with standard Git commands, resulting in a low learning curve.

3. Synchronizing with GitHub Repositories: To migrate an existing project, users can connect their GitHub account in Origin and select the target repository. Origin will synchronize code and PR comments in real-time in both directions, ensuring data consistency across both platforms. Users can disconnect the synchronization at any time, making Origin an independent authoritative data source, while the original GitHub repository remains read-only.

4. Code Review and Merging: Open a PR in the repository, and users can view the timeline and file changes, review diffs, add comments, and merge code directly. Merging supports both merge commit and squash methods, and users can configure the default merge strategy in the repository settings. Branch protection rules can also be set here to ensure the safety of the main branch.

5. Integrating Third-Party Applications: Go to the Apps tab in the repository, and users can install Vercel, Depot, or Buildkite to enable preview deployments and CI workflows. Origin also supports running existing GitHub Actions workflows—users simply need to configure the corresponding Actions files in the repository.

6. Configuring Permissions and Rules: In the repository settings, users can configure access permissions (public or private), branch protection rules (such as requiring PR reviews, prohibiting direct pushes), and merge methods. These configurations ensure the security and standardization of team collaboration.

4. Pros and Cons Analysis

5. Comparative Analysis with Similar Tools

For teams deeply using Cursor and AI Agents, Origin is the optimal choice. Its native Agent support maximizes Agent autonomy and minimizes human intervention. Especially in scenarios requiring concurrent collaboration among multiple Agents or handling large-scale code changes, Origin's stacked PRs and AI-powered merge queues significantly enhance efficiency. However, for teams primarily relying on human developers and a mature CI/CD ecosystem, GitHub or GitLab are more reliable options. GitHub boasts the largest developer community and a mature Actions ecosystem, making it ideal for open-source projects and large teams. GitLab, on the other hand, excels with its built-in CI/CD and integrated DevOps capabilities, making it suitable for teams seeking self-hosted solutions and full DevOps processes.

For teams already using the Atlassian toolchain (such as Jira and Confluence), Bitbucket's deep integration offers clear advantages, maintaining workflow consistency. Teams wishing to gradually migrate to an Agent-native platform can first use Origin's GitHub bidirectional synchronization feature as a mirror layer, progressively experiencing its capabilities before fully migrating. Overall, Origin holds a first-mover advantage in the Agent-native space, but its ecosystem still requires time to mature. Coexisting with GitHub in the short term remains a pragmatic choice.

6. Editor's Summary

The emergence of Origin marks a paradigm shift in code hosting platforms from "human-centric" to "Agent-native." Its technological innovation is reflected in features such as stacked PRs, AI merge queues, and machine-readable review statuses. These are not merely additive functionalities but rather a comprehensive reengineering of the underlying architecture and workflows, aiming to make AI Agents first-class citizens in the code repository. In terms of practical value, Origin directly addresses the core bottlenecks of code management in the Agent era—traditional Git platforms are unable to accommodate the high-frequency and batch operations typical of Agents. Origin resolves these issues through its native design, enabling AI Agents to autonomously complete the full development loop from coding to merging, significantly enhancing development efficiency. The primary users are developers or teams within Cursor's paid user base who deeply utilize AI Agents, especially in scenarios requiring multi-Agent collaboration, large-scale code changes, or full-chain automation. For individual developers or non-Cursor users, Origin's current value is limited, but it may expand in the future with an open ecosystem. From the current technological trends, the role of AI Agents in software development is becoming increasingly important, and the Agent-native code hosting domain where Origin operates holds vast potential. However, its long-term development still depends on ecosystem building, user adoption speed, and product stability. In the short term, its coexistence strategy with GitHub reduces migration barriers, while in the long term, becoming an authoritative data source independently is Origin's direction. However, achieving this goal requires overcoming challenges in ecosystem development and user adoption. Overall, Origin represents an important exploration in the field of AI-native code hosting and is worth keeping an eye on.

7. Application Scenarios

• AI Agent Autonomous Development: The Agent autonomously completes the entire process of coding, submitting, opening PRs, and merging on the cloud, enabling closed-loop delivery without human intervention. Origin's stacked PRs and machine-readable review status allow the Agent to manage code changes independently, automatically adjusting based on review outcomes to achieve truly unmanned development. This scenario is particularly suitable for standardized development tasks such as automation scripts and data processing pipelines.

• Massive Change Review: When the Agent generates changes to hundreds of files, the traditional single-PR model becomes overwhelming for human reviewers. Origin's stacked PRs break down the changes into smaller PRs with dependency relationships and display them as a visual dependency graph. Reviewers can examine each small PR sequentially, reducing cognitive load. Meanwhile, the integration with Ask Cursor helps reviewers quickly understand the intent behind the code.

• Concurrent Collaboration Among Multiple Agents: In large projects, multiple Agents can simultaneously develop different modules and submit their own PRs. Origin's merge queue automatically sorts and detects conflicts, with AI resolving complex conflicts to ensure the main branch remains green at all times. This significantly enhances the team's parallel development efficiency and reduces manual coordination costs.

• GitHub Disaster Recovery and Gradual Migration: Teams can use Origin as a real-time mirror of GitHub, with daily bidirectional synchronization. In the event of a GitHub outage or performance issue, teams can disconnect with a single click, making Origin an independent authoritative data source and ensuring uninterrupted development. Additionally, teams can gradually migrate core repositories to Origin, minimizing risk.

• Fully AI-Driven End-to-End Delivery: Full automation of the entire delivery pipeline, from code submission to AI review, CI testing, and preview deployment, without the need to switch across platforms. Origin integrates deeply with Cursor, Vercel, and others, allowing Agents to automatically trigger CI and deploy preview environments, achieving a fully agentized end-to-end delivery pipeline.

8. FAQ

Q: What is the relationship between Origin and GitHub? Can Origin fully replace GitHub?
A: Origin currently supports bidirectional synchronization with GitHub, and can function as a mirror layer or an independent data source. In the short term, both platforms will coexist, and users can disconnect at any time to make Origin the authoritative data source. The long-term goal is to replace traditional code hosting platforms, but it is currently in the Beta phase. It is recommended that users treat Origin as a supplement to GitHub rather than a complete replacement.

Q: Is there any additional cost to use Origin? Can free users access it?
A: Origin is currently available to Cursor's Pro, Teams, and Enterprise paid users, with no additional fees required. However, a valid Cursor paid subscription is necessary. Free users cannot use Origin, which is one of the main barriers at present.

Q: How can I migrate an existing GitHub repository to Origin? Will data on GitHub be lost after migration?
A: To migrate, connect your GitHub account in Origin and select the target repository. You can then一键 mirror it and enable real-time bidirectional synchronization. After migration, data on GitHub will not be lost, as Origin only serves as a synchronized copy. When you're ready to fully migrate, you can disconnect, making Origin an independent data source, while the GitHub repository remains as a read-only backup.

Q: Which CI/CD tools does Origin support? Can it use existing GitHub Actions?
A: Origin has integrated with Vercel (preview deployment), Depot, and Buildkite (CI), and supports running existing GitHub Actions workflows. Users simply need to configure the corresponding Actions files in the repository, and Origin can execute them. More CI/CD integrations are currently under development.

Q: What is the difference between stacked PRs and traditional PRs? How can I create a stacked PR?
A: Traditional PRs place all changes into a single PR, making review difficult. Stacked PRs break down large changes into multiple smaller PRs with dependency relationships, displayed as a visual dependency graph. When creating, agents or developers can submit PRs step by step in logical units, with each PR depending on the previous one. Reviewers can examine them in sequence. Origin automatically manages these dependencies.

Q: What is Origin's concurrent performance? How many agents can operate simultaneously?
A: Origin is built on an NVMe + S3 + global replica architecture, supporting 22 commits per second and global synchronization latency below 400ms. This performance metric is specifically designed for high-frequency concurrent operations by agents, and it can support tens or even hundreds of agents operating simultaneously, depending on the repository size and type of operation.

9. Project Links

• Product Official Website: https://cursor.com/codebase (Origin platform entry point, includes quick start guide)
• Team Official Website: https://cursor.com (Cursor main site, provides product introduction and account management)