The Git Bottleneck

A developer pushes code a few times a day. An agent pushes code a few times a minute. GitHub's engineering team described the problem in specific terms: agent-scale Git infrastructure requires rethinking connection handling, rate limiting, caching, and storage patterns that were all calibrated to human cadence. The word "bridge" in their title matters. They are not describing a finished state. They are describing the transitional engineering required to keep the system standing while the traffic profile changes underneath it.

The assumption that broke was temporal. Git hosting stacks assume bursty, intermittent connections with long pauses between operations. A developer reads a diff, thinks, types, tests, commits. An agent reads a diff and commits in the same second. Multiply that by hundreds of concurrent agent sessions across a single repository and the read-write contention patterns look nothing like what the system was tuned for.

This is the pattern worth naming: the cadence mismatch. Every piece of developer infrastructure, from CI pipelines to code review queues to merge conflict resolution, encodes an assumption about how fast the next action arrives. Agents violate that assumption everywhere at once.

GitHub did not publish this as a product announcement. They published it as an architecture post, which means the problems were real enough to warrant public engineering discussion. When the platform that hosts 100 million developers writes about needing to rebuild its connection layer, the signal is not subtle.

Anthropic launched Claude Duet the same week, a product that puts a persistent Claude session alongside a human collaborator. The name is precise. A duet requires two performers in the same space at the same time, sharing the same instrument. The instrument, in this case, is the document, the codebase, the spreadsheet.

Separately, Anthropic announced that Claude now works inside Google Docs, Sheets, and Slides. The integration is direct. Claude reads and writes inside documents that humans are also reading and writing. This is not a sidebar assistant summarizing a file. It is a concurrent editor with API-speed reflexes sharing a collaborative workspace designed for people who type at 80 words per minute.

Google Docs was built on operational transforms and conflict resolution algorithms tuned for human editing speed. A human collaborator might type a paragraph while you type a sentence. Claude can rewrite three pages while you fix a typo. The cadence mismatch again. The same structural problem GitHub described in Git shows up in every collaborative tool the moment an agent gets write access.

The reversal here is directional. Most teams evaluating agent products ask whether the agent is good enough. Whether it writes acceptable code, whether it produces useful analysis. The GitHub post reveals the question they should be asking first: whether their infrastructure can handle the agent at all. Quality is irrelevant if the plumbing fails.

Git is the canary, not the exception. Every system built for human-cadence interaction carries the same latent failure. CI/CD pipelines assume minutes between triggers, not seconds. Code review tools assume a human will look at a pull request before the next one arrives. Notification systems assume a manageable volume of events per hour. Merge queues assume contention is rare.

OpenAI shipped a CLI tool this week. Anthropic shipped workspace integrations. An open-source project called Omnara appeared as an alternative to managed agent platforms. The agent surface area is expanding across every tool developers touch. Each new integration point creates a new instance of the cadence mismatch.

Nvidia's framing this week was pointed. The company described turning the AI factory into a product and agents into the workload. That language treats agents as the primary consumer of compute infrastructure, with human interaction as the configuration layer. The infrastructure vendors have already internalized what most enterprise teams have not: the ratio is flipping.

OpenAI reinforced the trajectory from a different angle. Its models now run on Google Cloud, and GPT-6 is being applied to rewrite 60-year-old banking code. Legacy code migration generates enormous volumes of commits, test runs, and deployment artifacts. An agent rewriting COBOL into modern languages does not pause to get coffee. It produces a continuous stream of changes that downstream systems must absorb, review, test, and deploy. The cadence mismatch hits the entire pipeline, not one tool.

Omnara launched as an open-source alternative to Claude Managed Agents. The timing matters more than the feature set. When open-source alternatives appear within months of a commercial product, the pattern indicates that the commercial product has validated a real category but left an adoption gap. The gap is usually control.

Managed agent platforms handle orchestration, state management, and tool access. They also own the execution environment. For teams running agents that write to production repositories, production databases, or production documents, that ownership creates a dependency they cannot audit. An open-source orchestrator running in your own infrastructure gives you the audit trail. It also gives you the cadence mismatch, because now your infrastructure absorbs the agent traffic directly instead of a managed platform buffering it.

The research side of the agent push tells the same story at a different scale. OpenAI published work on using thousands of AI agents to uncover leads in biological data. Thousands of concurrent agents, each reading data, forming hypotheses, running analyses, writing results. The infrastructure underneath that workload bears no resemblance to a developer typing queries. It looks like a distributed compute job that happens to use natural language as its instruction set.

Even the recreational experiments point the same direction. Researchers built LLM agents that play competitive Pokemon, a domain where the agent must make decisions at game speed, maintain state across turns, and interact with systems designed for human reaction times. The game's API was not built for an opponent that never hesitates. The cadence mismatch shows up in a toy domain as clearly as it shows up in Git.

The standard enterprise AI adoption story runs: pick a use case, run a pilot, measure results, expand. SAP reported this week that cloud growth accelerated with AI driving results in Q3 2026. Australian research projected a $136,000 annual productivity gain per SME from AI adoption. The numbers look encouraging. They also assume the infrastructure holds.

GitHub's post is the corrective. The productivity gains are real, and they require infrastructure changes that most teams have not scoped. A team that deploys 10 coding agents against a monorepo without rethinking its CI pipeline, its merge strategy, its review process, and its rate limits will hit the cadence mismatch within the first week. The agents will not be slow. The pipeline will be overwhelmed.

The coordination problem compounds it. OpenAI published a separate post on coordinated disclosure of critical vulnerabilities discovered by agents. When agents find security flaws at scale, the response process must operate at agent speed. Human vulnerability triage assumes days. Agent-discovered vulnerabilities arrive in batches. The cadence mismatch extends past development tooling into security operations.

Anthropic's Public Benefit Charter published this week addresses governance at the corporate level. The infrastructure question sits below governance. You can have the right policies and the right intentions and still break your own systems by deploying agents faster than your plumbing can handle them.

The practical move is an infrastructure audit scoped specifically to cadence assumptions. Not "can our systems handle more load" but "what happens when the interval between operations drops from minutes to milliseconds." The answer will be different for every tool in the chain, and most of the answers will be uncomfortable.