Agentic AI Foundation · Published 2026-09-28

Building a Debugging Agent Harness at Uber - Kriti Dangi

privateReview: unreviewedConfidence: high
debuggingai agentLangGraphMCPuberagent-harnessdeterministic-workflowcontext-engineeringagent-deploymentHuman-in-the-loopproduction-ml
Open on YouTube ↗

Summary

Overview

  • Speaker: Kriti Dangi
  • Channel: Agentic AI Foundation
  • Main topic: Building an AI-powered debugging agent harness (DebugAssist) at Uber using 11 MCP servers
  • Purpose: To share Uber's architecture, challenges, and impact of deploying autonomous agents for app quality and production bug resolution at scale. Uber senior software engineer Kriti Dangi presents DebugAssist, an AI-powered debugging agent harness built at Uber to tackle production crash investigations and reduce mean time to resolve issues. The system automates end-to-end debugging across discovery, auto-triage, deep root cause analysis (RCA) using models like Claude, and resolution, utilizing LangGraph combined with Model Context Protocol (MCP) servers and deterministic-AI hybrid pipelines.

Topic Map

Debugging in Reality at Uber

  • Explanation: Discusses the severe challenges of software debugging in massive mono-repo codebases with scattered context, unclear error messages, and cross-team dependencies.
  • Key claims:
    • Uber engineers take an average of 28 days to resolve an issue.
    • Developers spend 40% of their time debugging and fixing production issues.
    • Monorepo architecture means many teams contribute to a single repository, making ownership difficult to trace.
  • Examples:
    • Receiving PagerDuty alerts at 2 AM with vague stack traces or blank screens.
  • Terminology:
    • Wisdom
    • Healthline
    • monorepo
    • RCA
  • Why it matters: Explains why automated agentic debugging is critical for developer productivity and app stability.

DebugAssist End-to-End Agentic Resolution Journey

  • Explanation: Walks through the four stages of bug resolution: Discovery, Auto-Triage, DebugAssist (Deep RCA), and Resolution.
  • Key claims:
    • Discovery captures crashes and user feedback via internal tools Healthline and Wisdom.
    • Auto-triage identifies severity, customer impact, and routes to the correct JIRA team.
    • DebugAssist performs deep RCA in under 30 minutes by analyzing stack traces, logs, and metadata.
  • Examples:
    • A developer reporting extreme battery usage via Slack gets an auto-generated fix on the same day.
  • Terminology:
    • Discovery
    • Auto-triage
    • Root Cause Analysis
    • JIRA
  • Why it matters: Establishes a standardized, automated workflow from bug report to deployed fix.

Under the Hood: Agent Pipeline & MCP Servers

  • Explanation: Details the LangGraph-based hybrid pipeline combining deterministic nodes and LLM nodes with Model Context Protocol (MCP) servers.
  • Key claims:
    • Pipelines use LangGraph to bypass the planning phase and enforce deterministic steps, reducing LLM hallucination.
    • Deterministic context collection queries Jaeger, distributed tracing, and logging via MCP connections.
    • Sub-agents fan out in parallel to analyze breadcrumbs, crash correlation, and git history.
  • Examples:
    • ClassifyRCA runs on Claude Sonnet with limited turns; fixing runs on Claude Opus with higher max turns.
  • Terminology:
    • LangGraph
    • MCP servers
    • Claude Sonnet
    • Claude Opus
    • PEX binaries
  • Why it matters: Demonstrates how to productionize AI agents reliably at Uber scale without uncontrolled agent loops.

Productionization at Uber Scale & UX Features

  • Explanation: Explains how 8 agent types are packaged into Python PEX binaries, pushed to Artifactory, and run across monorepos with built-in human-in-the-loop UX features.
  • Key claims:
    • All code resides in Python monorepos and is packaged as PEX binaries executed via Docker runtimes.
    • UX features include Diff fixer for incremental adjustments, Ask AI Chat for developer feedback loops, and Open in your Machine.
    • MCP plugin loading is restricted at runtime to prevent context bloat.
  • Examples:
    • Refactoring code or adding unit tests with a single click in the Diff fixer.
  • Terminology:
    • PEX
    • Artifactory
    • Diff fixer
    • Ask AI Chat
    • domain extensions
  • Why it matters: Shows how complex AI systems are reliably deployed, versioned, and interacted with by developers.

