Conversational AI Data Agent for Financial Analytics

uber · Finance · 2025 · source Agentic: yes · promotional bias: med · source-backed · extracted with prompt 0.5.6 (schema v2)

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

Problem

Domain: Financial analytics data retrieval

Uber finance teams needed faster, safer access to financial data. Analysts previously searched across Presto, IBM Planning Analytics, Oracle EPM, Google Docs, SQL documentation, and data-science request queues, creating delays and errors for business-critical reporting.

Constraints:

Financial data access must preserve role-based permissions and sensitive-data controls.
Finance users may not know SQL, schemas, or the right system of record.
Natural-language terms like regional aliases and finance abbreviations must map to structured tables and values.
The system must be fast enough to work inside Slack.
Future model changes should not require application rewrites.

Architecture

Uber built Finch, a Slack-integrated financial data agent. It uses Uber's Generative AI Gateway for model access, LangGraph for supervisor/sub-agent orchestration, curated single-table data marts, an OpenSearch metadata and alias index, SQL Writer and other sub-agents, RBAC checks, Slack status callbacks, Google Sheets export, and continuous eval/regression testing.

Diagram confidence: explicit (topology described by the source).

flowchart LR
  slack-user-interface["Slack user interface"] --> langgraph-agent-application["LangGraph agent application"]
  langgraph-agent-application --> supervisor-agent["Supervisor Agent"]
  langgraph-agent-application --> generative-ai-gateway["Generative AI Gateway"]
  supervisor-agent --> sql-writer-agent["SQL Writer Agent"]
  supervisor-agent --> document-reader-agent["Document Reader Agent"]
  sql-writer-agent --> opensearch-metadata-index["OpenSearch metadata index"]
  sql-writer-agent --> curated-financial-data-marts["Curated financial data marts"]
  sql-writer-agent --> rbac-permission-layer["RBAC permission layer"]
  sql-writer-agent --> google-sheets-export["Google Sheets export"]
  google-sheets-export --> slack-user-interface

Drag to pan · scroll or use +/− to zoom · reconstructed from the source's described component topology

Components

Component	Role	Interacts with
`Slack user interface`	Workplace chat surface where finance users ask questions and receive status updates/results.	`LangGraph agent application`
`LangGraph agent application`	Coordinates supervisor and specialized sub-agents and updates Slack during execution.	`Slack user interface`, `Supervisor Agent`, `Generative AI Gateway`
`Supervisor Agent`	Routes user intents to the correct specialized agent.	`LangGraph agent application`, `SQL Writer Agent`, `Document Reader Agent`
`SQL Writer Agent`	Looks up metadata and aliases, constructs SQL, handles errors, validates permissions, and executes queries.	`Supervisor Agent`, `OpenSearch metadata index`, `Curated financial data marts`, `RBAC permission layer`, `Google Sheets export`
`Document Reader Agent`	Handles document-oriented finance retrieval tasks when routed by the supervisor.	`Supervisor Agent`
`OpenSearch metadata index`	Stores SQL table columns, values, and natural-language aliases for fuzzy metadata retrieval.	`SQL Writer Agent`
`Curated financial data marts`	Single-table financial and operational datasets optimized for simple, governed LLM-generated queries.	`SQL Writer Agent`
`RBAC permission layer`	Ensures only authorized users can query sensitive financial data.	`SQL Writer Agent`
`Generative AI Gateway`	Provides Finch access to self-hosted and third-party LLMs and allows model swaps.	`LangGraph agent application`
`Google Sheets export`	Exports large result sets to the user's preferred spreadsheet workflow.	`SQL Writer Agent`, `Slack user interface`

Data flow

A finance user asks a question in Slack. The Supervisor Agent routes the request to the SQL Writer or another sub-agent. The agent retrieves table, column, and value aliases from OpenSearch, builds and validates a SQL query, checks user permissions, executes against the correct financial data source, posts progress updates in Slack, and returns a structured answer and optional Google Sheets export.

“The Supervisor Agent receives the query and sends it to an appropriate sub-agent, such as the SQL Writer Agent. The appropriate agents are selected based on the nature of the query.”article, stated

“The SQL Writer Agent dynamically builds the query using the retrieved metadata and executes it against the appropriate data source.”article, stated

Why this architecture

Finch avoids free-form SQL over arbitrary enterprise data by combining curated data marts, metadata aliases, RBAC, and agent orchestration. The gateway isolates model choice, while Slack integration keeps data retrieval inside the finance team's existing workflow.

“Finch relies on a curated set of single-table data marts that consolidate frequently accessed financial and operational metrics to maximize efficiency and accuracy.”article, stated

“Finch accesses a wide array of self-hosted and third-party large language models via Uber’s Generative AI Gateway. This approach allows us to swap out models easily”article, stated

Models used: Self-hosted large language models via Uber Generative AI Gateway · Third-party large language models via Uber Generative AI Gateway · SQL Writer Agent · Supervisor Agent · Document Reader Agent

Scale

