Most finance research questions can't be answered from a model's training data: what a company just disclosed, who raised money last week, which rule changed. Those answers live on the open web, scattered across SEC filings, regulator sites, funding announcements, and industry press, and often buried deep inside those sites.

Built-in LLM web search handles the basics (a headline, a company overview, a well-covered funding round), but the evidence finance questions rely on won't always appear in a list of results, and paying per query for shallow passes adds up fast.

Nimble's web search and research tools go deeper into specific domains, rather than treating all use cases the same, to discover and capture deeper and more relevant context for your finance agents.

This post walks through three finance research use cases. For each, we show how a LangChain agent can use two Nimble products to discover and capture relevant web context:

• The Search API (your agent controls the workflow, Nimble retrieves the data) 
• Web Search Agents (you hand Nimble a research objective and it runs the workflow itself). 

You can create a free Nimble account here.

Key takeaways

• Built-in LLM web search often misses the data a finance agent needs to grade, cite, or defend a conclusion.
• Nimble's Search API discovers and retrieves hard-to-reach web data such as rendered pages, filings, and extracted document text, at half the cost of out-of-the-box LLM web search.
• Nimble's Web Search Agents (Agent API) run the full workflow: planning, searching, site navigation, cross-checking, synthesis, schema-shaped output, and confidence scoring.
• The same agent you build can use either product; the choice is about what lands in its context window.

Use Case 1: Regulatory and Filing Intelligence

Financial teams need to monitor regulatory filings, enforcement actions, policy updates, and other official disclosures that could materially affect a company or sector. The challenge is that relevant information is spread across SEC filings, regulator websites, PDFs, press releases, and deeply nested pages that generic search may not surface reliably.

We built a regulatory-intelligence-agent, which is a LangChain agent that:

• Accepts a company, sector, or topic.
• Runs several targeted searches such as SEC filings, enforcement/litigation, investigations, and policy/rule changes as separate passes.
• Reads the primary documents and extracts the material facts or changes.
• Produces a concise brief of what changed and why it may matter, with each item graded for materiality and confidence, with source URLs to the primary document.

Search API: when you want the primary documents and own the sequence

Use the Search API here when you want the document text itself and your agent decides what happens to it. Regulatory monitoring is a sequence: an SEC pass, an enforcement pass, a rules pass, then a call on which results are worth reading in full. That logic stays in your code. Nimble handles discovery, rendering, and extraction.

The request. One broad pass; the agent then narrows with include_domains (["sec.gov"] for filings, ["justice.gov","ftc.gov"] for enforcement, ["federalregister.gov"] for rules):

from nimble_python import Nimble
  
nimble = Nimble()  # reads NIMBLE_API_KEY

resp = nimble.search(    
	query="NVIDIA export controls China antitrust litigation SEC filing 2026",
	search_depth="standard",
  	full_content=True,                       # fetch and extract the page text, not just a snippet    
  	include_domains=["sec.gov", "federalregister.gov", "reuters.com"],
    max_results=6,
)
for r in resp.results:
    print(r.title, r.url, len(r.content or ""))

‍Drop full_content=True for a cheaper, snippet-only pass when the agent is still scanning for which documents are worth reading.

The response (trimmed to one result):

