Building Internal AI Agent Infrastructure for Software Development at Scale

uber · Tech · 2026 · source Agentic: yes · promotional bias: med · source-backed · extracted with prompt 0.5.5 (schema v2)

Generated from extraction.json — do not edit by hand. Every claim cites verbatim source evidence; stated means the quote directly asserts the claim, implied means it supports it indirectly.

Problem

Domain: Enterprise software-development agents

Uber needed to roll AI agents into a large engineering organization without leaving every developer and team to assemble their own models, context sources, MCP servers, agent clients, background execution, review tools, and cost controls. The core problem was not a single coding assistant; it was an internal platform for many agentic development workflows at company scale.

Constraints:

• The platform had to serve nearly 3,000 people in the tech function, not a small pilot group.
• Agents needed Uber-specific context such as source code, engineering documentation, Slack information, and JIRA tickets.
• Developers wanted multiple industry tools rather than one mandated client, including Claude Code, GitHub Copilot, Cursor, Codex, and other clients.
• Internal APIs used Thrift, Protobuffer, and HTTP endpoints that needed to be exposed safely to agents.
• Parallel background-agent workflows created resource and cost-management pressure.
• Adoption could not rely only on top-down mandates; engineers needed education, defaults, and peer-shared wins.

Architecture

Uber built an internal AI-agent stack for software development around layered platform responsibilities. Michelangelo supplies the internal AI platform and model gateway. An internal-context layer gives agents access to Uber source code, documentation, Slack, JIRA, and other company data. Industry agent clients such as Claude Code, GitHub Copilot, Cursor, Codex, and other tools sit above that substrate. Uber-specific systems then provide MCP Gateway access to internal and external tools, Agent Builder and Agent Studio for no-code and traced multi-agent workflows, AIFX CLI for distribution and defaults, Minion for background agent tasks, and specialized agents such as Code Inbox, uReview, Autocover, and Shepherd.

Diagram confidence: reconstructed (reconstructed from prose).

flowchart LR
  uber-developer[Uber developer] --> aifx-cli[AIFX CLI]
  uber-developer --> industry-agent-clients[Industry agent clients]
  uber-developer --> agent-builder-and-studio[Agent Builder and Studio]
  uber-developer --> specialized-development-agents[Specialized development agents]
  aifx-cli --> industry-agent-clients
  aifx-cli --> mcp-gateway[MCP Gateway]
  aifx-cli --> minion-background-platform[Minion background platform]
  industry-agent-clients --> internal-ai-platform[Internal AI platform]
  industry-agent-clients --> internal-context-layer[Internal context layer]
  industry-agent-clients --> mcp-gateway
  agent-builder-and-studio --> internal-ai-platform
  agent-builder-and-studio --> internal-context-layer
  agent-builder-and-studio --> mcp-gateway
  agent-builder-and-studio --> agent-registry[Agent registry]
  mcp-gateway --> internal-services-and-mcp-servers[Internal services and MCP servers]
  mcp-gateway --> mcp-registry-and-sandbox[MCP registry and sandbox]
  minion-background-platform --> internal-ai-platform
  minion-background-platform --> internal-context-layer
  specialized-development-agents --> internal-ai-platform
  specialized-development-agents --> internal-context-layer
  engineering-enablement-layer[Engineering enablement layer] --> aifx-cli
  engineering-enablement-layer --> industry-agent-clients
  engineering-enablement-layer --> specialized-development-agents

Components

Data flow

A developer starts from AIFX CLI, an industry coding assistant, Agent Builder, or a specialized agent. The client reaches Uber's internal AI platform and model gateway when it needs model access, and it pulls Uber-specific memory from source code, engineering docs, Slack, JIRA, and other internal data. When the agent needs tools or data sources, MCP Gateway exposes first-party MCPs, third-party MCPs, and proxied internal Thrift, Protobuffer, or HTTP endpoints while centralizing authorization, telemetry, and logging. Agent Builder/Studio lets users compose, trace, version, evaluate, and register multi-agent workflows. Longer-running development tasks can run through Minion/background infrastructure, while specialized agents route PRs, review code, generate tests, or manage migrations.

Why this architecture

