You.com Rebuilt Finance AI From Scratch by Engineering Disagreement Into It
You.com details how they engineered a multi-agent stock research system that mimics real investment teams, including a PM agent that argues back
Most AI financial research tools work the same way: feed a model some filings, get a summary back. You.com's engineering team decided that approach was fundamentally broken, and published a detailed breakdown of how they rebuilt the entire process from scratch using a team of specialized agents that mirrors how real investment teams actually operate.
The core insight driving the design: in financial markets, the edge is almost never in the headline numbers. It lives in footnotes, in a CEO's shift in tone across earnings calls, in the gap between what management says and what the numbers show. A system that just retrieves relevant text and summarizes it will miss all of that. So they threw out the standard RAG pipeline entirely.
Why RAG Gets Finance Wrong
RAG (Retrieval-Augmented Generation) is the dominant pattern for building document Q&A systems. You chunk documents into pieces, embed them into a vector database, and retrieve the most relevant chunks at query time. It works well for many domains. For financial analysis, it quietly destroys the signals that matter most.
The most valuable information in financial documents is not in the obvious places. It's in footnote disclosures, shifts in management tone across quarters, and gaps between what a CEO says on an earnings call and what the numbers show. Chunking and embedding flattens all of that into undifferentiated text blobs. So instead of retrieval, You.com built a Document Analyzer agent that reads every document at ingestion time, before anything gets stored.
- Financials analyzer: looks for margin trends, pricing power signals, and earnings quality
- Earnings call analyzer: detects hedging language, tracks management tone, and pulls direct quotes
- SEC filing analyzer: surfaces buried disclosures and accounting changes
By the time a document hits the database, it has already been interrogated. The analyst agent later sees both the full source text and the pre-extracted insights, giving it two levels of depth to work from.
Making the Analyst Do Real Math
LLMs are notoriously unreliable at arithmetic. Ask one to compute a DCF model in its head and you'll get a plausible-looking number that may be completely wrong. The analyst agent doesn't do math in its head. It writes code, executes it, and reasons over the results. You.com built four financial modeling tools the agent can call:
- DCF (Discounted Cash Flow): forces the agent to commit to explicit assumptions about revenue growth, margins, and discount rate, then runs the model
- Reverse DCF: works backwards from the current stock price to find the growth rate the market is already pricing in
- Comparables analysis: benchmarks the company against sector peers
- Sensitivity analysis: varies key assumptions across a matrix to stress-test the thesis
The reverse DCF is the most interesting piece. If the market is pricing in 15% revenue growth and the analyst's analysis suggests 20%, that is a specific, testable insight. If the numbers agree, there may be no edge. Without this tool, the agent has no way to distinguish between a genuine insight and something the market already knows.
They also pre-compute derived financial metrics before the LLM ever sees the data. Margins, growth rates, balance sheet ratios, free cash flow. The LLM is explicitly told to use these pre-computed numbers rather than doing arithmetic itself.
The Part Nobody Warned Them About
Here's where the architecture gets genuinely interesting. Once the analyst produces a draft, a Portfolio Manager (PM) agent reviews it and challenges the thesis. The PM argues for different grades on growth, quality, risk, valuation, and momentum, with data-backed reasoning. The analyst then has to respond.
The first version of this loop failed completely. When the analyst received a critique from the PM, it would immediately cave. Every critique was accepted, every grade was softened. The result was a set of reports with no conviction about anything. Every stock looked roughly the same. The system was producing exactly the kind of hedged, say-nothing analysis they'd set out to kill.
The fix required rethinking how the revision loop worked. When the analyst receives a critique, it must explicitly choose to accept, reject, or partially accept each point, with reasoning for each decision. The goal isn't for the analyst to win every argument. It's for the final report to reflect genuine analytical reasoning rather than a series of concessions.
The lesson is worth internalizing: LLMs are agreeable by default. That's useful in most applications. In financial research, it's a fatal flaw. Getting good research out of the system meant engineering disagreement into it on purpose.
The Evaluation Problem
Evaluating this kind of system in finance is uniquely hard. AI models are trained on historical data from the internet, meaning a model already knows how a stock moved over the past ten years even if you don't tell it. Traditional backtesting is meaningless here. You can't test 2023 predictions on 2024 data when the model has already seen the answer.
So they evaluated the same way a real PM would: not by predicting the future, but by assessing the depth of the research. The most important criterion they settled on is market gap identification: each insight must explain not just what the agent found, but what the market is missing. If the agent can't articulate what isn't priced into the stock, the analysis has no value regardless of how polished the report looks.
The Productized Version
The architecture described above is what powers the You.com Finance Research API, which packages this multi-agent research system as a simple API call. The Finance Research API is purpose-built for developers who need accurate, current, and deeply sourced intelligence in their financial workflows, built on the You.com Research API and augmented with licensed structured data from S&P Global and others.
The API returns a JSON object with a markdown answer, inline citation tags, and a sources array mapping every citation back to a URL. It's a single POST to https://api.you.com/v1/finance_research:
import requests
response = requests.post(
"https://api.you.com/v1/finance_research",
headers={"X-API-Key": "YOUR_KEYComments
