Source: The Pragmatic Engineer podcast, "Uber's AI infra, from the inside" (Gergely Orosz with Uber Distinguished Engineer Uday Kiran Medisetty, 2026-10-14; summary and transcript). Clip on SLATE posted by The Pragmatic Engineer on LinkedIn, 2026-11-16.
The idea in one paragraph
Uber already had SLATE, a per-engineer staging mechanism: deploy just the services your branch changes into your own short-lived instance, and route your test account's traffic to it, while every other upstream and downstream call goes to shared staging. Uber taught its coding agents to stand up a SLATE instance and gave them the service APIs to drive it. The agent then runs a browser against both main and the branch, produces a before-and-after regression report, and attaches screenshots and video to the pull request. The same pattern exists for iOS, Android and backend APIs. The point is less the tool than the order of work: the agent proves the change works end to end before a human reviews it.
Architecture
Branch-scoped deploy. Only the services touched by the change are deployed into an isolated instance. Everything else stays shared, so the environment is cheap and quick to create.
Identity-based routing. A test account's user ID is routed to the instance; other traffic is unaffected. Distributed tracing (Uber cites Jaeger) is what makes this routing practical across many services.
Agent-driven A/B run. An agent browser exercises the same flows against main and against the branch.
Evidence as an artifact. A diff-style report of behaviour, plus screenshots and video, is attached to the PR, so reviewers see what changed, not just the code.
Where it sits in Uber's wider agent stack (from the same episode)
Model Gateway (since 2023): one model- and harness-agnostic gateway across vendor and self-hosted models, extended with a security middleware that inspects requests and responses, per-user spend tracking, and audit logs and session traces.
AIFX: a wrapper over Claude Code, Codex and OpenCode so an engineer's settings, skills and plugins move with them when they switch harness.
Spend tiers: per-engineer budgets with manager sign-off to exceed them, plus a cost-coaching plugin; Uber reports roughly halving token costs over a few months.
Review triage: humans still review every PR, but by then AI review has run, evidence is attached and a risk score is assigned, so reviewers can budget attention.
CI pressure: CI jobs more than doubled in 12 months, prompting an internal "code red". Cheap checks (lint, build, template rules) moved into the agent's inner loop via a local validate command before a PR is opened.
Measuring work, not volume: instead of PR velocity, PRs are tagged feature, bugfix, maintenance, testing or docs, and the mix is tracked.
Built on old investments: the agent platform (Minion on DevPods from 2017, the MCP Gateway on existing Thrift and Protobuf registries, SLATE routing on tracing) reused a decade of developer tooling.
Why it matters
Verification moves left of review. As agents multiply PRs, human review becomes the bottleneck. Attaching executed evidence turns review from "does this look right" into "does this evidence match the intent".
Environment is the harness. The agent's quality ceiling is set by what it can safely run. A per-change environment is a better verifier than any prompt.
Reuse beats new agent infrastructure. Teams with good ephemeral environments, tracing and service registries can give agents end-to-end checking cheaply; teams without them will find this the expensive part.
Tradeoffs
Shared staging dependencies leak in. Only changed services are isolated; flaky or drifting shared staging can produce false regressions or hide real ones.
Routing by test identity works for request-scoped flows; async jobs, queues, batch pipelines and data migrations need separate isolation.
Cost and quotas. Every agent run can spin up instances; without TTLs and per-team quotas this becomes the next CI code red.
Visual diffs are noisy. Before-and-after screenshots flag benign changes; reports need thresholds and an explicit list of expected differences from the change's intent.
Failure modes to watch
The agent tests the flows it thinks of, not the ones the change breaks; coverage of the report must be visible.
Evidence is generated by the same agent that wrote the code, so it can be selectively favourable; reviewers should be able to rerun it.
Test accounts and seeded data drift from production shapes, so green runs overstate safety.
Agents with deploy rights to staging need scoped credentials and kill switches; an isolated instance should never be able to write to shared state it doesn't own.
Review checklist for adopting the pattern
Can an agent create, use and tear down a per-change environment without a human, with a TTL?
Is traffic isolation by identity, header or tenant, and what isn't covered by it (async work, data stores)?
Does the report compare against main on the same flows, and list which flows were exercised?
Is the evidence reproducible by the reviewer with one command?
Are cheap checks run in the agent's inner loop before CI?
Are environment spend and concurrency capped per team?
Related
R071 Uber's MCP Gateway (the tool layer the same agents use).
R001 Scaling Git at OpenAI (developer infrastructure strained by agent fan-out).
R047 Robinhood's Bazel build graph (build infrastructure for agent-scale change volume).
R099 Evaluating agents at Amazon (layered evaluation with humans in the loop).
R098 Stanford CS329A (why verifiers, not generators, set quality).