Agent-Based Development Handles 70% of PRs — How Uber Kept Costs Flat Through 7x Usage Growth

·

Key Takeaways

  • Over 70% of PRs are handled by local and cloud agents, with agents acting as the first line of development
  • Automation runs at scale: more than 3,600 agent skills execute over 30,000 times per day
  • Between February and mid-August 2026, weekly users grew 7x and agent requests grew 9.4x

Analysis

Table of Contents

Agent-based development is now automatically handling over 70% of pull requests across Uber’s codebase. This is not simple code autocompletion—agents running both locally and in the cloud act as the first line of PR work. The operational metrics Uber has published put concrete numbers behind this shift.

The reason this case caught my attention is that it is less a “tool that writes code for you” and more an operating system that runs the entire PR pipeline. How Uber operates its software factory reveals both the scale and the cost structure of agent-based development at the same time.

What “Software Factory” Really Means

Uber calls its development system a “software factory.” The core idea is not a single agent, but a building-block design in which role-specific agents are stacked together. PR creation, review, merge candidates, and post-merge monitoring are all closed loops inside the agents. Humans are left with only the final gatekeeping role.

The Numbers Behind the Scale

More than 3,600 agent skills run over 30,000 times per day. From February through mid-August 2026, weekly users grew 7x and agent requests grew 9.4x. Over 70% of PRs are now handled by agents as the first pass.

Metric Value
Daily skill executions Over 30,000
Share of PRs handled by agents Over 70%
Weekly user growth (Feb–Aug) 7x
Agent request growth 9.4x
Active skills Over 3,600
Cost curve (since April) Remains flat

Despite this explosive growth, the cost curve flattened after April. Usage and cost have been decoupled on the graph.

Why Costs Stayed Flat in Agent-Based Development

What Uber did to control costs is not a single trick. Around-the-clock optimization runs on every front: caching, routing, mixing of small and large models, and per-request token reduction. For practitioners, the most meaningful point is that cost was designed not to scale proportionally with usage.

The real issue in agent-based development is not model performance but how this decoupling structure is operated. The same pattern is observed repeatedly in real-world tooling contexts as well.

Design Considerations for Large-Scale Codebases

Running agents across an environment like Uber’s mix of monoliths and microservices requires three prerequisites. Codebase indexing and search infrastructure must be fast enough; PR-level permissions and accountability boundaries must be organized to a level that can be delegated to agents; and the human gate for final merge decisions must be unambiguous.

If any one of these is missing, the gains of automation turn into a net negative.

Risks and Limits of Agent-Based Development

Organizations that let agent-based development handle over 70% of their PRs take on new risks: the potential for security policies to be bypassed, ambiguity in accountability, and the paradox of “humans re-reviewing code produced by agent-based development.” Uber’s case shows what is possible, but what to control on top of it is something each organization has to answer for itself.

This multi-agent behavior is not unrelated to the spontaneous swarm patterns observed in the agent ecosystem.

Practical Application Points

  • Codify which PR stages are delegated to agents and which remain human-gated.
  • Plot cost and usage on the same graph to find the inflection point.
  • Operate an internal standard for the agent skill catalog.

What to Try Right Now

  • Pick 5 PRs from this week and note which stages could be replaced by agents.
  • Plot usage and cost on one graph and mark an inflection point like April.
  • Draft an initial agent skill catalog with no more than 10 items.
  • Put together a one-page document for PR merge permissions and accountability matrix.

Frequently Asked Questions

Why can cost be decoupled from usage in agent-based development?

When optimizations such as caching, routing, and model mixing are applied continuously, per-token cost falls. In the Uber case, costs staying flat even as usage grew 9.4x is the result of this decoupling structure.

Which stages does Uber’s 70% PR automation cover?

It goes well beyond simple code generation, broadly covering PR creation, review, and merge candidate generation. The key assumption is that humans keep the final gate.

Can small and mid-sized organizations adopt agent-based development?

Yes. However, codebase indexing infrastructure and PR gate design must be prepared first for the automation to be meaningful. Starting at 10–20% rather than aiming for 70% out of the gate is more realistic.

What is the biggest risk as agent dependency grows?

Security policy bypass, ambiguity in accountability, and the cost of having humans re-verify agent outputs. If these three are not managed together, the gains of automation erode quickly.

Reference Source

This article was written after reviewing the following source: geeknews — How to Operate a Software Factory at Uber’s Scale Efficiently

Leave a Reply

Your email address will not be published. Required fields are marked *