Uber chose a platform stack because agent adoption at its scale depends on governed access, common defaults, internal context, tool discovery, background execution, and cost visibility. The MCP Gateway prevents each team from making bespoke internal integrations. AIFX centralizes fast-moving client updates and default configuration. Agent Builder and Studio turn reusable workflows into discoverable, traceable artifacts. Minion and the specialized agents handle the shift from single-agent IDE work toward background and parallel development tasks.

Models used: frontier models · internally hosted models · Claude Code · GitHub Copilot · Cursor · Codex

Scale

• Uber employed almost 3,000 people in its tech function when describing the rollout.
  “Today, it’s maturing as a publicly traded, profitable company, and employs almost 3,000 people in the tech function.”article, stated
• As of March 2026, 84% of Uber developers were agentic coding users.
  “84% of devs at Uber are agentic coding users”article, stated
• IDE-based tools generated 65-72% of code in the reported usage metrics.
  “65-72% of code is AI-generated”article, stated
• Claude Code usage nearly doubled over three months, from 32% to 63%.
  “from 32% in Dec to 63% in Feb, while IDE-based tools (Cursor, IntelliJ) have plateaued.”article, stated
• Agents opened 11% of Uber pull requests in the reported period.
  “92% of Uber devs use agents monthly, 65-72% of code is AI-generated inside IDEs, and 11% of pull requests opened by agents.”article, stated
• AI-related costs were up 6x since 2024.
  “AI-related costs are up 6x since 2024, and token cost optimization is a growing priority.”article, stated
• Autocover produced more than 5,000 unit tests per month.
  “Autocover for generating 5,000+ unit tests per month, and Shepherd for managing large-scale migrations end to end.”article, stated

Alternatives considered (roads not taken)

Automate everything possible in engineering.

Rejected because: Uber framed the work more narrowly around eliminating toil and freeing engineers for creative work, rather than pursuing blanket automation.

Let every team wire internal endpoints directly to agents.

Rejected because: The MCP Gateway centralizes authorization, telemetry, logging, registry, sandboxing, and the conversion of internal Thrift, Protobuffer, or HTTP endpoints into MCP servers.

Mandate one AI coding client for all developers.

Rejected because: Uber instead enabled multiple industry agents so engineers could use the latest tools and the platform could retain optionality as the market evolved.

Rely on top-down mandates for adoption.

Rejected because: The case reports slower-than-expected adoption and says peer-shared wins worked better than mandates.

Keep developers in a single-threaded IDE workflow.

Rejected because: The observed workflow shifted toward developers supervising multiple parallel agents, which required background execution and resource-management infrastructure.

Patterns

tool-use-orchestration (agent-architecture)

Uber used MCP Gateway as the central path for exposing internal and third-party tools to agents, including first-party MCPs, third-party MCPs, and internal Thrift, Protobuffer, or HTTP endpoints.

agent-memory (state-management)

Uber gave agents internal organizational memory by connecting them to source code, engineering documentation, Slack, JIRA, and other internal data sources.

multi-agent-orchestration (agent-architecture)

Uber supported developers moving from one interactive agent to multiple parallel background agents and enabled Agent Builder workflows that can hand work to other agents.

observability-tracing (evaluation)

Agent Studio gives multi-agent workflows visual debugging, tracing, versioning, and evaluation so agent behavior can be inspected and reproduced.

cost-aware-routing (operations)

Uber made cost measurement and token optimization part of its engineering enablement layer as agent usage and AI-related costs grew.

model-routing (model-operations)

The internal AI platform includes a model gateway that can proxy agent requests to external frontier models or internally hosted models.

eval-driven-development (evaluation)

Agent Studio makes evaluation a workflow capability, and Uber's specialized agents are described with usage and signal goals such as high-signal review comments and generated tests.

Tradeoffs

Centralize agent access through MCP Gateway.

Chose a gateway with registry, sandbox, authorization, telemetry, and logging over team-by-team direct integrations to internal services and external MCP servers.

Rationale: The gateway reduces integration complexity while keeping security and observability uniform across internal Thrift, Protobuffer, HTTP, first-party MCP, and third-party MCP access.

