- [How to build an AI research agent that actually works](https://parallel.ai/articles/how-to-build-an-ai-research-agent-that-actually-works)
Tags:Guides
October 29, 2026
# AI due diligence: how to build an automated research pipeline
AI due diligence uses agents to search public sources, pull out structured facts, and return a cited report an analyst can verify, so a deal team reviews every source in scope instead of a sample. This guide covers the four-layer pipeline, the sources each layer needs, working code, how to evaluate the web research layer, and what makes the output audit-ready.
Tags:Guides
**Key takeaways**
- - AI due diligence replaces manual, multi-source research with structured pipelines that query web data, extract insights, and produce cited outputs.
- - The pipeline architecture has four layers: data ingestion, extraction and enrichment, analysis and synthesis, and output with verification.
- - You name every data source your pipeline consumes (SEC EDGAR, Crunchbase, PACER, USPTO) and query them programmatically.
- - Citation-backed outputs with confidence scores make automated due diligence audit-ready, which manual research cannot guarantee at scale.
- - A working pipeline can reduce deal-level research from weeks to hours while increasing source coverage from partial sampling to comprehensive review.
AI due diligence exists because diligence has a scale problem: the number of targets, vendors, and counterparties that organizations need to evaluate keeps growing, but the analyst bench stays flat, so coverage quality slips.
An AI due diligence pipeline takes over the retrieval work. You issue API calls that retrieve results from a web search API[web search API], extract structured data from raw content, cross-reference findings, and return a cited, confidence-scored research report.
## Manual due diligence breaks under pressure
A target lands, the clock starts, and you open 10 browser tabs. SEC EDGAR for filings. PACER for litigation. Crunchbase or PitchBook for funding history. Patent databases for IP. News archives for anything that's gone wrong.
A thorough analyst can manage this for a single target, but not across a whole deal pipeline.
The first failure mode is sampling. Under deadline pressure, analysts cover 40 to 60 percent of available information. An automated due diligence pipeline queries all sources in scope without sampling.
The second failure mode is inconsistency. Two analysts covering the same target type apply different standards, weight sources differently, and produce outputs that don't compare. Automated DD enforces a consistent schema across runs. If financial health, leadership risk, and litigation exposure are in scope for deal A, they stay in scope for deals B through Z.
The third failure mode is cost. Senior analysts and outside counsel bill between $300 and $800 per hour, and a large portion of that time goes to information retrieval. McKinsey research[McKinsey research] shows AI-assisted due diligence cycles complete 30 to 50 percent faster than manual equivalents. A pipeline can take the retrieval and leave analysts the judgment calls.
The fourth failure mode is scale. As deal flow increases, you can't hire fast enough to keep research quality constant. A pipeline scales horizontally and applies the same rigor to one vendor assessment or a thousand.
## How an AI due diligence pipeline works
A due diligence research pipeline accepts a research target and produces a structured, cited intelligence report without manual intervention between input and output.
**Layer 1: Data ingestion.** You query authoritative public sources across financial, legal, news, people, and regulatory categories. This layer covers everything from SEC EDGAR filings to USPTO patent records. You issue API calls that return ranked, relevant results from a web-scale index.
**Layer 2: Extraction and enrichment.** Raw search results are URLs, not data. This layer converts those pages into structured JSON. A Crunchbase company profile becomes fields: funding total, last round date, lead investors, headcount range, founding year. An SEC 10-K filing becomes a set of extracted financial metrics. The Extract API pulls clean page content; you define the schema, and the Task API returns data against it.
**Layer 3: Analysis and synthesis.** Individual data points don't constitute due diligence. This layer cross-references extracted data across all sources, detects contradictions, and identifies red flags. AI agents[AI agents] handle this using the _Basis framework_, which produces paragraph-level citations, rationale chains, and calibrated confidence scores alongside the output.
**Layer 4: Output and verification.** The pipeline returns a structured report where you can trace each claim to a specific source URL, with a confidence rating attached. Analysts review flagged areas, not every finding. High-confidence findings need little human time. Thin or contradictory evidence escalates for review.
You own the pipeline: you define the schemas, the source coverage, and the output structure. Parallel's Search, Extract, Task, Responses, FindAll, and Monitor APIs map to these four layers. You extend each layer independently as requirements change.
## Layer 1: ingesting data from the right sources
The value of due diligence automation depends on source coverage. A pipeline that misses PACER has no visibility into federal litigation. A pipeline that skips USPTO patent records can't assess IP exposure. Specify your source categories before you write a line of code.
Most DD use cases need five categories of source.
**Financial sources:** SEC EDGAR[SEC EDGAR] for public company filings (10-K, 10-Q, 8-K, proxy statements), Crunchbase[Crunchbase] and PitchBook for startup funding history and investor records, and annual report archives for private company financials where available.
**Legal sources:** PACER[PACER] for federal court records covering civil litigation, bankruptcy, and criminal cases. State court databases for state-level proceedings. USPTO[USPTO] for patent filings, grants, and inter partes reviews. Google Patents for broader patent landscape mapping.
**News and media:** TechCrunch, Reuters, Bloomberg, and industry-specific publications indexed across the public web. A leadership change or regulatory action from six weeks ago outweighs a three-year-old feature story.
**People and organizational data:** Company websites and press releases for official announcements. Job posting patterns can reveal product direction and financial health.
**Regulatory sources:** FDA databases for life sciences and medical device companies. EPA records for environmental exposure. State licensing boards for financial services, healthcare, and professional services firms.
A single Search API[Search API] call retrieves relevant results from across all public web sources, ranked by relevance. The query takes under three seconds.
12345678910111213141516171819import requests
response = requests.post(
"https://api.parallel.ai/v1/search",
headers={"x-api-key": "YOUR_API_KEY"},
json={
"mode": "advanced",
"objective": "Assess Acme Corp's recent funding history, executive leadership changes, and active litigation",
"search_queries": [
"Acme Corp funding rounds 2025 2026",
"Acme Corp SEC filings EDGAR",
"Acme Corp lawsuit litigation PACER"
]
}
)
results = response.json()
for r in results["results"]:
print(r["url"], r["excerpts"][0])``` import requests response = requests.post( "https://api.parallel.ai/v1/search", headers={"x-api-key": "YOUR_API_KEY"}, json={ "mode": "advanced", "objective": "Assess Acme Corp's recent funding history, executive leadership changes, and active litigation", "search_queries": [ "Acme Corp funding rounds 2025 2026", "Acme Corp SEC filings EDGAR", "Acme Corp lawsuit litigation PACER" ] }) results = response.json()for r in results["results"]: print(r["url"], r["excerpts"][0])``` This call returns ranked URLs with compressed, query-relevant excerpts across all three research dimensions. Feed the results into Layer 2 for extraction.
For ongoing DD, such as monitoring a portfolio company after close, Parallel's Monitor API runs the same query on a daily or weekly schedule and sends a webhook when new relevant content appears.
## Layer 2: extracting structured data from unstructured sources
DD sources don't arrive in tidy formats. A Crunchbase company page is dynamic JavaScript. An SEC 10-K filing is a long HTML document with Inline XBRL tags embedded in its financial statements. A law firm profile is an HTML page with no consistent schema. Parsing each by hand means building and maintaining custom scrapers for every source type.
The Extract API handles this without custom parsers. Declare what you need in plain language. The API renders JavaScript and parses PDFs, then returns the relevant content as clean markdown excerpts. Pass that content to the Task API when you need structured JSON against your schema.
Define the extraction schema based on what your DD framework requires. For a financial health assessment of a SaaS vendor, you might pull funding total, last round date, lead investors, annual recurring revenue (ARR) signals, headcount, and founding year from the Crunchbase profile. This follows the same automated data enrichment[automated data enrichment] pattern used in sales and account qualification workflows.
123456789101112response = requests.post(
"https://api.parallel.ai/v1/extract",
headers={"x-api-key": "YOUR_API_KEY"},
json={
"urls": ["https://www.crunchbase.com/organization/acme-corp"],
"objective": "Extract funding history, key investors, headcount, and founding year"
}
)
excerpts = response.json()["results"][0]["excerpts"]
# For schema-conformant structured output with citations, pass these
# excerpts to the Task API``` response = requests.post( "https://api.parallel.ai/v1/extract", headers={"x-api-key": "YOUR_API_KEY"}, json={ "urls": ["https://www.crunchbase.com/organization/acme-corp"], "objective": "Extract funding history, key investors, headcount, and founding year" }) excerpts = response.json()["results"][0]["excerpts"]# For schema-conformant structured output with citations, pass these# excerpts to the Task API``` Run the same pattern against the company's own website, G2 or Trustpilot review pages, and any news articles the Search layer returned. Each call returns a JSON object you can merge into a unified company record before passing it to Layer 3.
The Extract API maintains the connection between extracted data and source URLs. Every field you extract traces back to the page it came from.
## Layer 3: synthesizing research with AI agents
Extraction gives you data points, and due diligence requires conclusions. Layer 3 crosses the gap between "you have a lot of data about this company" and "here's your assessment of its financial health, legal exposure, competitive position, and leadership risk."
A generic large language model (LLM) call fails here because, without grounding in real-time web data, LLMs hallucinate company details, cite outdated funding rounds, and can't verify claims against primary sources. A Task API[Task API] call grounds every output in live web data retrieved during the run.
The Task API accepts a research objective and an optional output schema, then executes a multi-step research process. It searches for relevant information, extracts and cross-references findings, detects contradictions, and produces a structured output with the _Basis framework_ attached. Every paragraph in the output includes citations, a rationale chain, and a calibrated confidence score.
For multi-dimensional DD, structure the Task around the specific dimensions your framework covers. Financial health, competitive positioning, legal and regulatory risk, leadership assessment, and technical maturity all benefit from dedicated research objectives and source priorities.
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253import time
# Create the Task Run
task_response = requests.post(
"https://api.parallel.ai/v1/tasks/runs",
headers={"x-api-key": "YOUR_API_KEY"},
json={
"processor": "pro",
"input": (
"Assess Acme Corp (https://www.crunchbase.com/organization/acme-corp) "
"across four DD dimensions: financial health "
"(funding runway, revenue signals, burn indicators), competitive position "
"(market share, differentiation, key competitors), legal and regulatory risk "
"(active litigation from PACER, regulatory actions, IP disputes from USPTO), "
"and leadership stability. "
"Cross-reference Crunchbase funding data, patent filings, "
"and recent news coverage. Flag contradictions and low-confidence areas."
),
"task_spec": {
"output_schema": {
"type": "json",
"json_schema": {
"type": "object",
"properties": {
"financial_health_summary": {"type": "string"},
"competitive_position": {"type": "string"},
"litigation_risk": {"type": "string"},
"leadership_stability": {"type": "string"},
"red_flags": {"type": "array", "items": {"type": "string"}},
"overall_confidence": {"type": "number"}
}
}
}
}
}
)
run_id = task_response.json()["run_id"]
# Poll for completion
while True:
status = requests.get(
f"https://api.parallel.ai/v1/tasks/runs/{run_id}",
headers={"x-api-key": "YOUR_API_KEY"}
).json()
if status["status"] == "completed":
result = requests.get(
f"https://api.parallel.ai/v1/tasks/runs/{run_id}/result",
headers={"x-api-key": "YOUR_API_KEY"}
).json()
print(result["output"]["content"])
break
time.sleep(10)``` import time # Create the Task Runtask_response = requests.post( "https://api.parallel.ai/v1/tasks/runs", headers={"x-api-key": "YOUR_API_KEY"}, json={ "processor": "pro", "input": ( "Assess Acme Corp (https://www.crunchbase.com/organization/acme-corp) " "across four DD dimensions: financial health " "(funding runway, revenue signals, burn indicators), competitive position " "(market share, differentiation, key competitors), legal and regulatory risk " "(active litigation from PACER, regulatory actions, IP disputes from USPTO), " "and leadership stability. " "Cross-reference Crunchbase funding data, patent filings, " "and recent news coverage. Flag contradictions and low-confidence areas." ), "task_spec": { "output_schema": { "type": "json", "json_schema": { "type": "object", "properties": { "financial_health_summary": {"type": "string"}, "competitive_position": {"type": "string"}, "litigation_risk": {"type": "string"}, "leadership_stability": {"type": "string"}, "red_flags": {"type": "array", "items": {"type": "string"}}, "overall_confidence": {"type": "number"} } } } } }) run_id = task_response.json()["run_id"] # Poll for completionwhile True: status = requests.get( f"https://api.parallel.ai/v1/tasks/runs/{run_id}", headers={"x-api-key": "YOUR_API_KEY"} ).json() if status["status"] == "completed": result = requests.get( f"https://api.parallel.ai/v1/tasks/runs/{run_id}/result", headers={"x-api-key": "YOUR_API_KEY"} ).json() print(result["output"]["content"]) break time.sleep(10)``` The `pro` processor handles exploratory research across up to 20 output fields, with latency in the 2 to 10 minute range. The `core` processor covers 10 fields in 1 to 5 minutes for standard enrichments. For deep research across complex corporate structures, `ultra` or `ultra2x` processors handle multi-source synthesis over longer timeframes.
With the Basis framework output attached to each field, every finding has a source, a reason, and a confidence level, so analysts reviewing the output check uncertainty flags instead of raw data.
## Layer 4: verifiable outputs that stand up to scrutiny
DD outputs inform decisions worth millions. An assertion that a target company has no material litigation is useful only if someone can verify it. "The AI found nothing" doesn't meet the standard for a legal team or an investment committee.
In the _Basis framework_[_Basis framework_], every atomic claim in a Task output links to a specific source URL. A rationale chain shows the reasoning path from source to conclusion. A confidence score, calibrated against the volume and consistency of evidence, rates the pipeline's certainty on a per-claim basis.
Manual research leaves behind whatever notes an analyst chose to record. A Basis-backed output records, for each field, the sources cited, the supporting excerpts, the reasoning, and a confidence rating. An auditor can trace how the pipeline reached each conclusion.
Confidence ratings drive the human-in-the-loop design. Basis rates each field low, medium, or high, so route anything below high confidence to analyst review. The pipeline handles high-confidence findings. Analysts focus on areas where evidence is thin, contradictory, or absent.
Parallel operates under SOC 2 Type 2[SOC 2 Type 2] certification and offers zero data retention on Enterprise plans. With it enabled, no research data persists after the pipeline returns its output. That matters for M&A, vendor assessment, and regulatory compliance work, where data handling faces its own scrutiny.
You define the output format. Export structured JSON to your existing DD workflow tools. Generate a markdown report for stakeholder review. Feed confidence-flagged items into a ticketing system for analyst follow-up.
## Putting it together: a working pipeline in practice
Say your procurement team needs to evaluate a new SaaS vendor before signing a $500,000 annual contract. Manual vendor due diligence for a contract at this value typically takes two to five days across a senior analyst and a legal reviewer.
**Step 1: Search.** A Search API call queries for the vendor's financial health signals, leadership stability, customer reviews, known security incidents, and any regulatory actions. The call takes under three seconds and returns ranked URLs across news sources, review platforms, regulatory databases, and the vendor's own published content.
**Step 2: Extract.** Extract API calls pull structured data from the vendor's Crunchbase profile (funding, investors, headcount), their G2 page (review scores, volume, recent sentiment), their website's security and compliance pages (SOC 2 status, certifications), and any news articles flagged in Step 1.
**Step 3: Synthesize.** A Task API call receives the company name, the structured data from Step 2, and a research objective covering financial viability, security posture, customer satisfaction risk, leadership tenure, and litigation or regulatory exposure. The `core` or `pro` processor cross-references all sources, produces a structured risk assessment for each dimension, and attaches Basis-framework citations and confidence scores.
**Step 4: Verify.** You review the output. Any finding below the confidence threshold (such as a litigation record where PACER returned limited results) routes to an analyst for targeted follow-up. High-confidence findings with citations need no additional verification.
The Opendoor team applied this pattern[Opendoor team applied this pattern] to HOA (homeowners association) research, a task that previously required 10 minutes of manual lookup per property. The automated pipeline reduced that to a 2-minute verification step.
Banks run the same pattern for enhanced due diligence. Bretton[Bretton] (formerly Greenlite AI) builds agents for bank back offices that handle KYC and KYB[KYC and KYB] onboarding, enhanced due diligence, screening alerts, and adverse media. About 70% of each investigation runs on web data, all sourced through Parallel. With Parallel's Responses API inside each investigator, Bretton cut end-to-end investigation time from about 20 minutes to about 12, and across customers such as MVB Bank and Mercury it has cut compliance review time by as much as 87%.
For the $500,000 vendor contract, the pipeline runs in minutes and an analyst reviews the flagged items and signs off. You make the decision with broader source coverage than a manual process provides and a complete audit trail.
## How to evaluate the web research layer for due diligence
Every layer above depends on what the search step finds. If it misses a register entry, a subsidiary, or a closed acquisition, extraction and synthesis can't recover the fact, and the report reads as confident while being incomplete. Test search APIs on diligence-shaped questions with known answers before you pick one, and hold the agent and model fixed so the search layer is the only variable.
Two finance benchmarks fit this job. FinSearchComp[FinSearchComp] (arXiv 2509.13160[arXiv 2509.13160]) has 635 questions written by 70 financial experts, and its T3 tier (Complex Historical Investigation) asks the multi-step questions that look most like diligence work. PWS-Finance is Parallel's private set of 174 held-out questions across eight finance workflows, including deals, ownership and leadership, and regulation and compliance. An answer counts only if every required fact is right.
We make Parallel and ran these evaluations; methodology is on /benchmarks[/benchmarks]. Every search API ran in the same agent loop with the same questions and judge, and cost is end to end per 1,000 questions at list price.
| Search API | FinSearchComp T3 accuracy | T3 cost per 1,000 questions | PWS-Finance accuracy |
|---|---|---|---|
| Parallel Advanced | 57.4% | $161.10 | 84.3% |
| Parallel Fast | 53.7% | $15.20 | 83.0% |
| Exa Auto | 51.4% | $226.20 | 75.9% |
| Perplexity (Finance + Web on T3, Search API on PWS) | 50.0% | $347.00 | 74.3% |
| OpenAI native search | 48.3% | $204.30 | 83.7% |
| Tavily | 43.0% | $481.80 | Not comparable (see /benchmarks) |
On T3, Parallel Advanced was the most accurate search API, 6.0 points ahead of Exa and 9.1 ahead of OpenAI's native search, at 1.3x to 3x lower cost than every competitor. Parallel Fast scored 53.7%, still ahead of every competitor, at 13x to 32x lower cost. On PWS-Finance, Parallel Advanced posted the top score, 8 to 10 points ahead of Exa and Perplexity. Its 0.6-point lead over OpenAI's native search is small, so treat those two as close on accuracy; Parallel costs 30% less.
FinSearchComp T3PWS-Finance
Correct answers per $
Parallel Fast35.3/$ | 53.7% / 15.2CPM
Parallel Advanced3.6/$ | 57.4% / 161.1CPM
OpenAI native search2.4/$ | 48.3% / 204.3CPM
Exa Auto2.3/$ | 51.4% / 226.2CPM
Perplexity Finance + Web1.4/$ | 50% / 347CPM
Tavily0.9/$ | 43% / 481.8CPM
COST (CPM)
ACCURACY (%)
Loading chart...
CPM: USD per 1,000 questions, end to end (answer-model tokens plus search and fetch calls at list price).
Parallel
Others
Benchmark comparison across Cost (CPM) and Accuracy (%). CPM: USD per 1,000 questions, end to end (answer-model tokens plus search and fetch calls at list price).
+Methodology
**Dataset**
FinSearchComp[FinSearchComp] has 635 questions, written by 70 financial experts, that reproduce analyst work across global and Greater China markets. T3 is the complex historical investigation tier, the hardest in the benchmark; results are reported on the 172 graded questions.
**Evaluation methodology**
Multi-step agentic evaluation: every search API runs in the same agent loop with the same questions and the same LLM judge, so the search layer is the only variable. The agent calls the provider's search tool plus its fetch tool where one exists. Parallel Advanced, Exa Auto, OpenAI native search, Perplexity and Tavily answer with GPT-6 Sol (reasoning: high); Parallel Fast runs as the low-latency stack with GPT-6 Luna (reasoning: high). Scores are the mean of three runs unless noted. The benchmark's answers are published online. For the other search APIs, our harness drops those copies before the model sees them. OpenAI native search answers that came from published copies count as wrong (OpenAI native search scores 64.0 before that adjustment). Tavily is a single run.
Cost is end-to-end per answer at list price: the answer model's tokens plus every search and fetch the agent makes, shown per 1,000 questions.
**Testing dates**
Evals were run on October 22, 2026 (Tavily on October 28, 2026).
**Dataset**
FinSearchComp[FinSearchComp] has 635 questions, written by 70 financial experts, that reproduce analyst work across global and Greater China markets. T3 is the complex historical investigation tier, the hardest in the benchmark; results are reported on the 172 graded questions.
**Evaluation methodology**
Multi-step agentic evaluation: every search API runs in the same agent loop with the same questions and the same LLM judge, so the search layer is the only variable. The agent calls the provider's search tool plus its fetch tool where one exists. Parallel Advanced, Exa Auto, OpenAI native search, Perplexity and Tavily answer with GPT-6 Sol (reasoning: high); Parallel Fast runs as the low-latency stack with GPT-6 Luna (reasoning: high). Scores are the mean of three runs unless noted. The benchmark's answers are published online. For the other search APIs, our harness drops those copies before the model sees them. OpenAI native search answers that came from published copies count as wrong (OpenAI native search scores 64.0 before that adjustment). Tavily is a single run.
Cost is end-to-end per answer at list price: the answer model's tokens plus every search and fetch the agent makes, shown per 1,000 questions.
**Testing dates**
Evals were run on October 22, 2026 (Tavily on October 28, 2026).
### FinSearchComp T3 (Parallel for Finance, Oct 2026)
| Series | Model | Cost (CPM) | Accuracy (%) | | -------- | ------------------------ | ---------- | ------------ | | Parallel | Parallel Fast | 15.2 | 53.7 | | Parallel | Parallel Advanced | 161.1 | 57.4 | | Others | Exa Auto | 226.2 | 51.4 | | Others | OpenAI native search | 204.3 | 48.3 | | Others | Perplexity Finance + Web | 347 | 50 | | Others | Tavily | 481.8 | 43 |
CPM: USD per 1,000 questions, end to end (answer-model tokens plus search and fetch calls at list price).
**Dataset**
FinSearchComp[FinSearchComp] has 635 questions, written by 70 financial experts, that reproduce analyst work across global and Greater China markets. T3 is the complex historical investigation tier, the hardest in the benchmark; results are reported on the 172 graded questions.
**Evaluation methodology**
Multi-step agentic evaluation: every search API runs in the same agent loop with the same questions and the same LLM judge, so the search layer is the only variable. The agent calls the provider's search tool plus its fetch tool where one exists. Parallel Advanced, Exa Auto, OpenAI native search, Perplexity and Tavily answer with GPT-6 Sol (reasoning: high); Parallel Fast runs as the low-latency stack with GPT-6 Luna (reasoning: high). Scores are the mean of three runs unless noted. The benchmark's answers are published online. For the other search APIs, our harness drops those copies before the model sees them. OpenAI native search answers that came from published copies count as wrong (OpenAI native search scores 64.0 before that adjustment). Tavily is a single run.
Cost is end-to-end per answer at list price: the answer model's tokens plus every search and fetch the agent makes, shown per 1,000 questions.
**Testing dates**
Evals were run on October 22, 2026 (Tavily on October 28, 2026).
### PWS-Finance (Parallel for Finance, Oct 2026)
| Series | Model | Cost (CPM) | Accuracy (%) | | -------- | --------------------- | ---------- | ------------ | | Parallel | Parallel Fast | 110.3 | 83 | | Parallel | Parallel Advanced | 125.5 | 84.3 | | Others | Exa Auto | 197.6 | 75.9 | | Others | OpenAI native search | 180.7 | 83.7 | | Others | Perplexity Search API | 121.9 | 74.3 |
CPM: USD per 1,000 questions, end to end (answer-model tokens plus search and fetch calls at list price).
**Dataset**
PWS-Finance is Parallel's private finance benchmark: 174 held-out questions across eight finance workflows (company profiles, funding, deals, ownership, public financials, regulation, markets and macro, developments), each asking for specific facts about one entity as of one date. The questions and answers are not published anywhere online.
**Evaluation methodology**
Every search API runs in the same agent loop with the same questions and the same LLM judge, with a budget of 20 tool calls per question. All arms, including Parallel Fast, answer with GPT-6 Sol (reasoning: high). Strict scoring: an answer is correct only if every required fact is right. Perplexity is the Search API only, not Finance + Web. Tavily is not plotted: it ran with the model's date filters on (98% of searches limited to the past year) and hit the 20-call cap on 77% of questions, so its 36.4% at $432.10 CPM is not comparable to the other arms. Scores are the mean of three runs.
Cost is end-to-end per answer at list price: the answer model's tokens plus every search and fetch the agent makes, shown per 1,000 questions.
**Testing dates**
Evals were run on October 27, 2026.
These numbers compare search APIs inside one fixed agent. End-to-end research products publish their own FinSearchComp scores in their own harnesses, which answers a different question. For your own test, pull 30 to 50 questions from past deals whose answers you already know (a target's subsidiaries, a past acquisition price, a lapsed license) and score each provider on them. How to benchmark web search APIs[How to benchmark web search APIs] covers the setup, and the best search API for financial AI agents[the best search API for financial AI agents] compares the providers in more detail. For where diligence fits among other finance agent workloads, see AI agents in finance[AI agents in finance].
## Frequently asked questions
**What is AI due diligence?**
AI due diligence uses AI agents to handle the intelligence-gathering phase of high-stakes decisions, replacing manual multi-source research with structured, citation-backed pipelines that query web data, extract insights, and produce verified outputs. Analysts keep the judgment calls.
**What data sources should an automated DD pipeline cover?**
At minimum: SEC EDGAR for financial filings, Crunchbase for funding history, PACER for federal court records, USPTO for patent filings, news archives for recent events, and the target's own web presence. Industry-specific sources like FDA databases, EPA records, and state licensing boards add depth for regulated industries.
**How do AI agents reduce due diligence timelines?**
They query multiple sources simultaneously, extract structured data from unstructured pages, and synthesize findings into cited reports in minutes rather than days. The Task API eliminates the sequential, tab-by-tab research process that caps manual throughput.
**Can automated due diligence outputs pass an audit?**
Basis-backed outputs with paragraph-level citations, rationale chains, and confidence scores exceed the audit readiness of most manual research. Every claim traces to a verifiable source URL, with the reasoning recorded alongside it.
**What's the ROI of due diligence automation?**
Automated DD cuts the research hours each deal needs. The larger gain is reallocation: analysts spend their time on judgment and decision-making, not information retrieval. For organizations running high deal volumes, those saved hours repeat on every deal.
**Which search API is most accurate for due diligence research?**
In Parallel's tests, where every search API ran in the same agent loop, Parallel Advanced scored 57.4% on FinSearchComp T3, 6.0 points ahead of the next search API (Exa), and posted the top score on PWS-Finance at 84.3%. We ran those evaluations; the methodology[methodology] is public. Run the same comparison on questions from your own past deals before you commit.
**Can AI due diligence handle enhanced due diligence in banking?**
Yes, with an analyst signing off. Bretton's agents run KYC, KYB, and enhanced due diligence investigations for banks with about 70% of each investigation on web data, and cut investigation time from about 20 minutes to about 12.
Build your first AI due diligence pipeline with Parallel's APIs. Start with the documentation[documentation], get an API key on the Parallel platform[Parallel platform], or see how Parallel for Finance[Parallel for Finance] supports research and compliance teams.