Impact & Metrics

  • Explanation: Shares metrics on the impact of DebugAssist on Uber's engineering velocity and issue resolution quality.
  • Key claims:
    • DebugAssist handles ~9,000 RCAs per month.
    • RCA accuracy is 50% compared against exact developer fixes, with 40% in the right direction.
    • JIRA resolution time improved by 2x.
    • PR merge rate for agent-fixed issues increased from 5% to 48%.
  • Examples:
    • Clearing backlogs of out-of-SLA issues and increasing PR merges.
  • Terminology:
    • RCA accuracy
    • PR merge rate
    • mean time to resolve
  • Why it matters: Proves the tangible business and engineering value of AI-powered debugging.

Key Points

Deterministic-AI Hybrid Pipelines

  • Explanation: Combining LangGraph deterministic skeletons with LLM nodes avoids hallucination and keeps token costs and latency under control.
  • Evidence: Pipeline enforces exact steps (Context Collector -> ClassifyRCA -> Fix -> Bazel Test -> Create Diff).
  • Practical implication: Engineers can build reliable agents that do not wander into infinite rabbit holes.

Scale and Productionization

  • Explanation: Agents are packaged as Python PEX binaries stored in Artifactory and executed using Docker image registries.
  • Evidence: 8 agent types running across 5 monorepos handling 9,000 RCAs per month.
  • Practical implication: Allows seamless deployment and execution of AI workloads across massive enterprise infrastructure.

Human-in-the-Loop UX

  • Explanation: Providing tools like Diff fixer, Ask AI chat, and one-click machine deployment ensures developers stay in control while saving hours of manual work.
  • Evidence: PR merge rate increased from 5% to 48% as developers gained interactive feedback loops.
  • Practical implication: Developers are much more likely to adopt and trust AI-generated fixes when they can easily review and tweak them.

Frameworks, Models & Processes

DebugAssist Agent Pipeline

  • How it works: A LangGraph workflow that executes deterministic context collection, AI classification, fixing, validation testing, and diff creation.
  • Components:
    • Context Collector
    • ClassifyRCA
    • Fix
    • Bazel Test (Validation)
    • Create Diff
  • When to use: For automated triage, root cause analysis, and patch generation of software production crashes.

Examples & Case Studies

An Uber developer experienced excessive battery usage due to the Android app running background loops during a ride.

  • Illustrates: End-to-end agentic discovery, auto-triage, deep RCA, and same-day PR creation.
  • Lesson: AI agents can isolate hot-looping code paths and generate fixes before the developer even opens their laptop at the office.

A P1 crash caused by disk full cache write errors during push notifications was caught at 5% rollout.

  • Illustrates: High-severity crash detection and rapid fix deployment.
  • Lesson: Automated debugging prevents widespread customer-impacting outages by catching bad rollouts early.

Actionable Takeaways

  • Immediate:
    • Use deterministic skeletons in agent workflows to restrict LLM wandering.
    • Preprocess large log files before passing them to agents to reduce token costs and noise.
  • Strategic:
    • Provide harness infrastructure while allowing teams to plug in their own domain-specific agent skills.
    • Focus on human-in-the-loop developer UX (diff fixers, chat, local execution) to drive high PR merge rates.
  • Questions to investigate:
    • How to scale domain extensions for thousands of distinct microservice owners?
    • How to further improve RCA accuracy from 50% to near 100%?

Claims Worth Verifying

  • Engineers spend 40% of their time debugging according to Stripe report (statistic)
  • DebugAssist handles 9,000 RCAs per month with 48% PR merge rate (internal metric)

Notable Quotes

"MCP-Powered Crash Investigation: How 11 MCP Servers Help an AI Agent Debug Production Issues at Uber" "DebugAssist is a AI agent for debugging that we built at Uber." "An engineer at Uber takes almost 28 days to resolve an issue on an average."

Compressed Summary

  • DebugAssist is Uber's AI agent harness for debugging production crashes.
  • Combines LangGraph deterministic pipelines with LLM nodes to prevent hallucinations.
  • Utilizes 11 MCP servers for accessing logs, traces, and internal tools.
  • Handles 9,000 RCAs per month with a 48% PR merge rate and 2x faster JIRA resolution.
  • Keywords: debugging, ai agent, langgraph, mcp, uber
  • Core insight: Combining deterministic graph pipelines with specialized AI agents and MCP servers transforms reactive production debugging into automated, same-day resolution at enterprise scale.

Core insights

7
Architecturehigh noveltystrong evidence

DebugAssist bypasses LLM planning entirely: a LangGraph DAG hard-codes the step sequence (Context Collector -> ClassifyRCA -> Fix -> Bazel Test -> Create Diff) and inserts LLM calls only as bounded nodes, deliberately trading agent autonomy for reduced hallucination and controlled token/latency cost.

