AI Engineer · Published 2026-08-21

Building Blocks for Uber’s Software Factory— Uday Kiran Medisetty & Adam Huda, Uber

privateReview: unreviewedConfidence: high
Software FactoryAgentic AImodel gatewayMCP gatewaydevpodsContext Graphagentic-aisoftware-factorymodel-gatewayMCPcontext-graphagent-skillstoken-optimization
Open on YouTube ↗

Summary

Overview

  • Speaker: Uday Kiran Medisetty and Adam Huda
  • Channel: AI Engineer
  • Main topic: Agentic AI at Uber scale and building blocks for an AI-native software engineering factory
  • Purpose: To showcase Uber's enterprise-scale architecture and building blocks for an AI-native software engineering factory and demonstrate how agentic workflows operate across the SDLC. Uday Kiran Medisetty and Adam Huda discuss Uber's journey towards a managed software factory powered by agentic AI. Operating across 12 global tech hubs with thousands of engineers, Uber has invested in agentic AI to double line-of-code velocity and automate migration and engineering toil. The talk outlines six core building blocks: Model Gateway, MCP Gateway, DevPods, Agent Skills, Context Graph, and AI Assistant (Cortana), followed by an end-to-end demonstration of how an idea moves from Slack to specs, PRs, self-improvement validation, and codebase maintenance.

Topic Map

Context and Scale of Agentic AI at Uber

  • Explanation: Uday introduces Uber's engineering footprint and how agentic AI investments have drastically improved PR adoption, code volume, and migration toil reduction.
  • Key claims:
    • Over 70% of PRs are now assisted by local or cloud agents.
    • Lines of code per engineer have more than doubled year over year.
    • Over 250 automated migrations have reduced 9 million lines of code automatically.
  • Examples:
    • Moving to monorepos and Bazel established solid foundations for agentic scale.
  • Terminology:
    • Agentic AI
    • Software Factory
    • DevPods
  • Why it matters: Demonstrates that agentic AI can achieve enterprise-wide adoption and dramatically accelerate engineering velocity at massive scale.

Building Block 1: Model Gateway

  • Explanation: Uber's centralized gateway ensuring zero PII leaves perimeter boundaries, bounded latency guards, cost attribution, and LLM caching.
  • Key claims:
    • No PII ever leaves Uber's perimeter by default.
    • Latency guards and AI Guard run under 100 milliseconds.
    • Requests are attributed per user, project, and team in real time and data lakes.
  • Examples:
    • Handling over 800 internal projects and over 100 million model requests per day.
  • Terminology:
    • Model Gateway
    • AI Guard
    • Redact PII
    • Token Optimization
  • Why it matters: Provides enterprise security, strict compliance, cost tracking, and safety guardrails across all internal and external models.

Building Block 2: MCP Gateway

  • Explanation: A centralized gateway for Model Context Protocol (MCP) servers, standardizing authentication, discovery, schema routing, and token optimization across thousands of internal and SaaS APIs.
  • Key claims:
    • Internal APIs and SaaS tools (Slack, Jira, GitHub) are automatically crawled and projected into MCPs.
    • Omni-MCP and CLI patterns prevent context bloat and reduce fleetwide token consumption by over 40%.
  • Examples:
    • Google, Slack, Jira, and GitHub tools integrated via MCP Gateway.
  • Terminology:
    • MCP Gateway
    • Model Context Protocol
    • Omni-MCP
    • Code Mode
  • Why it matters: Eliminates the friction of manual tool authentication and setup while massively optimizing token usage.

Building Block 3: DevPods

  • Explanation: Pre-provisioned Kubernetes balloon pods providing instant, isolated, globally available development and execution environments for agents and engineers.
  • Key claims:
    • DevPods come pre-provisioned with snapshotted repositories and search indexes, reducing startup to seconds.
    • Mega DevPods provide single common repositories for autonomous multi-repo coding agents.
  • Examples:
    • Pre-provisioned environments across global regions like Oregon, Virginia, Netherlands, São Paulo, and Mumbai.
  • Terminology:
    • DevPods
    • Mega DevPod
    • Kubernetes Balloon Pods
  • Why it matters: Enables fast, secure, isolated, and globally distributed execution environments for autonomous AI agents.

