Skip to content
DigitalBorders

AI & Automation

A browser farm and a multi-LLM rule engine for document due diligence

a due-diligence firm

A due-diligence firm needed to pull verifiable facts out of source documents that only exist behind logged-in web portals. DigitalBorders built the whole pipeline — a farm of real Chrome browsers, driven over the DevTools Protocol, that collect the documents, and a multi-LLM rule engine that extracts each fact and ties it back to where it came from.

  • Neko
  • Puppeteer
  • Chrome DevTools Protocol
  • OpenRouter
  • Convex
  • Next.js
  • TypeScript

Context

The firm runs due diligence on companies and the people behind them. The evidence lives in documents — filings, registries, reports — scattered across web portals that expect a real, logged-in browser, not an API. Analysts were opening each source by hand, downloading PDFs and spreadsheets, and copying the facts that mattered into a checklist. They brought the whole automation to DigitalBorders: collect the documents, extract the facts, and let a human review instead of transcribe.

Problem

The hard part wasn't any single document — it was getting to them and reading them at scale, with every fact traceable.

  • The sources have no APIs. The data sits behind interactive portals, often behind a login. Reaching it means driving a genuine browser session, not calling an endpoint.
  • One browser isn't enough. A real run needs many sessions in parallel, each isolated, each with its own downloads kept apart from the rest.
  • A document isn't an answer. A 40-page PDF is not a fact. The firm needs specific values, each one tied back to the exact source it came from and checked against the firm's own rules.
  • No single model is reliable on its own. An extraction one model fumbles, another gets right. The pipeline has to route across models and let disagreements surface rather than hide.

Approach

We owned the whole chain — the browser infrastructure, the extraction engine, and the dashboard analysts work in.

The collection layer is a farm of real Google Chrome instances running inside Neko containers, each exposing the Chrome DevTools Protocol through a proxy so our automation drives it with Puppeteer over CDP. Every session gets an isolated browser profile and a scoped downloads folder; a file server enforces a strict policy — only the document types we expect (PDF, spreadsheets, Word), kept per session, cleaned up afterward — so a run can't quietly accumulate junk.

The documents flow into a rule engine that runs extraction across multiple LLMs routed through OpenRouter, so each rule can use the model that handles it best and conflicting answers are caught instead of trusted blindly. Every extracted fact is bound to the source document it came from.

Analysts work in a Next.js dashboard backed by Convex, with role-based access: they configure the rules, watch runs as they go, and review the extracted facts. One team owned the browser farm, the extraction engine, and the dashboard, so the boundaries between them lined up instead of being negotiated across vendors.

Outcome

A run now spins up browsers that gather the sources, the rule engine extracts and cross-checks each fact against the firm's rules, and the results land in the dashboard where an analyst reviews them — reading and judging, not collecting and copying. Because the farm drives real Chrome, it reaches sources an API-only approach simply can't, and because every fact carries its source, the firm can stand behind what the pipeline returns.