Why it matters

This inverts the default agentic design assumption that the model should decide the control flow. It suggests production reliability at scale may come from constraining where reasoning is allowed, not from maximizing it.

Generalization

For high-volume, repetitive, verifiable workflows, encode control flow deterministically and reserve LLM inference for the steps that actually require judgment; this bounds failure surface and cost.

Pipelines use LangGraph to bypass the planning phase and enforce deterministic steps, reducing LLM hallucination.
Open source video
Combining LangGraph deterministic skeletons with LLM nodes avoids hallucination and keeps token costs and latency under control.
Open source video
Mechanismmedium noveltymoderate evidence

The harness routes different pipeline stages to different models with different turn budgets: classification uses Claude Sonnet with limited turns while the fix step uses Claude Opus with a higher max-turn allowance, matching reasoning depth and cost to stage difficulty.

Why it matters

Per-stage model and turn-budget assignment is a concrete, tunable knob for balancing cost, latency, and correctness in a multi-step agent pipeline.

Generalization

Treat model choice and max-turn budget as per-node configuration parameters in an agent graph rather than a global setting.

ClassifyRCA runs on Claude Sonnet with limited turns; fixing runs on Claude Opus with higher max turns.
Open source video
Practicehigh noveltystrong evidence

Agents are packaged as Python PEX binaries pushed to Artifactory and executed via Docker runtimes, with 8 agent types running across 5 monorepos — i.e., agents are versioned, immutable deployable artifacts rather than live services with mutable state.

Why it matters

This is a concrete productionization pattern for shipping agent logic through existing binary/deployment infrastructure, solving versioning, reproducibility, and rollout for agent code.

Generalization

Distribute agent harnesses as versioned, self-contained binaries through existing artifact registries so agent behavior is reproducible and rollback-able like any other software.

All code resides in Python monorepos and is packaged as PEX binaries executed via Docker runtimes.
Open source video
8 agent types running across 5 monorepos handling 9,000 RCAs per month.
Open source video
Tradeoffhigh noveltymoderate evidence

MCP plugin loading is deliberately restricted at runtime to prevent context bloat, treating tool/plugin availability as a scarce budgeted resource rather than an open-ended capability surface.

Why it matters

Directly contradicts the common practice of exposing all tools to an agent; it frames tool/plugin registration as a context-window and reliability constraint.

Generalization

Gate tool and plugin availability per-run so that capability breadth does not degrade context quality; unused tools are a tax on reasoning.

MCP plugin loading is restricted at runtime to prevent context bloat.
Open source video
Architecturemedium noveltymoderate evidence

Parallel fan-out sub-agents each own a distinct context source (breadcrumbs, crash correlation, git history) so context collection is decomposed into independent deterministic queries rather than one large prompt.

Why it matters

Shows a decomposition pattern for context assembly in agent harnesses: parallel independent collectors reduce prompt bloat and isolate retrieval failures.

Generalization

Split heterogeneous context retrieval into parallel specialized sub-agents/collectors with narrow scopes instead of stuffing all evidence into a single context window.

Sub-agents fan out in parallel to analyze breadcrumbs, crash correlation, and git history.
Open source video
Deterministic context collection queries Jaeger, distributed tracing, and logging via MCP connections.
Open source video
Empirical Resulthigh noveltystrong evidence

Reported end-to-end impact metrics show the agent's value is not raw RCA accuracy (50% exact match, 40% 'in the right direction') but the interaction loop around it: PR merge rate for agent-fixed issues rose from 5% to 48%, meaning human review and edit tooling, not model correctness, drove adoption.

Why it matters

Reframes the bottleneck: agents producing partially-correct output can still deliver large gains if reviewable and editable, so investment in the human-in-the-loop UX may dominate investment in accuracy.

Generalization

Measure agent value through downstream actionable outcomes (merge rate, resolution time) rather than upstream answer accuracy, and budget for review/edit interfaces accordingly.

PR merge rate for agent-fixed issues increased from 5% to 48%.
Open source video
RCA accuracy is 50% compared against exact developer fixes, with 40% in the right direction.
Open source video
Practicemedium noveltystrong evidence

Human-in-the-loop affordances are concrete artifacts rather than a review gate: a Diff fixer for incremental edits (refactor, add unit tests), Ask AI Chat for feedback loops, and one-click execution on the developer's machine.

Why it matters