Finch reduces an hours-or-days data-request path to Slack responses within seconds for example queries.
“If the query is too complex or if Taya lacks the right permissions, she must submit a request to the Data Science team. This can mean waiting hours—or even days—for a response.”article, stated
The example Slack query returns a structured response within seconds.
“Within seconds, Finch posts a structured response with a summary and breakdown table.”article, stated
Finch integrates with major internal finance systems including Presto, IBM Planning Analytics, and Oracle EPM.
“Finch is designed to work in harmony with Uber’s broader tech stack. It integrates with internal data platforms (such as Presto, IBM Planning Analytics, and Oracle EPM)”article, stated

Alternatives considered (roads not taken)

Manual cross-platform data lookup

Rejected because: It requires users to search multiple systems and decide which source is current.

“Taya must log into multiple platforms like Presto®, IBM® Planning Analytics, Oracle® Enterprise Performance Management, and Google Docs™, unsure which system holds the most up-to-date figures.”article, stated

Human-written SQL for every query

Rejected because: It is time-consuming, error-prone, and requires schema knowledge.

“this often requires cross-referencing documentation, troubleshooting syntax errors, and ensuring all the necessary columns are included.”article, stated

LLM SQL generation from schemas and sample rows only

Rejected because: Uber improved WHERE clause reliability by adding natural-language aliases for columns and values.

“This is a significant enhancement over traditional methods used by LLM-powered SQL agents that rely solely on table schemas and a few sample rows.”article, stated

Patterns

`multi-agent-orchestration` (orchestration)

LangGraph coordinates a supervisor and specialized sub-agents such as SQL Writer and Document Reader.

“We use LangChain Langgraph™ to construct and orchestrate our agents. It coordinates the flow of queries between specialized agents”article, stated

`rag-retrieval` (retrieval)

Finch retrieves metadata and aliases from OpenSearch to ground SQL generation.

“Finch uses an OpenSearch index to store dataset metadata, including SQL table columns, values, and natural language aliases.”article, stated

`tool-use-orchestration` (orchestration)

The agent executes SQL, checks permissions, updates Slack status, and exports results through tools.

“Throughout the process, a Slack callback handler updates the user’s Slack status with real-time messages describing each operation step, such as when the agent makes tool calls.”article, stated

`human-in-the-loop-gate` (workflow)

Future executive use cases can request SME validation for critical answers.

“we also want to integrate human-in-the-loop validation upon request for our leaders.”article, stated

Tradeoffs

Use curated single-table data marts

Chose simpler governed marts over arbitrary complex enterprise schemas.

Rationale: Simpler datasets reduce query complexity and improve LLM query repair.

“They’re structured to minimize query complexity and retrieval time, making it easier for the LLM to write a query and quickly get feedback, like error messages”article, stated

Embed Finch in Slack

Chose workflow-native conversational access over forcing users into separate BI/query tools.

Rationale: Finance users can ask questions where they already collaborate.

“Finch is designed to integrate seamlessly into Slack, where Uber’s finance teams already collaborate.”article, stated

Use a model gateway

Chose swappable model access over hard-coding a model provider into Finch.

Rationale: The gateway lets Uber swap models as AI technology advances.

“This approach allows us to swap out models easily as the underlying AI technology advances.”article, stated

Gotchas (what bit them)

Financial term aliases can break SQL filter accuracy.

Root cause: Internal terms like region abbreviations and values may not match table schemas directly.

Resolution: Store column and value aliases in OpenSearch for fuzzy metadata lookup.

“Finch dramatically improves the accuracy of WHERE clause filters by storing natural language aliases for both SQL table columns and their values in our OpenSearch™ index.”article, stated

Supervisor routing can collide when tools look similar.

Root cause: Different data retrieval tools may serve similar-seeming use cases.

Resolution: Evaluate supervisor routing accuracy separately from sub-agent accuracy.

“Supervisor agent routing accuracy. This identifies issues with intent collisions, where the supervisor makes the wrong choice when the question is ambiguous or tools have similar capabilities”article, stated

Finch is not reliable enough for every executive-critical answer without validation.

Root cause: Generative AI can hallucinate, even when good enough for day-to-day finance operations.

Resolution: Add on-demand human validation for leaders and critical questions.

“like all generative AI technologies at this point, it’s not 100% reliable and is prone to hallucination.”article, stated

Evaluation

Finch uses sub-agent accuracy evaluation, supervisor routing evaluation, end-to-end simulated queries, regression tests on historical queries, and performance optimization.

Metrics: Generated-query result match against golden query · Supervisor routing accuracy · End-to-end reliability · Regression drift · Latency · Database load

“Each sub-agent (SQL Writer, Document Reader) is independently evaluated against a set of expected responses.”article, stated

“Historical queries are re-run to detect accuracy drifts before updates are deployed for system prompts or model changes.”article, stated

Outcomes

Finch gives finance users natural-language access to financial data inside Slack.
Example requests return structured responses within seconds.
The system reduces dependence on manual SQL and data-science request queues.
Future roadmap includes more agents, toolkits, and on-demand human validation.

The article does not give broad usage counts; it emphasizes response latency improvement from hours or days to seconds for the illustrated workflow.

“Finch revolutionizes how Uber’s finance teams access data through conversational retrieval, leading to less friction, fewer delays, and faster data-driven decisions.”article, stated