Anthropic Replaces Git with Scion: Tackling Agent-Scale Merges

When AI agents start committing code at machine speed, the traditional Git workflow becomes a bottleneck. According to Hacker News and RSS feeds, Anthropic's daily code merge volume has surged from around 2,500 to over 30,000, forcing them to replace Git with their own system, Scion.

Why Git Is No Longer Enough

Git was born in an era of collaboration among human developers. Its branching model, merge conflict resolution mechanisms, and PR-based review process all assume there's a patient, thinking human behind every merge.

Once Anthropic's AI agents began participating in code production at scale, that assumption broke down. 30,000 daily merges means a merge happening roughly every 3 seconds on average. Human reviewers simply can't keep up with that pace, and Git itself has revealed performance bottlenecks when handling high-concurrency branch merges—each merge requires full tree object computation and conflict detection.

The emergence of Scion isn't a rejection of Git, but an acknowledgment of a new reality: humans are no longer the only producers of code.

Git's tree objects and merge overhead: A Git repository is essentially a directed acyclic graph, where each commit points to a complete tree object that records the directory structure and content hashes of all files at that moment. When merging two branches, Git needs to find the common ancestor, compare both tree objects layer by layer, generate a merge tree, and perform line-level three-way diffs on text files to detect conflicts. Although this process has been heavily optimized, its time complexity still scales with the number of changed files and repository size. When merge frequency reaches multiple times per second and branch counts are massive, repeated tree object computations, index rebuilds, and lock contention quickly accumulate into significant latency. Additionally, the PR review process relies on human intervention before merging, which inherently cannot match machine-level commit speeds. So the bottleneck isn't any specific Git command—it's the fundamental mismatch between its "review first, merge later" conservative model and high-concurrency agent production.

What Scion Does Differently

According to Anthropic's official post, Scion doesn't reinvent version control from scratch—it redesigns the merge layer specifically for agent scenarios. The core changes include:

• Optimistic merge first: Assume most agent commits won't conflict, merge first then validate, rather than detect-then-merge
• Semantic-level conflict resolution: Use LLMs to understand code intent rather than relying purely on line-level diffs
• Batch operations: Package multiple agent commits together to reduce coordination overhead

The core philosophy here is an acknowledgment: code changes generated by agents tend to be more "localized" and "predictable" than those from humans, so Git's conservative strategy is actually over-engineering.

Optimistic merging and semantic conflict resolution: Traditional version control uses a pessimistic strategy—complete conflict detection before merging, blocking if conflicts exist, and waiting for manual resolution. Optimistic merging assumes most commits won't actually conflict, applies changes directly, then validates; if validation fails, it rolls back or triggers a compensation process. This strategy pays off significantly when agent commits are highly localized with predictable change scopes. Semantic-level conflict resolution further introduces LLMs to understand code intent rather than just comparing text lines. For example, if two agents rename different call sites of the same function, a line-level diff would report a conflict, but semantically they may be fully compatible. However, semantic merging depends on the model's understanding of code context and can still misjudge in cross-file refactoring, implicit dependencies, or complex type systems. Therefore, optimistic merging must be paired with fast rollback and auditable logs to strike a balance between speed and correctness.

The HN Controversy: Safety and Auditability

The Hacker News discussion wasn't all applause. Multiple highly upvoted comments pointed out that removing Git means losing an auditing mechanism validated over decades.

One commenter put it bluntly: "Git's history itself is a security boundary. When merge speeds reach multiple times per second, how do you guarantee every change is traceable?"

Others questioned whether Scion's semantic merging is reliable enough—LLMs' ability to understand code intent is still limited in complex refactoring scenarios, and one incorrect automatic merge could be more dangerous than ten conflicts.

However, supporters argue this is exactly the growing pains that agent-native toolchains must go through. A developer who worked on a similar project said: "You can't constrain agents with a security model designed for humans. You need to design new security models for agents."

Auditability and supply chain security: In software supply chain security, auditability means every code change can be traced back to a clear author, time, intent, and review record. Git provides strong traceability through commit hashes, signatures, and immutable history, which is also the foundation recommended by frameworks like SLSA. When merge frequency reaches multiple times per second and some changes are automatically generated by LLMs, traditional manual review logs no longer apply. For Scion to meet equivalent security requirements, it needs to generate machine-readable intent descriptions, change impact scopes, and rollback points for every automatic merge, and ensure these records are tamper-proof. Otherwise, once a malicious injection or model hallucination causes an incorrect merge, teams will struggle to identify the root cause. So the core discussion isn't "whether to audit" but "how to design new audit primitives for agent-native workflows."

What This Means for Your Repository

If your team hasn't reached thousands of merges per day, directly replacing Git is obviously unrealistic. But Anthropic's practice offers several directions worth thinking about ahead of time:

First, watch for early signals of merge bottlenecks. When CI queue times exceed coding time, or merge conflicts start frequently disrupting agent workflows, that's the point when you need to reconsider your version control strategy.

Second, consider a layered approach. You can add an agent-specific fast merge channel on top of Git rather than replacing it entirely. For example, let agents operate on lightweight branches and periodically batch-sync back to the main repository.

Third, treat auditability as a hard constraint. Regardless of what solution you adopt, ensure every agent merge has a clear source, intent, and rollback path. Speed can be compromised; traceability cannot.

Scion remains an internal Anthropic system with no open-source plans. But the direction it points to—version control needs to be redesigned for the agent era—deserves serious attention from every team scaling up AI coding.

One-line Summary

Anthropic replaces Git with its own Scion system as AI agent merge volumes surge, sparking auditability debates.

Paragraph Summary

Anthropic's daily code merge volume surged from around 2,500 to over 30,000, making traditional Git workflows a bottleneck due to their human-review-oriented design. In response, Anthropic built Scion, which uses optimistic merge-first strategies, LLM-based semantic conflict resolution, and batch operations to redesign the merge layer specifically for high-concurrency AI agent commits. On Hacker News, some commenters worry that removing Git means losing validated audit trails and security, and question the reliability of automatic semantic merging; supporters argue the agent era demands entirely new security models. For ordinary teams, the article recommends watching for early merge bottleneck signals, considering an agent-specific fast channel on top of Git, and treating auditability as a hard constraint rather than directly replacing Git.