Building Block 4: Agent Skills

  • Explanation: A managed marketplace of 2,500+ core and domain-specific agent skills with automated lint checks, reviews, and continuous eval feedback loops.
  • Key claims:
    • Solves skill duplication, sub-par quality, and discovery hassles across repositories.
    • Drives over 20,000 skill executions per day across the engineering fleet.
  • Examples:
    • Auto-installing default skills based on engineer personas.
  • Terminology:
    • Agent Skills
    • Skill Marketplace
    • Lint Checks
  • Why it matters: Standardizes agent capabilities, eliminates redundant skill development, and ensures baseline quality through automated evals.

Building Block 5: Context Graph

  • Explanation: A unified context graph capturing 150 unique node/edge types and 40 million entries connecting mobile apps, backend services, data lakes, design docs, Jira issues, and bugs.
  • Key claims:
    • Connects scattered systems across Uber to help agents instantly find the correct context.
    • Significantly reduces token burn, latency, and unpredictable outcomes compared to unbounded searching.
  • Examples:
    • Answering mobility trip queries in India by mapping SQL tables and services automatically.
  • Terminology:
    • Context Graph
    • Node and Edge Types
  • Why it matters: Eliminates hallucination and latency caused by fragmented documentation and architecture across dozens of microservices.

Building Block 6: AI Assistant (Cortana)

  • Explanation: An enterprise AI assistant plugged into Slack, CLI, and web surfaces, leveraging skills, MCPs, and the Context Graph to answer questions and run workflows.
  • Key claims:
    • Generates over 300 unique personas and 20,000 sessions per day in the last month.
    • Allows custom skills and custom prompts hooked directly into team Slack channels.
  • Examples:
    • Idea jam on Slack seamlessly transitioning into requirements and specs via Cortana.
  • Terminology:
    • Cortana
    • AI Assistant
  • Why it matters: Provides a unified, personalized conversational interface across all enterprise surfaces for engineers and non-engineers alike.

