AI Engineer World's Fair 2026
Building uReview, Uber’s Multi-Agent Code Review Engine — Will Bond & Ameya Ketkar, Uber
Loading slides…
Read the talk
Building uReview, Uber’s Multi-Agent Code Review Engine
Will Bond and Ameya Ketkar explain how Uber routes code changes through multiple reviewers, filters their output, learns from developer behavior, and lets hundreds of teams maintain local rules without giving up platform-wide consistency.
From a talk by Will Bond and Ameya Ketkar
At a glance
Ideas worth remembering
uReview separates review surfaces from generators, then rates, categorizes, filters, and deduplicates candidate comments before delivering them.
Useful observability combines what developers say, what they change, and how the agent produced its finding: sentiment, addressal rate, and agent trajectories answer different questions.
Team-owned review rules need ownership integration, nearby configuration, deterministic routing, and feedback to their authors. Writing a skill was easier than operating it consistently and cheaply at scale.
Uber reports around 25,000 comments per week, a 67% addressal rate, and 60% lower cost than a naive implementation. Addressal measures developer behavior, while the reported 70% quality and accuracy improvement lacks enough methodology to reproduce.
Agent-facing reviews need greater accuracy because a bad comment can induce repeated changes and reversals. As agents assume more detailed work, the speakers propose moving human review toward architecture, domain expertise, and product judgment.
As pull requests grew, review became the bottleneck
Uber’s scale makes code review an allocation problem as much as a code-quality problem. Thousands of engineers work across hundreds of teams, 12 sites, and six language-specific monorepos. Over the preceding 24 months, both pull-request volume and pull-request size grew. The company’s time to first review rose from three hours in 2024 to nine hours in 2026, leading Bond to identify review as the new bottleneck. Those numbers explain why Uber invested in automation; they do not by themselves measure uReview’s impact.
Uber built uReview internally partly because its development surfaces were in transition. The company was using Phabricator while migrating to GitHub, and Bond says most available products did not support Phabricator. Uber also wanted the same review rules to operate inside an agent’s coding loop, rather than creating one review regime for people and another for generated code.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Generate broadly, then control what reaches the engineer
GitHub, Phabricator, and the agent loop all send review requests into the uReview service. The service also receives user feedback and routes work among multiple generators tuned for different cost and performance characteristics. Third-party review systems can plug into the same architecture, giving Uber a way to compare internal generators with outside alternatives.
Multiple generators create an immediate product problem: overlapping findings can flood a pull request with repetitive comments. uReview separates candidate generation from publication. A post-processing stage rates, categorizes, filters, and deduplicates comments, with the goal of showing engineers only actionable, high-confidence findings. The talk does not reveal the scoring thresholds or deduplication algorithm, so this is an architectural description rather than a reproducible ranking recipe.
The uReview request and comment pipeline
Read the diagram as text
- Review surfaces. input — GitHub, Phabricator, and the agent loop submit review requests.
- uReview service. platform — Receives requests and user feedback, then routes review work.
- Review generators. generation — Multiple internal generators are tuned for different cost and performance characteristics.
- Third-party reviewers. generation — External review systems can be connected for comparison.
- Comment post-processing. control — Rates, categorizes, filters, and deduplicates proposed comments.
- Engineer or coding agent. output — Receives the selected actionable, high-confidence findings.
- User feedback. evaluation — Responses return to the service and evaluation system.
- Review surfaces → uReview service: review request.
- uReview service → Review generators: routes work.
- uReview service → Third-party reviewers: optional comparison.
- Review generators → Comment post-processing: candidate comments.
- Third-party reviewers → Comment post-processing: candidate comments.
- Comment post-processing → Engineer or coding agent: selected findings.
- Engineer or coding agent → User feedback: replies and actions.
- User feedback → uReview service: evaluation signal.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Cost and surveys could not explain review quality
The first uReview implementation was deliberately small: one prompt performed per-file logic checks, a simple agent conducted a more thorough review, and a dispatcher chose which generator to use. Its observability was similarly coarse—cost tracking, an NPS survey, Google Forms, and Slack support. The team could see that quality relative to cost varied widely, but those signals did not explain which comments failed or why.
The next iteration classified developers’ replies to uReview comments by positive or negative sentiment and by additional categories. Aggregating those responses exposed recurring classes of bugs and system issues that the uReview team could address. Ketkar reports that this moved many pull requests toward a better quality-to-cost position.
The team then added two complementary signals. Addressal rate asks whether a developer changes the code after receiving a comment. Agent trajectories act as runtime profiles, recording the tool calls and the system’s recorded reasoning process behind a review. Sentiment captures what developers say, addressal captures what they do, and trajectories show how the reviewer reached its result. Together, these signals gave the team more useful evidence for tuning runtime, performance, quality, and cost.
The key warning is that a model does not reliably signal when its review is wrong. It can present a bad finding with confidence, so model confidence cannot replace team knowledge or evaluation. Teams need to supply their style guides, patterns, and anti-patterns. The runtime also needs guardrails that keep the agent from wasting turns: review has a useful time budget, and irrelevant work consumes both time and inference cost while potentially degrading the result.
The review-improvement loop
Read the diagram as text
- uReview comment. The system publishes a selected review finding.
- Developer signals. Reply sentiment and whether the comment is addressed provide different evidence about usefulness.
- Agent trajectory. Tool calls and the recorded reasoning process reveal how the finding was produced.
- Failure diagnosis. Recurring bug and issue categories become visible.
- Runtime and rule tuning. Teams adjust prompts, performance, guidance, and guardrails.
- uReview comment → Developer signals: elicits reaction or action.
- uReview comment → Agent trajectory: has an execution history.
- Developer signals → Failure diagnosis: reveals recurring outcomes.
- Agent trajectory → Failure diagnosis: explains production path.
- Failure diagnosis → Runtime and rule tuning: guides changes.
- Runtime and rule tuning → uReview comment: changes future reviews.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
From general reviewers to team-owned agents
uReview’s customization stack begins with two scopes of general review. A single-file reviewer looks for logic bugs within each file. A deeper multi-file reviewer incorporates anti-patterns and style guides from Uber’s six monorepos, allowing it to reason across a larger change rather than treating every file independently.
The platform then adds more specialized mechanisms:
- AI linters: Few-shot systems gather context in a more controlled way and apply rules to a file to find systematic, mechanical issues. Ketkar describes deterministic context collection, but the talk does not establish that the model’s final judgment is deterministic.
- Custom agents: Teams can define a reviewer connected to their knowledge base, previous pull requests, and a review skill. This carries more local history and procedure than the general reviewers.
Making custom agents available was harder than exposing a prompt box. uReview ties them to Uber’s ownership model, stores customizations near the code so developers can update them, and uses deterministic routing to decide which team receives which review type, model, and generator. These choices make ownership and execution discoverable instead of relying on a parallel registry maintained by the central platform team.
Rule authors also need to see the consequences of their work. uReview returns agent trajectories, addressal rates, and sentiment analysis to contributing teams. A team can discover that developers dislike or ignore a rule and revise it. Writing the initial skill was often easy—Ketkar says teams could ask Claude to derive one from previous pull-request reviews. Running those skills at organizational scale with consistent quality and low cost required repeated work from both the platform team and each team authoring rules.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
What the reported results do—and do not—show
Ketkar reports that uReview produces around 25,000 comments each week. About 10% of comments receive some feedback, while 4% of pull requests receive negative feedback. Those percentages have different denominators and should not be combined into an approval rate. Silence also does not prove that a comment was correct or useful.
The overall addressal rate is around 67%, and developers address almost three quarters of high-severity issues. These figures show that developers act on a substantial portion of uReview’s output. Addressal is still a behavioral proxy: it does not directly prove that every addressed finding was correct or that it prevented a defect.
Compared with what Ketkar calls a naive implementation, Uber reports 60% lower cost and roughly 70% higher quality and accuracy after adding observability and evaluation. The talk does not define the quality or accuracy metrics, identify the measurement window, or say whether 70% is a relative increase or a percentage-point change. The result is therefore directionally useful but not independently reproducible from the presentation.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Agent-facing review raises the accuracy requirement
The final part shifts from uReview’s current operation to where the speakers expect software development to go. Engineers are interacting with implementation details less as agents write more code. Humans still approved code at the time of the talk, while Bond presents automatic approval and landing for some percentage of changes as a near-future direction rather than a shipped uReview result.
A single review platform can serve humans and agents, but the audiences behave differently. Humans become frustrated by a pull request covered in 100 minor comments; an agent will work through them. Yet agent willingness makes bad feedback more dangerous, not less. An inaccurate comment can make an agent change the code, request another review, and then reverse the change after the next comment. Accuracy must rise because errors can create an unstable review-and-repair cycle.
This creates a second problem: uReview improved by learning from human reactions and actions. If humans leave the detailed review loop, the system loses part of the feedback that helped tune its prompts and agents. Bond warns that removing that corrective signal could lead to quality degradation and low-quality generated code, but the talk does not specify a replacement feedback mechanism.
The proposed answer is to expand the outer loop rather than eliminate it. Agents take on more implementation and detailed review, while engineers move their attention toward architecture, domain expertise, and product thinking. Bond includes performance optimization and API compatibility among the implementation concerns that agents may increasingly handle. The human role becomes guidance at a higher level—but preserving effective feedback while making that move remains an open design problem.
Human-facing and agent-facing review loops
Read the diagram as text
- Review for a human. human-facing — High comment volume, including 100 small nits, can frustrate an engineer.
- Human evaluates and changes code. human-facing — Reactions and addressal provide feedback for improving the reviewer.
- Review for an agent. agent-facing — The agent is willing to process a large number of findings.
- Agent changes code. agent-facing — The agent acts on the review comment and requests another review.
- Possible reversal. agent-facing — A low-quality comment can make the next review send the agent backward.
- Expanded human outer loop. future-role — Engineers concentrate on architecture, domain expertise, and product thinking.
- Review for a human → Human evaluates and changes code: human judges the finding.
- Human evaluates and changes code → Review for a human: feedback tunes reviews.
- Review for an agent → Agent changes code: comment triggers a change.
- Agent changes code → Possible reversal: next review contradicts it.
- Possible reversal → Review for an agent: repeated review cycle.
- Human evaluates and changes code → Expanded human outer loop: responsibility moves up a layer.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Resources
From the talk
The official AI Engineer page includes the recording, timestamped transcript, chapter navigation, and a reading version of the talk.
Further reading
- Will Bond on XReference
Bond’s supplied speaker profile identifies his work on AI developer experience and uReview.
- AI EngineerReference
Conference organizer and publisher of the recording.
Related talks
- Agentic SDLC at Uber - Building Blocks for Uber’s Software Factory
Provides the adjacent Uber architecture behind the agent inner loop that uReview is intended to serve.
- AI-powered entomology: Lessons from millions of AI code reviews
Examines the closely related problem of distinguishing useful pull-request findings from hallucinated or unwanted comments.
- Agents reported thousands of bugs, how many were real? - Ian Butler and Nick Gregory
Adds a useful counterpoint on false-positive rates and the difficulty of verifying agent-generated bug reports.
Full transcript
Loading transcript…