AI coding agents choke on monorepos, and enterprises are rethinking their codebases to fix it
Nearly nine in ten AI coding agent pilots never make it to production, according to recent industry surveys — and the obvious explanation, that the models simply aren't good enough yet, turns out to be largely wrong. The real blocker is architectural: the codebases these agents are being asked to work in were built for humans and build systems, not for tools with a fixed context window, and monorepos are where that mismatch is most visible.
Why monorepos are hostile to agents specifically
A monorepo with 50 packages and 300,000 lines of code is a completely normal engineering setup — plenty of large tech organizations consolidate dozens of services and libraries into a single repository specifically to make cross-project changes and dependency management easier for human engineers. That consolidation is the point: one commit history, one CI pipeline, one place to enforce standards.
For an AI agent, the same structure becomes a liability. An agent that tries to load "the codebase" for context either loses track of what's actually relevant to the task at hand, or burns its entire context budget on files it will never touch. One reported case involved an attempt to import a 450,000-file monorepo into an agent's working context that failed outright due to browser and tooling limitations — not because the task was conceptually hard, but because the sheer file count exceeded what the tooling could handle at all.
This is a fundamentally different failure mode than "the model made a mistake." It's closer to handing someone a filing cabinet with 300,000 folders and asking them to find the three that matter, except the person has to skim every folder label first and forgets everything past folder 40,000.
The integration problem is bigger than the context problem
Survey data reinforces that this isn't really an intelligence gap. Roughly 46 percent of teams deploying agentic coding tools cite integration with existing systems as their primary obstacle — not incorrect code generation, not hallucination, but the mechanics of getting an agent safely and reliably connected to real repositories, real CI systems, and real deployment pipelines. Gartner's own forecast is stark: it expects more than 40 percent of agentic AI projects to be canceled by the end of 2027, driven by escalating costs, unclear business value, and inadequate risk controls — not by the agents failing at the coding task itself.
Despite that, adoption hasn't stalled. Roughly 57 percent of surveyed organizations already have coding agents in production somewhere, with large enterprises — the very organizations most likely to run large monorepos — leading adoption. That combination of high production usage and high monorepo friction is why the workarounds matter right now, not hypothetically.
What teams are actually doing about it
Three patterns are emerging in how engineering organizations are adapting monorepos for agent use rather than waiting for agents to get smarter.
Selective indexing over full-repo context. Instead of feeding an agent the whole monorepo, teams are building retrieval layers that hand the agent only the subset of files relevant to the task — dependency graphs, ownership boundaries, and recent-change history are used to build a much smaller working set per task, rather than relying on the agent's raw context window to hold everything.
Virtual sub-repo carving. Some organizations are exposing agent-facing "views" into a monorepo that look and behave like standalone repositories scoped to a single service or package, even though the underlying source of truth remains a single unified repo for humans and CI. This gives agents a repo-sized problem instead of a codebase-sized one, without giving up the operational benefits of the monorepo for human engineers.
Governance and isolation infrastructure before more agent capability. Teams reaching production are prioritizing sandboxing, permission scoping, and audit trails for what an agent can touch — treating deployment infrastructure as the actual bottleneck rather than agent intelligence, which lines up with why integration, not model quality, is the top-cited barrier.
The takeaway for engineering leads
If your organization is stuck at the pilot stage with a coding agent, the fix probably isn't a better model or a better prompt — it's rethinking how much of your codebase the agent actually needs to see for a given task, and building the retrieval or scoping layer that makes that possible. Monorepo architecture decisions that made sense purely for human engineering teams are now also, whether anyone planned it or not, decisions about how usable your codebase is for agentic tooling. Organizations that treat that as a deliberate architectural choice — rather than an afterthought — are the ones most likely to be in the 57 percent running agents in production instead of the 88 percent stuck in pilot purgatory.