Specifies the actual UI/interaction surface needed for engineers to trust and adopt agent output, moving beyond 'human in the loop' as a slogan.

Generalization

Design agent outputs to be incrementally editable and executable in the developer's own environment; editability is what converts suggestions into merged changes.

UX features include Diff fixer for incremental adjustments, Ask AI Chat for developer feedback loops, and Open in your Machine.
Open source video
Refactoring code or adding unit tests with a single click in the Diff fixer.
Open source video

Deep dives

5

Deterministic control flow as a reliability mechanism for production agents

Research question

Does hard-coding the step sequence in a workflow graph (Context Collector -> ClassifyRCA -> Fix -> Bazel Test -> Create Diff) with LLM calls only as bounded nodes reduce hallucination and cost enough to justify the loss of adaptivity on novel bug classes?

Why

This inverts the default agentic assumption that the model should own control flow; if the tradeoff holds, production agent design shifts from 'maximize reasoning' to 'constrain where reasoning is allowed', which changes how harnesses are architected, tested, and cost-modeled.

Pipelines use LangGraph to bypass the planning phase and enforce deterministic steps, reducing LLM hallucination.
Open source video
Combining LangGraph deterministic skeletons with LLM nodes avoids hallucination and keeps token costs and latency under control.
Open source video
Source video

Downstream action metrics vs. upstream answer accuracy as the agent value function

Research question

Is merge rate / resolution time a more faithful measure of agent value than exact-match RCA accuracy, and what portion of the 5%->48% merge-rate gain is attributable to edit/review UX rather than model correctness?

Why

If 50% exact-match accuracy still yields a 5%->48% merge-rate jump, then investment allocation should move from accuracy work toward reviewability, editability, and one-click execution surfaces — a directly falsifiable reallocation of engineering budget.

PR merge rate for agent-fixed issues increased from 5% to 48%.
Open source video
RCA accuracy is 50% compared against exact developer fixes, with 40% in the right direction.
Open source video
UX features include Diff fixer for incremental adjustments, Ask AI Chat for developer feedback loops, and Open in your Machine.
Open source video
Source video

Agents as versioned immutable deployable artifacts

Research question

What reproducibility, rollout, and rollback properties are gained by packaging agent harnesses as PEX binaries pushed to Artifactory and run in Docker, versus deploying agent logic as a long-running service?

Why

It converts agent behavior into a software artifact with a version hash, making fleet-wide consistent rollouts and rollbacks across 5 monorepos tractable — a prerequisite for operating agent fleets at 9,000 RCAs/month without silent behavior drift.

All code resides in Python monorepos and is packaged as PEX binaries executed via Docker runtimes.
Open source video
8 agent types running across 5 monorepos handling 9,000 RCAs per month.
Open source video
Source video

Tool availability as a budgeted context resource

Research question

Does runtime restriction of MCP plugin loading measurably improve context quality, accuracy, or latency relative to exposing the full tool surface, and how does that restriction interact with domain teams' ability to register new tools?

Why

Treating tools as a scarce context budget rather than free capability contradicts standard practice of exposing all tools to an agent, and forces an explicit governance path for extensibility that most harnesses currently lack.

MCP plugin loading is restricted at runtime to prevent context bloat.
Open source video
Source video

Per-node model and turn-budget routing as a tuning surface

Research question

What is the cost/latency/quality frontier of assigning different models and max-turn allowances per graph node (Sonnet with limited turns for classification, Opus with higher max turns for fixing) at 9,000 RCAs/month?

Why

If model choice and turn budget are per-node configuration rather than a global setting, pipeline cost becomes an optimizable allocation problem rather than a fixed expense, with concrete instrumentation requirements.

ClassifyRCA runs on Claude Sonnet with limited turns; fixing runs on Claude Opus with higher max turns.
Open source video
Source video

Article ideas

4

Stop Letting the Model Own the Control Flow

For high-volume, verifiable workflows, production reliability comes from hard-coding the step sequence and admitting LLM inference only at bounded nodes; the planning loop is usually a flexibility tax paid in hallucination, latency, and tokens.

Angle

Contrast a fixed LangGraph DAG against planner-driven agents using the DebugAssist stage sequence as the worked example, and state explicitly which bug classes the deterministic design must give up.

Source video

Your Agent's Accuracy Is Not the Bottleneck

A pipeline with 50% exact-match RCA accuracy drove PR merge rates from 5% to 48%, which means the binding constraint is output editability and execution surface, not model correctness — so budgets should move from accuracy research to review UX.

Angle

