You.com Finance Research API Outperforms Anthropic’s Fable on FinSearchComp T3

‍TLDR: A principal engineer working on agentic AI platforms ran an independent study on a simple question: with the reasoning model held constant, how much accuracy is left on the table in the way a problem is decomposed, executed, and recomposed?

‍He tested it on the public FinSearchComp T3 Global benchmark, the hardest tier, using the You.com Finance Research API. The API alone scored 58%, above every general-purpose frontier model he tested and above the human expert baseline of 51%. Second, a thin orchestration layer on top of it reached 64.3% with zero regressions. The gains came from separating retrieval from computation. 

The takeaway for anyone building agents: the accuracy frontier is moving from the base model to the layer that coordinates it.

The Bigger-Model Reflex Is Running Out of Road

The default move when an AI system underperforms is to reach for a larger model. On hard, multi-step financial questions, that reflex is starting to miss. Navid Mehrdad, a principal engineer focused on agentic AI platforms and multi-agent orchestration, spent several weeks testing a different lever. He kept the reasoning model fixed and asked whether accuracy could improve purely from better decomposition, execution, and recomposition—the architecture around the model rather than the model itself.

He published the code, results, and methodology as part of an independent study. His findings run counter to the industry's dominant assumption that scale is the answer to reasoning failures. 

The Benchmark: FinSearchComp T3 Global

FinSearchComp T3 Global is the "Complex Historical Investigation" tier in a public financial search benchmark. There are 84 questions that demand multi-step reasoning across multiple sources and long-horizon historical analysis. A representative question asks a model to identify S&P 500 constituents with market caps above the median that also rank among the top five decliners over a specific 2022 window, with explicit rules for handling multiple share classes. 

The model parses the question, retrieves the right values over a time range, performs the arithmetic, handles edge cases, and only then answers.

Mehrdad selected the comparison set for his independent study: the general-purpose frontier models he had access to, run with their own native web search, plus the published human expert baseline. 

His study shows the You.com Finance Research API ahead of Fable, Grok, and other Leading LLMs:

The Finance Research API sat at 58%, ahead of every general-purpose model in the set and ahead of the human expert baseline. The strongest general models clustered in the high-40s to low-50s. His conclusion: a strong model armed with generic web search topped out roughly 20 points lower, and larger models did not reliably do better. The separation came from licensed financial data and orchestration.

Note: This study measures the harder T3 Global set. The Finance Research API's published in-house benchmark is 87.29% on FinSearchComp T2, a different and less complex tier. The 58% and 64.3% figures above are Mehrdad's independent T3 results, not the T2 number.

The Important Distinction

Mehrdad went looking for the failures, expecting data gaps. Instead, he found the opposite. On the T3 misses, the API almost always retrieved the correct numbers—the composition on top of those numbers is what broke. The classic example being a system that fetches four correct values across four fiscal years and then trips on a fiscal-versus-calendar-period edge. The retrieval is correct, but the arithmetic over it is wrong.

A retrieval problem and a composition problem call for different fixes. If the data is already landing, throwing a bigger model at the arithmetic is expensive and beside the point. Separate the two, and you can attack the failure class that's actually costing you the correct answers.

The Layers: Decompose, Retrieve, Recompute, Arbitrate

The architecture Mehrdad built is intentionally thin, comprised of only four steps and no model swapping.

1. Decompose. Generate an ensemble of independent plans and join them for coverage, rather than betting the answer on a single decomposition path.
2. Retrieve. Resolve each lookup precisely through the same Finance Research API deep calls, one primitive at a time.
3. Recompute. Rebuild the answer explicitly from an itemized evidence ledger, so the arithmetic runs on named values rather than a fuzzy synthesis.
4. Arbitrate. Run an independent verification pass before committing to a final answer.

The architecture restructures how work flows through the API, pulling computation out of the retrieval step so that arbitration catches a fiscal-period edge case before it approaches an answer.

Below is a concrete composition failure and the fix. A single call can retrieve four correct values across four fiscal years and still trip when it treats a fiscal-year end as a calendar-year end. The recompute step rebuilds the answer from a named evidence ledger, so the period logic is explicit rather than implied.

# Retrieve step: each value is pinned to its reporting period, not a raw year
ledger = [
    api.deep(metric="operating_income", ticker="ACME", fiscal_year=fy)
    for fy in (2019, 2020, 2021, 2022)
]

# Recompute step: arithmetic runs on named, period-aligned values
def recompute(ledger):
    for item in ledger:
        # fiscal-year fix: align to the reporting period, don't assume calendar year
        item.period_end = fiscal_year_end(item.ticker, item.fiscal_year)
    return sum(item.value for item in ledger) / len(ledger)

# Arbitrate: only override the direct answer if the recompute wins the verifier panel
answer = arbitrate(direct=api.deep(question),
                    recomputed=recompute(ledger))

Recomputation catches the fiscal-versus-calendar edge before it reaches the output.

The above is a simplification of Mehrdad’s open-source harness. Full implementation at github.com/nvdm59/coordination-intelligence.

The Results: 64.3% With Zero Regressions

On all 84 T3 Global questions, the You.com Finance Research API scored:

• Published baseline: 49/84 (58.3%)
• Orchestrated system: 54/84 (64.3%)

Five recovered answers, and critically, zero regressions. The layer never broke an answer that the API already had right. The recovered failures clustered exactly where decomposition was supposed to help: compositional reasoning, multi-period arithmetic, and precision calculations.

The latency-accuracy tradeoff here is reasonable. Median latency rose from 139 to 167 seconds per call. The answers that remained broken were mostly due to a scope problem—screening or ranking across very large universes, such as finding extrema over hundreds of securities. Those failures are systems problems—not prompt problems—related to wiring reasoning into structured retrieval over specialized data systems.

Why Coordination Intelligence Is the Next Frontier

As base models keep improving, the marginal accuracy gain is shifting away from the model and onto that coordination layer, which tool to call, when to verify, and how to recompose primitives into an answer. 

For teams building financial or, frankly, any agents, the practical reading is direct. If your grounding layer already retrieves the right data, your next gain in accuracy comes from structure: decomposition, an explicit evidence ledger, and a verification step that catches the arithmetic before it ships. A robust research API provides the primitives. The coordination on top is where the remaining points live, and it's a product surface worth engineering deliberately.

Built for Enterprise Trust

Accuracy only matters if you can put it into production. When ZeroDataRetention (ZDR) is enabled, You.com limits retention of customer data — queries and customer data are only processed in transit. For teams handling sensitive financial workloads, that means the licensed-data accuracy above comes without the data-handling tradeoffs that usually keep an API out of regulated environments.

Read the Study

Navid Mehrdad published the full write-up, "Beyond Language Models: Why Coordination Can Be the Next Frontier in AI Systems" (July 2, 2026), on his Substack, with code and methodology on GitHub. Read it in his own words at substack.com/@navidmehrdad, and review the harness and results at github.com/nvdm59/coordination-intelligence.

Want to test the retrieval layer his study was built on? Try the Finance Research API playground and see where your own agents slip between retrieval and composition.