Replacing 2-3 days of manual due diligence with a 30-minute AI report

Proxity is an invite-only deal platform and virtual data room for confidential sales of large commercial assets, connecting verified sellers with vetted investors. I joined as the first product hire, working directly with the founder, owning product strategy and delivery across the full platform: KYC verification, VDR access control, two-sided search, deal flow, and admin.

The product is a system of dependent modules - passing KYC unlocks VDR access, VDR access unlocks deals - so every feature decision touched trust, permissions, and legal exposure at once.

The platform code is written by an external dev team. I own the PRD (16 versions so far), a 280+ task backlog, QA acceptance, the legal flow (LOI/NDA e-signing, agency agreements) and the launch plan. The platform went to production in July 2026 and opened to search indexing in August 2026.

This case is about the second thing I own: the group's due-diligence engine, a separate internal service that I build myself with AI coding agents.

Qualifying a distressed-asset opportunity required manual analyst research: 2-3 days per deal. That was the bottleneck for the group's investment committee. The founder's spec described the asset types, inputs, modules and the report the committee needed. Scoping, architecture and delivery were mine to own.

There were no formal user interviews. The requirements came from the founder's spec; the design principles came from reviewing production reports with the group's analysts. Two findings shaped everything that followed:

• The research itself is highly repeatable - the same categories of questions, sources, and checks for every asset.
• Nobody trusts a conclusion they can't verify. An AI report without confirmed sources and visible reasoning would simply not be used, no matter how good the underlying model.

I architected and shipped a 13-stage asynchronous pipeline (FastAPI, Pydantic AI, Google Cloud) covering data collection, asset matching, pricing analytics, related-party analysis, and report synthesis.

The core architectural decision: run open agentic loops only where they earn their place - research and matching, where the search space is genuinely unpredictable - and collapse everything else into deterministic, typed LLM synthesis. Agents where exploration pays; structure where it doesn't. When I moved the remaining stages from an open agent loop to typed calls, the proof-of-concept gate showed per-stage LLM cost down ~3x and latency down ~5x.

Because the engine had to survive production traffic, I owned its AI infrastructure end-to-end:

• Typed tool and function calling throughout - no free-form glue between stages.
• Output validators and anti-homonym guardrails against the LLM failure modes we actually observed (e.g. conflating same-named entities in related-party analysis).
• Per-provider circuit breakers with two-layer model failover, so a provider outage degrades quality instead of killing the report.

There was no off-the-shelf eval framework for this kind of report, and honestly - we didn't start with a formal one. Quality was owned through a manual review loop that ran on every report:

• Analyst review of production reports, with errors triaged into recurring failure modes rather than treated as one-off bugs.
• Every failure mode fixed structurally - as a typed validator or guardrail in the pipeline, not a prompt patch. The anti-homonym checks came directly from observed entity-conflation failures in related-party analysis.
• Human-in-the-loop sign-off as the final quality gate before a report reached the investment committee.

• A structured, cited due-diligence report in under 30 minutes instead of 2-3 analyst-days.
• In production as an internal tool: the group's investment team runs it 8-14 times a day, with export formatted for investment-committee review.
• Agentic loops in 2 of 13 stages: per-stage LLM cost ~3x lower and latency ~5x lower than the all-agent version.
• 101 architecture decision records keep agent-written code consistent across 560+ commits.

• A formal eval framework: a regression set built from production reports with pass/fail criteria, run before every pipeline change - replacing review-driven confidence with measured confidence.
• Drift monitoring: systematic detection of source and model quality degradation, instead of discovering it through review.
• Cost and latency: extend model routing and caching, so cheaper and faster models handle more of the stages that don't need frontier reasoning.
• Broader source coverage: every new data source compounds the value of the same pipeline.

• In high-stakes domains, verifiability beats eloquence. Cited facts and traceable reasoning did more for adoption than any model upgrade.
• Agentic architecture is a budget to spend, not a default. Constraining agents to the two stages with real uncertainty made the system faster, cheaper, and easier to debug.
• Going from a founder's spec to a production system is a chain of scope and architecture decisions, not just code. The ADRs are what kept agent-written code inside those decisions.