Argue the value function should be downstream actionable outcomes (merge rate, resolution time), and show what edit primitives (diff fixer, chat feedback, open-in-your-machine) are needed to convert partial answers into merged changes.

Source video

Tools Are a Context Tax: Budgeting Plugin Availability

Exposing every tool to an agent degrades reasoning; tool availability should be gated per run and treated as a scarce context budget item, with an explicit governance path so teams can still extend the capability surface.

Angle

Frame MCP plugin loading as capacity planning rather than capability maximization, and lay out the extension/governance tension that runtime restriction creates.

Source video

Ship Your Agent Like a Binary, Not Like a Notebook

Agent harnesses should be versioned, immutable artifacts pushed to an existing artifact registry and executed in a container runtime, so agent behavior is reproducible and rollback-able like any other software.

Angle

Walk through PEX + Artifactory + Docker packaging of an 8-agent fleet across 5 monorepos, and argue that mutable live agent services are unrollback-able by design.

Source video

Project ideas

4

Skeleton-vs-Planner Benchmark

beyond-evals

A fixed-graph pipeline will match or beat a planning-based agent on known bug classes while degrading measurably on out-of-distribution incidents, and the crossover point is predictable from the predefined step sequence.

Proof of concept

Port the Context Collector -> ClassifyRCA -> Fix -> Bazel Test -> Create Diff sequence into a fixed graph, add a planner-driven variant, and run both against a replay set of resolved incidents split into in-distribution and novel/ambiguous crash types.

Measurement

Exact-match and 'right direction' RCA rate per bucket, hallucinated-step count, tokens, and wall-clock latency for both configurations.

Source video

Per-Node Cost and Turn-Budget Profiler

gatehouse

Per-node instrumentation will reveal that a small number of graph nodes consume the majority of tokens and latency, and that reallocating model tier and max-turn budget per node improves cost per merged fix without reducing merge rate.

Proof of concept

Wrap each LangGraph node with token, cost, latency, and turn-utilization counters, then sweep model tier and max-turn configurations per node on a fixed incident replay set.

Measurement

Cost per node, latency per node, turn utilization vs. max turns, and cost per merged PR across configurations.

Source video

Merge-Rate Instrumentation Harness

beyond-evals

Downstream action metrics (merge rate, resolution time) will correlate weakly or not at all with upstream RCA exact-match accuracy, meaning accuracy alone is a poor adoption predictor.

Proof of concept

Join agent-run logs to PR outcomes and JIRA resolution timestamps, bucketing runs by RCA accuracy bucket, and test whether accuracy bucket predicts merge outcome.

Measurement

Correlation between accuracy bucket and PR merge rate; PR merge rate and resolution time by bucket; attribution of merge-rate movement to edit-tool usage.

Source video

Context-Budgeted Tool Gate

new

Per-run gating of MCP plugin availability reduces assembled context size and improves reasoning quality or latency versus exposing the full tool surface, without materially reducing task success on known bug classes.

Proof of concept

Implement a runtime gate that loads only the MCP plugins relevant to the inferred incident class, and A/B it against unrestricted plugin loading on a replay set.

Measurement

Context size per run, tool-selection errors, RCA accuracy/Latency deltas, and time-to-onboard a new plugin under the gated policy.

Source video

Architectural implications

3

Control flow authority moved from the LLM planner to a fixed workflow graph.

Before

Agent decides which tools/steps to invoke, potentially exploring unboundedly.

After

Predefined LangGraph skeleton dictates the exact sequence; LLMs act as bounded node functions within it.

Consequence

Hallucination, token cost, and latency become bounded and testable, at the expense of flexibility for novel bug classes.

Source video

Agent code distribution via PEX binaries + Artifactory + Docker.

Before

Agent logic deployed as a long-running service or notebook, hard to version.

After

Each harness version is an immutable artifact pushed to a registry and executed in a container runtime.

Consequence

Agent behavior becomes reproducible and rollback-able like standard software, enabling fleet-wide consistent rollouts across monorepos.

Source video

Context assembly decomposed into parallel specialized collectors/sub-agents.

Before

One large prompt assembled from all relevant sources.

After

Independent parallel sub-agents each query a narrow source (breadcrumbs, crash correlation, git history).

Consequence

Reduces context bloat and isolates retrieval failures, but requires orchestration and aggregation logic.

Source video

Tradeoffs and failure modes

3

Deterministic skeleton vs. adaptive agent

Benefit

Reduces hallucination and keeps token costs and latency under control.

Cost or risk