Use a multi-tool strategy for coding assistants.

Chose supporting Claude Code, GitHub Copilot, Cursor, Codex, and other clients over standardizing the whole engineering organization on one agent client.

Rationale: The AI-agent market is changing quickly and developer workflows vary, so Uber prioritized optionality while using platform layers to provide common defaults and governance.

Provide a unified CLI for AI tooling.

Chose AIFX CLI for provisioning, defaults, discovery, background tasks, and updates over letting each engineer install, configure, and update agent tools independently.

Rationale: A central CLI gives the Developer Experience team a way to roll out versions, helpful defaults, MCP discovery, and background execution consistently.

Invest in background-agent infrastructure.

Chose Minion and background task support over only interactive IDE or command-line agent sessions.

Rationale: Developers naturally start more tasks while waiting on agents, so background infrastructure is needed to support parallel work without leaving it as unmanaged local activity.

Use no-code Agent Builder alongside developer tools.

Chose Agent Builder and Agent Studio for building, debugging, tracing, versioning, evaluating, and registering workflows over requiring every agent workflow to be hand-coded or configured through CLI tooling.

Rationale: No-code workflow construction broadens who can build agents while Studio/registry features provide the observability and reuse needed for production workflows.

Gotchas (what bit them)

Agent rollouts can create runaway infrastructure and token costs once parallel usage becomes normal.

Root cause: Developers naturally start multiple background agents while waiting, which expands concurrent resource consumption and token spend.

Resolution: Make cost control, efficiency measurement, token optimization, and education explicit engineering-enablement responsibilities.

Providing tools is not enough to change developer behavior.

Root cause: Adoption was slower than expected even with a strong engineering culture and substantial platform investment.

Resolution: Use education, helpful defaults, and peer-shared wins rather than relying primarily on executive mandates.

Without a gateway, each internal endpoint-to-agent integration would recreate security and observability work.

Root cause: Uber has many internal service protocols and agent clients, so point integrations would spread authorization, telemetry, logging, and discovery concerns across teams.

Resolution: Centralize MCP exposure, registry, sandboxing, authorization, telemetry, and logging in MCP Gateway.

Rapidly evolving AI clients are hard to distribute consistently across thousands of engineers.

Root cause: Clients such as Cursor, Claude Code, Codex, and others change quickly, and teams need updated versions, useful defaults, MCP configuration, and background-task access.

Resolution: Put provisioning, discovery, background task execution, and updates behind the AIFX CLI.

More AI-generated code can increase review noise and routing pressure.

Root cause: Higher AI-generated code and agent-authored PR volume create more pull requests and review work.

Resolution: Build Code Inbox for smart routing and uReview for high-signal review comments rather than generic noisy feedback.

Evaluation

The case reports operational adoption and platform usage rather than a controlled productivity evaluation. The main evidence is usage telemetry, adoption metrics, PR/code-generation shares, specialized-agent throughput, cost growth, and qualitative lessons about adoption speed and peer sharing.

Metrics: agentic coding user share · AI-generated code share in IDE tools · Claude Code usage share over time · monthly agent-user share · agent-opened pull request share · unit tests generated per month · AI-related cost growth · token cost optimization priority · adoption speed versus expectations

Outcomes

• Uber built a layered internal AI-agent platform spanning model gateway, internal context, industry clients, specialized agents, MCP Gateway, AIFX CLI, Agent Builder/Studio, Minion, and engineering enablement.
• 84% of developers were reported as agentic coding users, and 92% used agents monthly.
• IDE-based tools generated 65-72% of code, while 11% of pull requests were opened by agents.
• Claude Code usage nearly doubled from 32% to 63% over three months.
• Autocover generated more than 5,000 unit tests per month, and Shepherd handled large-scale migrations end to end.
• The rollout exposed real operating costs: AI-related costs rose 6x since 2024 and token cost optimization became a priority.

The source describes a tech function of almost 3,000 people, 84% agentic coding users, 92% monthly agent use, 65-72% AI-generated code in IDE tools, 11% PRs opened by agents, Claude Code usage rising from 32% to 63% in three months, 5,000+ generated unit tests per month, and 6x AI-related cost growth since 2024.