End-to-End Demo: From Idea to PR to Maintenance

  • Explanation: Adam demonstrates how ideas generated in Slack are transformed into specs, handed off to Minion (Uber's coding agent), validated through inner and outer loops, and maintained automatically.
  • Key claims:
    • Minion handles cross-repo coding changes for backend and frontend simultaneously.
    • Validation inner and outer loops include static analysis, visual validation against Figma specs, and staging integration.
    • Self-healing CI and codebase maintenance agents run scheduled cleanups like feature flag removal.
  • Examples:
    • World Cup smart pickup feature A/B variant development and testing.
  • Terminology:
    • Minion
    • Inner Loop
    • Outer Loop
    • Visual Validation
    • Self-Healing CI
    • Code Review
    • Feature-Flag Cleanup
  • Why it matters: Illustrates a complete, production-grade agentic SDLC where code self-improves before human review.

Key Points

Security and compliance at the model gateway

  • Explanation: Ensuring PII never leaves enterprise perimeter boundaries while maintaining strict latency and cost attribution controls.
  • Evidence: Model Gateway routes all internal and external model requests under 100ms with built-in PII redaction.
  • Practical implication: Enterprises can safely adopt frontier and open-source models without risking data leaks.

Token optimization via MCP and CLI patterns

  • Explanation: Standardizing tool access through MCP gateways and code mode CLIs drastically cuts token consumption.
  • Evidence: Over 1,000 MCP tools optimized with code mode saved over 40% fleetwide token costs.
  • Practical implication: Reduces API costs and prevents context window saturation during complex agent runs.

Context graphs over raw unstructured search

  • Explanation: A unified knowledge graph connecting code, Jira, design docs, and services prevents agents from wasting tokens searching.
  • Evidence: Context Graph with 40M entries and 150 node/edge types dramatically improves SQL generation and service discovery.
  • Practical implication: Drastically lowers latency, token burn, and hallucinations in multi-repository workflows.

Shift-left validation and self-healing CI

  • Explanation: Validating code changes via inner-loop static analysis, visual Figma comparison, and staging integration before human review.
  • Evidence: Minion runs inner-loop validation and self-healing fixes before presenting PRs to human reviewers.
  • Practical implication: Reduces human review burden and prevents buggy code from hitting standard CI pipelines.

Frameworks, Models & Processes

Uber's Agentic SDLC Building Blocks

  • How it works: Six layered building blocks spanning model routing, tool integration, execution environments, skill marketplaces, context mapping, and conversational interfaces.
  • Components:
    • Model Gateway
    • MCP Gateway
    • DevPods
    • Agent Skills
    • Context Graph
    • AI Assistant (Cortana)
  • When to use: When scaling AI agent development across enterprise engineering organizations.

Examples & Case Studies

Engineers brainstormed a World Cup smart pickup feature on Slack, tagged Cortana, and generated structured product requirements and Figma mockups automatically.

  • Illustrates: Idea jam on Slack transitioning to specs via AI Assistant.
  • Lesson: AI assistants connected to context graphs can compress weeks of alignment into minutes.

Minion created draft PRs across backend and frontend repositories, ran visual validation against Figma specs in a DevPod, and resolved merge conflicts automatically.

  • Illustrates: From specs to PRs using Minion and DevPods.
  • Lesson: Autonomous coding agents can execute multi-repo changes securely when backed by proper development environments and validation loops.

A scheduled maintenance skill automatically cleaned up unused feature flags across repos on Sunday when CI capacity was high.

  • Illustrates: The codebase maintaining itself via scheduled maintenance skills.
  • Lesson: Routine codebase hygiene and tech debt reduction can be fully automated using scheduled agent loops.

Actionable Takeaways

  • Immediate:
    • Implement a centralized model gateway with PII redaction and latency guards.
    • Adopt MCP gateways to streamline tool integration and reduce token costs.
    • Establish pre-provisioned ephemeral dev environments for agents.
  • Strategic:
    • Build a unified enterprise context graph to supply accurate grounding for autonomous agents.
    • Shift validation left by incorporating inner-loop visual and static checks before human code review.
    • Automate codebase maintenance and tech debt cleanup through scheduled agentic skills.
  • Questions to investigate:
    • How do we manage infrastructure bottlenecks and CI capacity as agentic output scales?
    • What is the optimal balance between model capability and execution speed in inner vs. outer loops?

Claims Worth Verifying

  • Uber achieved a 2x increase in lines of code per engineer year over year through agentic AI. (Metric)
  • Over 70% of PRs at Uber are now assisted by local or cloud agents. (Adoption Metric)
  • Model gateway PII redaction and AI guard run under 100 milliseconds. (Performance Claim)

Notable Quotes

"Over the last year, all of the investments we made in agentic AI have led to more than 70% of our PRs now either by local or cloud agents." "Every PR self-improves before a human sees it."

Compressed Summary

  • Uber scaled agentic AI across 12 tech hubs, doubling line-of-code velocity.
  • Six core building blocks: Model Gateway, MCP Gateway, DevPods, Agent Skills, Context Graph, and Cortana.
  • Minion agent automates multi-repo coding from specs to PRs with inner-loop validation.
  • Scheduled maintenance agents autonomously clean up tech debt and unused feature flags.
  • Keywords: software factory, agentic ai, model gateway, mcp gateway, devpods, context graph
  • Core insight: Enterprise-scale agentic AI requires foundational building blocks—such as secure model gateways, context graphs, and self-healing validation loops—to transform fragmented codebases into a managed software factory.

Core insights

7
Architecturemedium noveltystrong evidence

Uber routes all LLM traffic through a single Model Gateway that enforces PII redaction, sub-100ms latency/safety guards, LLM caching, and per-user/project/team cost attribution at platform level rather than in each application, at a scale of 800 internal projects and 100M+ model requests per day.

Why it matters

Safety, compliance, and cost accounting become platform invariants enforced once, instead of per-team responsibilities that drift and cannot be audited centrally. It also means every model call in the company transits one control plane, making that plane a critical latency and availability dependency.

Generalization

Any org running multiple LLM-consuming applications should push PII boundaries, guardrails, caching, and cost attribution into a shared inference gateway rather than an SDK convention, and must then budget for that gateway being in the hot path.

No PII ever leaves Uber's perimeter by default.
Open source video
Latency guards and AI Guard run under 100 milliseconds.
Open source video
Requests are attributed per user, project, and team in real time and data lakes.
Open source video
Handling over 800 internal projects and over 100 million model requests per day.
Open source video
Mechanismhigh noveltymoderate evidence

The MCP Gateway auto-crawls internal APIs and SaaS tools and projects them into MCP servers, and specific tool-representation patterns (Omni-MCP and 'Code Mode') cut fleetwide token consumption by over 40%.

Why it matters

It frames tool/context bloat as a fleet-level cost and latency problem solved by changing how tools are represented to the model, not by writing better prompts. Automatic projection also removes per-team tool auth and setup work.

Generalization

Tool exposure format is a first-class optimization dimension: aggregating/compressing tool surfaces (or exposing them as code rather than discrete schemas) can dominate other token-reduction efforts when many tools are available.

Omni-MCP and CLI patterns prevent context bloat and reduce fleetwide token consumption by over 40%.
Open source video
Internal APIs and SaaS tools (Slack, Jira, GitHub) are automatically crawled and projected into MCPs.
Open source video
Eliminates the friction of manual tool authentication and setup while massively optimizing token usage.
Open source video
Architecturehigh noveltymoderate evidence

Uber built a typed Context Graph (150 node/edge types, 40M entries) spanning services, data lakes, design docs, Jira issues, and bugs, explicitly as a bounded alternative to unbounded agentic search, and claims it reduces token burn, latency, and unpredictable outcomes.

Why it matters

It positions curated, schema-bound retrieval as the reliability mechanism for agent context, implying that 'let the agent explore the repo/graph' is a measurable cost and determinism failure mode rather than a flexibility win.

Generalization

For large distributed codebases and tool fleets, investing in a maintained typed index may beat retrieval-by-exploration on token cost, latency, and output variance — but shifts cost into index construction and freshness maintenance.

A unified context graph capturing 150 unique node/edge types and 40 million entries connecting mobile apps, backend services, data lakes, design docs, Jira issues, and bugs.
Open source video
Significantly reduces token burn, latency, and unpredictable outcomes compared to unbounded searching.
Open source video
Mechanismhigh noveltystrong evidence

DevPods are pre-provisioned Kubernetes 'balloon pods' with snapshotted repositories and search indexes that bring agent environment startup down to seconds, deployed regionally; Mega DevPods give multi-repo autonomous agents a single common repository.

Why it matters

It identifies environment provisioning as a dominant latency and reliability cost in agentic coding, addressed by snapshot-based warm starts and shared workspaces rather than by faster models.

Generalization

Agent throughput is often gated by sandbox cold start and repo/index hydration, so snapshotting warmed execution environments is a transferable infrastructure pattern; shared workspaces for multi-repo agents trade isolation for cross-repo editing capability.

DevPods come pre-provisioned with snapshotted repositories and search indexes, reducing startup to seconds.
Open source video
Mega DevPods provide single common repositories for autonomous multi-repo coding agents.
Open source video
Pre-provisioned environments across global regions like Oregon, Virginia, Netherlands, São Paulo, and Mumbai.
Open source video
Practicemedium noveltystrong evidence

Agent Skills are managed as a governed registry — 2,500+ core and domain skills with automated lint checks, reviews, and continuous eval feedback loops, persona-based auto-install, and ~20,000 executions/day — explicitly to eliminate duplication, sub-par quality, and discovery problems across repositories.

Why it matters

It treats prompts/tool bundles as versioned, evaluated, supply-chained artifacts under central quality gates, which is the difference between a skill marketplace and scattered prompt snippets in repos.

Generalization

Once agents execute skills at fleet scale, skill quality becomes a package-management problem: you need lint, review, evals, distribution, and default installation, not just authoring conventions.

A managed marketplace of 2,500+ core and domain-specific agent skills with automated lint checks, reviews, and continuous eval feedback loops.
Open source video
Solves skill duplication, sub-par quality, and discovery hassles across repositories.
Open source video
Drives over 20,000 skill executions per day across the engineering fleet.
Open source video
Practicehigh noveltymoderate evidence

Validation is split into inner and outer loops that run before human review — static analysis, visual validation against Figma specs, and staging integration — plus self-healing CI and scheduled maintenance agents for tasks like feature-flag removal, so code self-improves prior to human inspection.

Why it matters

It relocates the quality gate upstream of code review, changing the human role from first-pass defect finder to downstream confirmer, and expands the agent's permitted action space into CI and maintenance.

Generalization

Autonomous coding pipelines need layered automated validation (static, visual/spec-conformance, integration) if they are to reduce human review load rather than just shift it; the same automation that repairs CI can also weaken checks, so CI-introspection permissions need explicit governance.

Validation inner and outer loops include static analysis, visual validation against Figma specs, and staging integration.
Open source video
Self-healing CI and codebase maintenance agents run scheduled cleanups like feature flag removal.
Open source video
Minion handles cross-repo coding changes for backend and frontend simultaneously.
Open source video
Mental Modelmedium noveltyweak evidence

Uber attributes its agentic scale partly to prior infrastructure consolidation: monorepos and Bazel are described as the foundation that made cross-repo agentic work tractable.

Why it matters

It suggests agent effectiveness is downstream of repo/build topology, so teams with fragmented repos may hit structural ceilings on cross-repo agents regardless of model quality.

Generalization

Before investing in multi-repo coding agents, assess whether build/topology consolidation is the actual prerequisite; agent ROI is partly an artifact of prior engineering-platform decisions.

Moving to monorepos and Bazel established solid foundations for agentic scale.
Open source video

Deep dives

5

Centralized inference gateway as a critical-path dependency

Research question

How do you budget and degrade a shared Model Gateway (PII redaction, guard, cache, attribution) so that one control-plane hop does not become the availability and latency ceiling for every AI feature in the company?

Why

Uber's scale claim (800 projects, 100M+ requests/day) plus a sub-100ms guard budget means the gateway's own SLOs are now the SLOs of all internal AI. Most orgs adopting a gateway decide the policy but never model the failure domain or a degraded-mode contract.

No PII ever leaves Uber's perimeter by default.
Open source video
Latency guards and AI Guard run under 100 milliseconds.
Open source video
Handling over 800 internal projects and over 100 million model requests per day.
Open source video
Requests are attributed per user, project, and team in real time and data lakes.
Open source video
Source video

Freshness and coverage failure of a bounded typed context graph

Research question

At what staleness threshold does a 150-node-type, 40M-entry context graph produce confidently wrong context, and are missed-context failures detectable at inference time?

Why

The graph is presented as the reliability mechanism replacing unbounded search, but a curated index converts retrieval errors from visible (agent finds nothing) to silent (agent finds plausible stale edges). Coverage gaps need their own observability before the graph can be trusted as a determinism control.

A unified context graph capturing 150 unique node/edge types and 40 million entries connecting mobile apps, backend services, data lakes, design docs, Jira issues, and bugs.
Open source video
Significantly reduces token burn, latency, and unpredictable outcomes compared to unbounded searching.
Open source video
Source video

Validator escape rate in pre-review automated validation loops

Research question

What fraction of agent-authored changes pass static analysis, visual-spec validation, and staging integration and still require substantive human correction, and who validates the validators?

Why

Moving the quality gate upstream of human review only reduces review load if the automated loops have measured escape rates. Visual validation against Figma specs in particular has a spec that may itself be wrong or outdated, so the loop can systematically bless incorrect output.

Validation inner and outer loops include static analysis, visual validation against Figma specs, and staging integration.
Open source video
Minion handles cross-repo coding changes for backend and frontend simultaneously.
Open source video
Source video

Tool representation as the dominant token lever

Research question

Does representation-level compression (Omni-MCP, Code Mode) keep outpacing context growth as tool and skill surfaces expand, or does auto-installed capability re-inflate the prompt?

Why

A 40% fleetwide reduction from changing how tools are represented reframes context budget as an interface-design problem. But persona-based auto-install and a 2,500-skill marketplace push in the opposite direction, so the net trajectory is an empirical question, not a settled win.

Omni-MCP and CLI patterns prevent context bloat and reduce fleetwide token consumption by over 40%.
Open source video
Internal APIs and SaaS tools (Slack, Jira, GitHub) are automatically crawled and projected into MCPs.
Open source video
Auto-installing default skills based on engineer personas.
Open source video
Source video

Agent environments as fleet infrastructure

Research question

What is the cost, eviction, and isolation contract for pre-warmed snapshot DevPods and shared Mega DevPods when autonomous multi-repo agents run concurrently across regions?

Why

Startup-to-seconds is framed as the throughput unlock, but shared workspaces for multi-repo agents trade repository isolation for cross-repo editing, and idle pre-provisioned pods across five regions create a standing cost and a contention surface that the talk does not quantify.

DevPods come pre-provisioned with snapshotted repositories and search indexes, reducing startup to seconds.
Open source video
Mega DevPods provide single common repositories for autonomous multi-repo coding agents.
Open source video
Pre-provisioned environments across global regions like Oregon, Virginia, Netherlands, São Paulo, and Mumbai.
Open source video
Source video

Article ideas

4

Your AI Gateway Is a Production Service, Not a Policy Checklist

Once PII redaction, guardrails, caching, and cost attribution live in a shared model gateway, compliance stops being a code-review concern and becomes an SLO problem: the gateway becomes a shared failure domain whose latency budget caps every feature built on it, and teams that adopt it without a degraded-mode contract have centralized their risk rather than reduced it.

Angle

Treat gateway adoption as a reliability engineering decision: define the hot-path budget, the fail-open/fail-closed matrix per guard, and the blast radius of a gateway incident across all consuming projects.

Source video

Token Efficiency Is a Tool-Interface Problem, Not a Prompt Problem

Fleetwide token consumption is governed primarily by how tools and context are represented to the model, not by prompt phrasing: aggregating tool surfaces or exposing them as code instead of discrete schemas can dominate every other optimization, which means context budget should be owned by the gateway/tooling layer rather than by individual prompt authors.

Angle

Reframe context bloat as an interface design and platform-ownership question, with representation patterns (aggregated tool surfaces, code-mode exposure) as the primary lever and prompt tuning as the residual.

Source video

Your Agentic Velocity Metrics Are Measuring the Wrong Thing

Adoption percentage and lines-of-code velocity are throughput metrics that cannot distinguish faster delivery from faster rework; without pairing them against revert rate, post-merge defect rate, and review time, an org can report doubled LOC while quality silently degrades, and the same blind spot applies to automated migration claims at fleet scale.

Angle

Build the counter-metric set that must ship alongside any agentic adoption dashboard, and treat a single systematic agent mistake propagated across millions of auto-migrated lines as the canonical tail risk.

Source video

Skill Marketplaces Are Package Registries and Should Be Governed Like One

Once agents execute skills at fleet scale, skill quality becomes supply-chain management: lint, review, evals, distribution, and default installation are the minimum controls, and persona-based auto-install is in direct tension with token-optimization goals because it inflates the tool surface for every engineer whether or not the skill is relevant.

Angle

Argue that skill authoring conventions are insufficient and map the required package-management controls onto agent skills, including the cost of defaults.

Source video

Project ideas

4

Escape-Rate Harness for Agent-Authored PRs

beyond-evals

A measurable fraction (target: quantify, not assume) of agent-authored changes that pass static analysis, spec/visual validation, and staging integration still require substantive human correction, and that escape rate varies systematically by change type (cross-repo, UI-vs-backend, migration).

Proof of concept

Instrument a pipeline that tags agent-authored PRs with which inner/outer loops they passed, then sample post-merge for substantive human follow-up commits within N days; report escape rate per loop combination and per change category on a fixed task suite.

Measurement

Escape rate (share of loop-passing PRs needing substantive correction), stratified by loop coverage and change type; false-pass rate of visual/spec validation against a known-good reference set.

Source video

Staleness-Conditioned Context Graph Retrieval Benchmark

beyond-evals

Agent answer accuracy degrades measurably with graph staleness, and missed-context failures from a bounded typed index are not detectable at inference time as errors, producing confident wrong answers rather than visible retrieval failures.

Proof of concept

Build a small typed context index over a toy multi-repo/service set, introduce controlled staleness (renamed services, deleted tickets, superseded design docs), and run identical agent tasks with a bounded-index retriever versus unbounded search; score for wrongness and for whether the agent signaled uncertainty.

Measurement

Accuracy and silent-error rate vs staleness level; token burn and latency delta between bounded-index and unbounded-search retrieval; rate at which the agent flags low confidence when the needed edge is missing.

Source video

Lineage-Correlated Gateway Cost Attribution

gatehouse

Per-feature unit economics cannot be reconstructed from gateway telemetry alone unless a trace-correlation ID is propagated across agent hops, so multi-agent fan-out silently misattributes cost to the originating user or project.

Proof of concept

Prototype a gateway shim that stamps a correlation ID at the first request, propagates it through nested agent/sub-agent calls, and attempts to reconstruct per-user-action cost from gateway logs only; compare against an instrumented end-to-end trace as ground truth.

Measurement

Reconstruction error between gateway-only attribution and ground-truth trace cost per user action; fraction of fan-out requests that lose lineage without explicit propagation.

Source video

Context Surface Growth Tracker

movement-lab

Fleetwide token-per-task does not stay reduced as tool and skill counts grow: persona-based auto-install and marketplace expansion re-inflate the effective tool/context surface, eventually outpacing representation-level compression.

Proof of concept

Stand up a synthetic agent fleet with adjustable tool counts and auto-installed skill sets, apply representation-level optimizations (aggregated tool surfaces, code-mode exposure) and then grow the surface, tracking tokens per completed task across both regimes.

Measurement

Tokens per task as a function of installed tool/skill count, with and without representation-level optimization; crossover point where surface growth cancels the compression gain.

Source video

Architectural implications

5

PII handling and model safety move from per-application code into a shared gateway.

Before

Each app/builder independently handles redaction, provider credentials, guardrails, and caching.

After

A single Model Gateway is the enforcement and observability point for every model request.

Consequence

Compliance becomes auditable and uniform, but the gateway becomes a shared failure domain and latency contributor whose own SLOs are now on the critical path of all AI features.

Source video

Tool integration shifts from hand-written per-tool connectors to auto-projected MCP servers behind a gateway.

Before

Engineers manually authenticate and wire each internal API or SaaS tool into each agent.

After

APIs are crawled and projected into MCPs with standardized auth, discovery, and schema routing.

Consequence

Tool onboarding cost drops, tool supply expands rapidly, and the token/context budget becomes the binding constraint — forcing representation-level optimizations like Omni-MCP and Code Mode.

Source video

Context retrieval moves from search-at-inference-time to a maintained typed graph.

Before

Agents issue exploratory queries/searches and assemble context on the fly.

After

Agents read from a bounded graph of typed nodes and edges spanning code, docs, tickets, and data.

Consequence

Lower token burn and latency plus more predictable outputs, at the cost of a new continuously-maintained index whose coverage gaps become a silent source of wrong answers.

Source video

Code validation runs before human review rather than at human review.

Before

Human code review is the primary quality gate for agent and human code.

After

Inner/outer automated loops (static analysis, spec-conformance visual diff, staging integration) gate the change first.

Consequence

Human review effort can be redirected to design and risk judgment, but validating agents now need their own trust model and can only be as good as the specs (e.g., Figma) they compare against.

Source video

Agent execution environments move from per-developer setup to pre-warmed shared/fleet infrastructure.

Before

Agents and engineers provision or clone environments on demand, incurring cold starts.

After

DevPods with snapshotted repos and indexes are pre-provisioned regionally, with Mega DevPods for multi-repo agents.

Consequence

Startup drops to seconds and cross-repo edits become feasible, but shared workspaces trade isolation for capability and require cost/eviction policy for idle pods.

Source video

Tradeoffs and failure modes

5

Centralized model gateway

Benefit

Uniform PII redaction, guardrails, caching, and per-team cost attribution across 800 projects and 100M+ daily requests.

Cost or risk

Every model call depends on one shared hop; the summary's own guard latency budget (sub-100ms) constrains it, and gateway degradation would stall all internal AI features.

Latency guards and AI Guard run under 100 milliseconds.
Open source video
Source video

Bounded context graph instead of unbounded search

Benefit

Reduced token burn, latency, and unpredictable outcomes relative to open-ended search.

Cost or risk

A curated 150-type, 40M-entry graph can miss rare or novel context and requires continuous maintenance; stale edges yield confident but wrong context, and coverage gaps are hard to observe as failures.

Significantly reduces token burn, latency, and unpredictable outcomes compared to unbounded searching.
Open source video
Source video

Large-scale automated migration

Benefit

Over 250 migrations and 9 million lines of code changed automatically.

Cost or risk

High-volume automated refactors can propagate a single systematic mistake fleet-wide before humans notice, so migration correctness needs independent verification rather than spot checks.

Over 250 automated migrations have reduced 9 million lines of code automatically.
Open source video
Source video

Persona-based auto-installed default skills

Benefit

Engineers get default capabilities without discovery or setup effort.

Cost or risk

Auto-installed skills inflate the system prompt/tool surface for everyone, creating context bloat and irrelevant-skill noise that works against the token-optimization goals of the MCP gateway.

Auto-installing default skills based on engineer personas.
Open source video
Source video

Self-healing CI and autonomous maintenance agents

Benefit

Scheduled cleanups like feature-flag removal and CI repair run without human initiation.

Cost or risk

An agent authorized to repair CI can also relax or rewrite checks to make a build pass, so CI-modifying agents need governance distinct from ordinary code-writing agents (risk inferred from the scope of action, not stated in the summary).

Self-healing CI and codebase maintenance agents run scheduled cleanups like feature flag removal.
Open source video
Source video

Open questions

5

What exactly counts as an 'agent-assisted' PR, and does the 70% adoption correlate with defect, revert, or review-cycle changes rather than only throughput?

Why unresolved

The summary reports adoption and LOC velocity but no quality or rework metrics, so faster code volume is indistinguishable from faster rework.

Research direction

Instrument adoption rate against revert rate, post-merge defect rate, review time, and time-to-first-change per PR to separate velocity from churn.

Source video

How is the Context Graph kept fresh and how are coverage gaps detected, given 150 node/edge types across code, docs, tickets, and data lakes?

Why unresolved

The summary states the graph exists and reduces unpredictability, but says nothing about staleness detection, ingestion cadence, or ownership of node types.

Research direction

Measure agent answer accuracy as a function of graph staleness and measure whether missed-context failures are detectable at inference time.

Source video

How trustworthy are the 'outer loop' validators, especially visual validation against Figma specs, and what catches cases where the validator itself is wrong or bypassed?

Why unresolved

The summary lists the validation mechanisms but provides no measured precision/recall or escape rate for changes that pass validation and are later found broken.

Research direction

Build an escape-rate benchmark: sample agent-authored PRs that passed inner/outer loops and measure how many required substantive human correction.

Source video

How does cost attribution work for multi-agent, multi-model chains where one user action fans out into many gateway requests across agents and sub-tasks?

Why unresolved

The summary claims attribution per user, project, and team but does not describe how lineage is preserved across agent hops.

Research direction

Define a trace-correlation ID propagated through agent calls and test whether per-feature unit economics can be reconstructed from gateway telemetry alone.

Source video

Do fleetwide token-consumption patterns (like the claimed 40% reduction) persist as tool counts and skill counts grow, or do auto-installed skills and expanding tool surfaces re-inflate context?

Why unresolved

The summary reports a point-in-time reduction without describing the measurement baseline or how it behaves as the marketplace and gateway surface expand.

Research direction

Track token per task over time while tool/skill counts grow, to see whether representation-level optimizations outpace surface growth.

Source video

Key claims

8
factualVerification needed

Over 70% of pull requests at Uber are now assisted by local or cloud agents.

Evidence

Over 70% of PRs are now assisted by local or cloud agents.

Question

How is 'assisted' defined and measured, and over what time window and population?

Source video
causalVerification needed

Lines of code per engineer more than doubled year over year following agentic AI investment.

Evidence

Lines of code per engineer have more than doubled year over year.

Question

Is the increase attributable to agents rather than headcount mix, measurement changes, or generated boilerplate?

Source video
comparativeVerification needed

Omni-MCP and CLI patterns reduced fleetwide token consumption by over 40%.

Evidence

Omni-MCP and CLI patterns prevent context bloat and reduce fleetwide token consumption by over 40%.

Question

What is the baseline, scope, and measurement method for the 40% reduction, and does it hold under growing tool/skill counts?

Source video
factualVerification needed

The Model Gateway handles over 800 internal projects and over 100 million model requests per day while keeping PII inside Uber's perimeter by default.

Evidence

Handling over 800 internal projects and over 100 million model requests per day.

Question

What fraction of traffic bypasses the gateway, and what is the measured false-negative rate of PII redaction?

Source video
comparativeVerification needed

A unified context graph spanning 150 node/edge types and 40 million entries reduces token burn, latency, and unpredictable outcomes versus unbounded searching.

Evidence

Significantly reduces token burn, latency, and unpredictable outcomes compared to unbounded searching.

Question

What is the measured delta versus an agentic-search baseline on the same tasks, and how does it degrade with graph staleness?

Source video
causalVerification needed

Agent Skills eliminate duplication, sub-par quality, and discovery problems and run over 20,000 executions per day.

Evidence

Drives over 20,000 skill executions per day across the engineering fleet.

Question

How is skill quality assessed beyond lint and review, and what is the failure rate of skill executions in production?

Source video
factualVerification needed

Minion performs cross-repo backend and frontend changes simultaneously, with validation covering static analysis, visual validation against Figma specs, and staging integration before human review.

Evidence

Validation inner and outer loops include static analysis, visual validation against Figma specs, and staging integration.

Question

What proportion of agent-authored changes pass all loops but still require substantive human correction?

Source video
factualVerification needed

Self-healing CI and maintenance agents autonomously perform scheduled cleanups such as feature-flag removal.

Evidence

Self-healing CI and codebase maintenance agents run scheduled cleanups like feature flag removal.

Question

What guardrails prevent a CI-repairing agent from weakening or disabling checks to achieve a passing build?

Source video

Connections

5