Bypassing the planning phase may limit the agent's ability to handle novel bug classes or unexpected evidence paths.

Pipelines use LangGraph to bypass the planning phase and enforce deterministic steps, reducing LLM hallucination.
Open source video
Source video

Restricting MCP plugin loading

Benefit

Prevents context bloat at runtime.

Cost or risk

Curtails the capability surface, potentially limiting domain teams' ability to extend the agent with new tools.

MCP plugin loading is restricted at runtime to prevent context bloat.
Open source video
Source video

Partial RCA accuracy in an autonomous pipeline

Benefit

Delivers 9,000 RCAs/month and 2x JIRA resolution improvement despite imperfect answers.

Cost or risk

50% exact-match accuracy means half of generated root causes diverge from the developer's actual fix, risking misleading leads or wrong patches if consumed without review.

RCA accuracy is 50% compared against exact developer fixes, with 40% in the right direction.
Open source video
Source video

Open questions

4

How is 'RCA accuracy' operationalized and measured against exact developer fixes, and what confidence threshold gates autonomous patch generation?

Why unresolved

The summary reports the 50%/40% figures but does not describe the evaluation methodology or whether accuracy gates downstream actions.

Research direction

Define a reproducible evaluation protocol for RCA correctness and correlate accuracy buckets with downstream merge outcomes.

Source video

Does the deterministic skeleton degrade on bug classes outside the predefined step sequence (e.g., novel crash types, cross-team ownership ambiguity)?

Why unresolved

The summary notes monorepo ownership tracing difficulty but does not say how the harness behaves on out-of-distribution bugs.

Research direction

Benchmark fixed-graph pipelines against planning-based agents on novel or ambiguous incidents.

Source video

What is the actual cost/latency structure of per-stage model routing (Sonnet for classification, Opus for fixing) at 9,000 RCAs/month?

Why unresolved

The summary states the model assignments but provides no cost, latency, or turn-utilization data.

Research direction

Instrument per-node token, cost, and latency to find optimal model/turn-budget assignments per stage.

Source video

How does runtime-restricted MCP plugin loading interact with domain teams' ability to extend the agent with new tools?

Why unresolved

The summary states the restriction prevents context bloat but does not describe the extension path or governance.

Research direction

Study dynamic tool-selection/retrieval policies that preserve context quality while allowing extensibility.

Source video

Key claims

8
factualVerification needed

DebugAssist handles approximately 9,000 root cause analyses per month across 8 agent types and 5 monorepos.

Evidence

DebugAssist handles ~9,000 RCAs per month.

Question

Is the 9,000/month figure over what time window and across what set of applications?

Source video
comparativeVerification needed

PR merge rate for agent-fixed issues increased from 5% to 48%.

Evidence

PR merge rate for agent-fixed issues increased from 5% to 48%.

Question

What was the baseline period for the 5% figure and is the 48% rate sustained over time?

Source video
factualVerification needed

RCA accuracy is 50% exact match against developer fixes, with 40% in the right direction.

Evidence

RCA accuracy is 50% compared against exact developer fixes, with 40% in the right direction.

Question

How is 'right direction' judged and who performs the labeling?

Source video
comparativeVerification needed

JIRA resolution time improved by 2x.

Evidence

JIRA resolution time improved by 2x.

Question

Is the 2x improvement attributable to the agent or to concurrent process changes?

Source video
factualVerification needed

Uber engineers take an average of 28 days to resolve an issue and spend 40% of their time debugging production issues.

Evidence

Uber engineers take an average of 28 days to resolve an issue.

Question

Does the 28-day average cover all issue severities and is the 40% time figure self-reported?

Source video
comparativeVerification needed

DebugAssist performs deep RCA in under 30 minutes versus a 28-day average resolution time.

Evidence

DebugAssist performs deep RCA in under 30 minutes by analyzing stack traces, logs, and metadata.

Question

Is the sub-30-minute figure median or best-case, and does it include queueing and context collection?

Source video
causalVerification needed

Bypassing the planning phase and enforcing deterministic steps reduces LLM hallucination in the pipeline.

Evidence

Pipelines use LangGraph to bypass the planning phase and enforce deterministic steps, reducing LLM hallucination.

Question

Was hallucination measured under both planning and non-planning configurations?

Source video
causalVerification needed

Restricting MCP plugin loading at runtime prevents context bloat.

Evidence

MCP plugin loading is restricted at runtime to prevent context bloat.

Question

What metric (context size, accuracy, latency) demonstrated the bloat reduction?

Source video

Connections

5