The Great Monorepo Unbundling: Why Big Tech is Fragmenting for the AI Agent Era

Source: Dev.to

Introduction

There’s a quiet revolution happening in the engineering departments of the world’s largest technology companies. FAANG‑style organisations are actively refactoring their legendary monorepos — those massive, unified codebases that have been the backbone of their engineering culture for over a decade. The reason? They’re preparing for what insiders call “infinite agent code.”

What Is a Monorepo?

A monorepo is a single repository containing all of an organisation’s code. Google famously operates one of the largest, housing billions of lines of code in a single repository. Facebook, Microsoft, and others followed suit, building sophisticated tooling to make this approach work at scale.

Benefits

• Atomic changes across multiple services
• Unified versioning eliminating dependency hell
• Code reuse through shared libraries
• Consistent tooling and developer experience

Companies invested millions in custom build systems (e.g., Bazel, Buck), code‑review tools, and infrastructure to keep monorepos viable at scale.

Why the Sudden Reversal?

The answer lies in how modern AI coding agents operate.

AI Agents and Context Windows

AI agents don’t just autocomplete; they reason about entire codebases, understand architectural patterns, and can make sweeping changes across many files. Their biggest limitation is the context window. Even as context windows expand to millions of tokens, a multi‑billion‑line monorepo presents unique challenges:

• Irrelevant code wastes tokens and adds noise.
• Missing dependencies because they can’t fit everything into context.

When an AI agent needs to modify a payment service, it shouldn’t have to wade through unrelated video‑encoding code. In a monorepo, establishing relevant context becomes exponentially harder.

Risks of Autonomous Changes

AI agents can now modify hundreds of files in seconds. In a monorepo, a subtle misunderstanding of one team’s conventions could cascade into breaking changes across dozens of services. The same interconnectedness that made atomic human changes easy makes autonomous agent changes terrifying.

Ownership and CI/CD Bottlenecks

• Code ownership becomes ambiguous when agents generate changes at scale.
• Monorepo CI/CD systems weren’t designed for the volume of AI‑generated PRs; centralized build systems become immediate bottlenecks.

Emerging Federated Model

Rather than reverting to completely isolated repositories, many companies are moving toward a federated architecture:

• Domain‑bounded repositories aligned with team ownership
• Explicit API contracts between repos, enforced by tooling
• Agent‑optimised documentation that serves as context for AI systems
• Standardised scaffolding so agents can reason about unfamiliar codebases quickly

This approach gives AI agents clear boundaries while preserving the coordination benefits of shared infrastructure.

Transition Challenges

A decade of monorepo tooling doesn’t translate directly:

• Cross‑repo refactoring needs new tools
• Dependency management becomes critical again
• Version‑compatibility matrices return with a vengeance

Companies are betting that AI agents themselves will help bridge this gap, using agents to manage the complexity reintroduced by distributed repositories.

Broader Implications

• Team autonomy increases as clearer repository boundaries give teams more control over technical choices.
• Agent specialisation becomes viable; you can fine‑tune agents for specific domains rather than teaching them the entire organisation’s conventions.
• Hiring patterns may shift toward engineers who excel at defining clear interfaces and documentation, rather than those who rely on tribal knowledge.

Monorepos emerged because distributed systems were too hard for humans to coordinate. Now, as AI agents become capable of managing that coordination complexity, the pendulum swings back. We’re not simplifying for human comprehension — we’re restructuring for machine comprehension.

Conclusion

The “infinite agent code” future isn’t about agents writing unlimited amounts of code; it’s about agents becoming genuine collaborators in software development at every scale. For that to work, our systems need to be legible to them.

FAANG companies fragmenting their monorepos aren’t abandoning the benefits of unified codebases; they’re evolving toward an architecture that serves both human and artificial intelligence.

The question isn’t whether this transition will happen elsewhere, but whether your organisation will lead it or be forced to catch up.

Originally sparked by this observation from @samswoora on X.