{
  "total_results": 6,
  "results": [
  {
    "title": "www.reuters.com/world/china/us-takes-step-halt-nvidia-ai-chip-shipments-chinese-firms-outside-china-2026-05-31/",
    "url": "https://www.reuters.com/world/china/us-takes-step-halt-nvidia-ai-chip-shipments-chinese-firms-outside-china-2026-05-31/",
    "description": "The unexpected guidance suggests that the United States' best AI chips may have been making their way to the subsidiaries of Chinese AI firms.",
    "content": "May 31 (Reuters): The U.S. Department of Commerce on Sunday moved to close a potential loophole that may have led companies to export the world's most advanced chips, like Nvidia's (NVDA.O) most so..."
  },
...

‍
What the agent now has: the actual 10-Q (nvda-20251026.htm), the Federal Register context for the May 2026 export-control guidance, and China's September 2025 anti-monopoly finding, with the document text in context rather than a link and a sentence. Because full_content=True results are sliced to the query-relevant windows of each document (a 10-Q runs over 150 KB), the agent reads the export-control and litigation sections rather than the cover page, and applies its materiality bar to each.

Agent API: offloading the research workflow to Nimble

Instead of orchestrating each search, hand a Web Search Agent the objective and let it plan, search, navigate, cross-check, and synthesise. Pick it here when you don't need your firm's specific materiality definition (a well-sourced general brief will do), or when you want a fast answer without maintaining the search logic.

The Web Search Agent:

• Scopes how much research the objective needs.
• Decides which regulators, filing types, and sources to investigate (SEC EDGAR, Federal Register, BIS, DOJ/FTC).
• Searches, navigates, and extracts across those sites and documents.
• Distinguishes material developments from routine disclosures.
• Synthesises a structured brief with per-claim citations and confidence.

The request (nimble-python SDK):

import time
from nimble_python import Nimble
  
nimble = Nimble()

run = nimble.agents.run(
  input=(
    "Research recent regulatory and filing developments related to NVIDIA. "
    "Identify material SEC disclosures, regulatory actions, investigations, or "
  	"policy developments that could affect the company. Explain what changed, why "
    "it matters, and cite the underlying evidence."
  ),
  use_case="research",
  effort="high",
)

‍The result: a confidence: high brief from about 15 primary sources across SEC EDGAR, the Federal Register, and contemporaneous reporting, organised by filings, export controls, tariffs, antitrust, and litigation. The value is the assembled picture, not any single document: the full H20 timeline reconstructed from NVIDIA's 8-Ks and the reporting around them, from the April 2025 license requirement through the roughly $4.5B Q1 FY26 charge to the January 2026 conditional H200 approvals, plus four years of In re NVIDIA Corp. Securities Litigation docket history up to its March 2026 class certification. The full run is in the video below.

Run this same objective on a schedule and the Web Search Agent gets better at it: it learns which EDGAR paths, regulator pages, and outlets reliably carry the developments you care about, so later runs reach the same depth with fewer searches and lower cost.

Use Case 2: Investment Due Diligence

A preliminary diligence report pulls together business models, leadership, products, financing, partnerships, competitors, and regulatory exposure. These signals are spread across many sites. The hard part is finding the right evidence, reaching facts buried inside sites, and assembling it into a consistent, defensible output.

We built a company-due-diligence-agent, which is a LangChain agent that:

• Accepts a company name.
• Researches a fixed set of diligence dimensions: business model, products, leadership, funding, partnerships, competitors, regulatory exposure, one focused pass each.
• Extracts a small set of structured facts per dimension and cross-checks funding figures against a second source.
• Produces a scorecard covering strengths, risks, and areas where evidence is insufficient, with a confidence grade per dimension.

Search API: when you own the diligence workflow

Pick the Search API here when the diligence process itself is yours: one focused pass per dimension, a second call to cross-check funding figures, and a rule for what counts as insufficient evidence. Your agent decides which dimensions to research, how hard to push each one, and when a fact is confirmed. Nimble returns the evidence; the workflow that turns it into a scorecard stays in your code.

The request:

from nimble_python import Nimble

nimble = Nimble()
  
resp = nimble.search(
  query="Ramp fintech business model funding valuation investors partnerships competitors 2026",
  search_depth="standard",
  full_content=True,
  include_domains=["ramp.com", "crunchbase.com", "techcrunch.com", "reuters.com"],
  max_results=6,
)

‍The response (trimmed to one result):

{
  "total_results": 6,
  "results": [
    {
      "title": "Ramp raises $750M at $44B valuation as investors hunger for fintechs with an AI story",      
      "url": "https://techcrunch.com/2026/06/04/ramp-raises-750m-at-44b-valuation-as-investors-hunger-for-fintechs-with-an-ai-story/",
      "description": "Ramp is now betting big on AI ...",
      "content": "Corporate expense management platform Ramp on Thursday said it has raised $750 million at a valuation of $44 billion, nearly tripling its valuation within just a year ..."
    },
...

‍
A followup search then issues narrower calls per dimension. It scopes include_domains=["ramp.com"] for products and partnerships, ["crunchbase.com","techcrunch.com"] for funding history, and drops full_content=True to keep costs down.

What the agent now has: a specific recent round to verify (June 2026, $750M, $44B), a prior round for the trajectory ($32B, Lightspeed), and the company's own framing of the business model, each with a source URL. It cross-checks the valuation across the two independent sources before writing it into the funding row, and drops any dimension it can't confirm into insufficient_evidence rather than guessing.

Agent API: when you want the first-look report

Hand Nimble the diligence objective and it breaks the request into research dimensions, browses relevant sources, cross-checks, and returns a structured report with confidence scoring. Pick it for a fast first look on a company you're not yet scoring against a portfolio.

The request:

result_run = nimble.agents.run(
  input=(
    "Conduct preliminary investment due diligence on Ramp. Research its business "
    "model, products, leadership, funding, major partnerships, competitive position, "
	"and key risks. Return a confidence grade per dimension."
  ),
  use_case="research",
  effort="high",
  output_schema=DILIGENCE_SCHEMA,   # optional: get structured JSON back instead of prose
)
# poll runs.get(...).status, then runs.result(...)

‍The result: a seven-section report covering business model, product inventory, a ten-person leadership table, the full funding history to the June 2026 $44B round, partnerships, competitive position, and ten enumerated risks. Every claim carries a bracketed citation to a source index. The run decomposed the objective into about 8 sub-questions and narrowed roughly 80 considered sources to about 16 cited ones. Pass an output_schema, and the same content comes back as structured JSON.

On a recurring diligence workflow, the Web Search Agent learns your preferred sources and the shape of the answer you want, so repeat runs get more granular and more cost-efficient.

Use Case 3: Deal Sourcing and Market Mapping

Investors often need to discover companies matching an investment thesis rather than research a company they already know. Relevant evidence is distributed across company websites, funding announcements, hiring pages, product pages, and industry publications, none of it reachable through a single query.

We built an investment-screening-agent, which is a LangChain agent that:

• Accepts a short investment thesis.
• Broad search. Several discovery searches varying by funding round, product sub-category, customer segment, and geography, to build a candidate set.
• Narrow search. Researches each candidate for headquarters, product focus, target customer, funding, and investors.
• Applies the thesis's inclusion criteria, deduplicates, and returns a ranked shortlist with a fit rationale and evidence per company, plus the near-misses and why they were cut.

Search API: when the qualification logic is yours

Pick the Search API here when dedupe, qualification, and ranking are your logic and you want them applied identically on every run. The Search API returns candidate pages and directory listings; your agent runs the rest. (The Agent API returns the finished ranked dataset with the exclusions attached, which is the same discovery task with less left in your code.)

The request. The broaden phase runs several of these, varying the angle:

from nimble_python import Nimble
  
nimble = Nimble()
  
resp = nimble.search(
  query="US private companies AI software insurance carriers underwriting claims funding investors",    
  search_depth="standard",
  include_domains=["crunchbase.com", "techcrunch.com", "businesswire.com"],
  max_results=8,
)
# narrow phase: per-candidate calls with full_content=True, max_results<=4

‍The response (trimmed to one result):

{
  "total_results": 8,
  "results": [
    {
      "title": "Sector Snapshot: Insurtech Funding Is Way Down, But AI Is Still Driving Some Big Deals",
      "url": "https://news.crunchbase.com/venture/sector-snapshot-insurtech-funding-down-ai-deals/",
      "description": "So far in 2025, global insurance-related startups have pulled in about $3.9 billion ...",
      "content": "For obvious reasons, insurance-related technology isn't exactly one of the sexiest investment areas for VCs ..."
    },
...

‍What the agent now has: named candidates (ZestyAI, Harper) with product focus and funding, a sector directory to expand from, and investor context, each with a source URL. The agent then broadens with more angled queries, researches each candidate with a full_content pass, applies the thesis criteria (US, private, software vendor, not a broker), deduplicates, and ranks. The committed example returns about 19 companies it can positively confirm plus about 28 it excludes with reasons. The deterministic cleanup errs toward dropping anything it can't cleanly verify.

Agent API: when you want the finished dataset

Hand Nimble the discovery objective with a target count and it searches broadly, investigates each company, validates the fit, deduplicates, and returns a structured dataset with evidence and an exclusions list.

The request:

run = nimble.agents.run(
  input=(
    "Find 25 US-based private companies building AI software specifically for "
    "insurance carriers. For each, return headquarters, product focus, target "
  	"customer, funding, major investors, and supporting evidence. Deduplicate and "
    "list near-misses with a reason."
  ),
  use_case="dataset_building",
  effort="high",
  output_schema=SCREENING_SCHEMA,
)

‍The result: the full ranked market map. 25 US private companies, each row with headquarters, product focus, target customer, funding, investors, and per-entry evidence, plus a separate list of firms it deliberately excluded (licensed carriers and MGAs, non-US vendors such as Akur8 and Shift Technology) and a 25-source index. This finished dataset is the visual payoff for the use case.

Re-run the thesis periodically and the Web Search Agent remembers which directories, outlets, and company-page patterns surface real candidates, so the market map refreshes faster and cheaper each time.

Why Nimble Goes Deeper for Financial Research

Specialized retrieval with self-learning research: Generic search treats every query similarly. Nimble specializes retrieval to the use case and the information being sought, identifying better sources and retrieving the deeper context needed to complete the task. Web Search Agents learn the use case across runs, so sources and retrieval paths that consistently produce useful information become more reliable, and recurring financial research tasks get progressively deeper and more complete.

Go beyond search results with intelligent site navigation: Most web-search tools send a query to an algorithm and return the results. Web Search Agents also use search queries, but then dive into high-value sites by clicking through pages to reach data that never appears in search results.

Reliable access to web data: Nimble handles retrieval infrastructure developers would otherwise build themselves: JavaScript rendering, anti-bot and proxy infrastructure, page interaction and site navigation, and search plus full-page extraction.

Full research orchestration: Web Search Agents go beyond retrieval to handle effort scoping, search and extraction orchestration, site navigation, parsing and JavaScript rendering, research synthesis, schema and output rules, and confidence scoring.

How to Get Started with Nimble's Search API and Web Search Agents

We suggest getting started by testing Nimble with your personal AI. Simply give it this link to get started.

To embed it into your AI workflows, choose the best option for you:

• See Nimble's integrations with the AI ecosystem including LangChain, LlamaIndex, liteLLM, and many more.
• Install the SDK for Python, Typescript, Go, or curl.
• Install the Nimble MCP Server.

Before you do any of these things, start a free trial.