Scaling Git for the agentic software factory

AI agents are fundamentally changing the economics of software development. As the cost of producing code falls, the volume of changes moving through the software factory is accelerating beyond what infrastructure designed for human developers was built to handle.

GitLab anticipated this shift and began developing next-generation source code management (SCM) to support thousands of concurrent agents working against large repositories. In June, we announced next-gen SCM at GitLab Transcend, joined on stage by Nick G. from Anthropic's source control team. We've continued collaborating on the technical challenges of agent-scale development, and in August we shared more of our architecture and early performance results.

This week, Anthropic provided a compelling demonstration of why this work is so important. As daily merges to its monorepo grew from approximately 2,500 in May to more than 30,000 in September, its engineers built Scion, a specialized source control system designed for their environment.

Anthropic's experience reinforces the architectural direction we've been pursuing. Scion is purpose-built for enormous monorepos where nearly all clients are agents that are always online. Anthropic acknowledges that its approach isn't a general-purpose replacement for Git and requires its own code review, search, and CI infrastructure.

GitLab is building for the broader enterprise market: delivering agent-scale performance while preserving Git compatibility, infrastructure choice, and integration with the software development lifecycle.

"Scaling our monorepo for agentic development has changed how we think about Git server architecture. We see room to expand what Git servers can do for these workloads without departing from the overall Git model."

— Nick G., Source Control, Anthropic

Built on Git. Designed for agents.

Traditional Git workflows require clients to download substantial repository data, even when an agent needs only a small portion. A single agent invocation can involve 5–10 GB of data transfer and more than 30 seconds of setup, just to answer one question. Multiply that overhead across thousands of agents and source control becomes a bottleneck.

Most enterprises can't move source control onto new infrastructure just to scale it. Next-gen SCM preserves the Git protocol while modernizing the architecture underneath. Stateless compute scales horizontally against shared object storage, while agent-native interfaces let agents request the files and history they need without repeatedly cloning entire repositories.

In early internal tests, workloads completed up to 50x faster, used up to 2x fewer tokens, and generated up to 1,000x less network traffic compared with conventional workflows. These are peak improvements under specific test conditions, and we're continuing to validate performance under sustained, concurrent load.

The same architecture is designed to run on GitLab.com and on S3-compatible storage that customers control, including in air-gapped data centers. Repository data stays within the customer's infrastructure, preserving data sovereignty and existing investments while delivering the scalability agentic development demands.

For a closer look at the architecture and what we're building, watch Mark and Kranthi's latest next-gen SCM update:

Source control is only the first bottleneck

Speeding up source control alone moves the bottleneck downstream. An agent that writes code in seconds creates little value if the resulting changes spend hours waiting for validation, security review, or deployment.

Traditional merge queues and CI workflows face growing pressure when agents generate changes faster than validation can complete. We're seeing this pressure across GitLab.com. Over the past year, customers created 40% more CI/CD pipelines, while code pushes increased 50%. Agent-scale CI will need to validate more changes with less compute per change while preserving evidence of what was tested and verified.

This is why next-gen SCM is part of GitLab's broader vision for a governed software factory. As agents accelerate software production, source control, context, orchestration, CI, security, and governance must evolve together.

We're designing next-gen SCM to let thousands of agents work in parallel in isolated sessions, where unsuccessful experiments can be discarded without disrupting shared code. Successful changes can flow into GitLab's existing merge requests, pipelines, security checks, and governance controls on their path to production.

GitLab Orbit is being developed to provide a context graph of the entire software lifecycle, while GitLab Duo Agent Platform orchestrates agent work across stages. We're also advancing capabilities to make agents accountable for their work, including attribution and authorization of agent actions, preserving the instructions and decisions behind code changes, and giving reviewers the context needed to focus human judgment where it matters.

The goal is to reduce the time and total cost of moving software from intent to production, even as the number of agents and changes grows dramatically.

We believe a governed software factory offers the best economics for agentic development: more software delivered at lower cost per change, with the security and control enterprises require.

Advancing Git through open collaboration

Git's open ecosystem has been foundational to modern software development, and we believe it will remain essential in the agentic era. GitLab has long been an active contributor to Git, and we'll continue working with the community to advance the standard that millions of developers and tools depend on.

Our next-gen SCM architecture builds on that foundation, combining Git compatibility with a redesigned backend and agent-native interfaces designed to deliver the performance and scalability these new workloads demand.

This approach preserves the investments customers have made in Git while allowing GitLab to innovate rapidly across the broader software lifecycle. Our differentiation is the governed software factory: bringing source control, context, orchestration, security, and governance together on one platform.

What's next

Next-gen SCM is in private beta, and we're working with customers to validate performance against their own repositories and workloads.

As agents dramatically increase software production, the entire software factory must operate at machine scale. GitLab is building that foundation.

Request early access to next-gen SCM and evaluate it against your own repositories.

This blog post contains "forward-looking statements" within the meaning of Section 27A of the Securities Act of 1933, as amended, and Section 21E of the Securities Exchange Act of 1934. Although we believe that the expectations reflected in these statements are reasonable, they are subject to known and unknown risks, uncertainties, assumptions and other factors that may cause actual results or outcomes to differ materially. Further information on these risks and other factors is included under the caption "Risk Factors" in our filings with the SEC. We do not undertake any obligation to update or revise these statements after the date of this blog post, except as required by law.