Case study · Proxity · Founding Product Manager · Aug 2025 - now

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

A production multi-agent LLM pipeline for investment due diligence: cited facts, transparent reasoning, human-in-the-loop review - shipped as a self-serve feature, not a demo.

2-3 days → <30 mintime per report
13 stagesasync pipeline in production
First product hireworking directly with the founder
FastAPI · Pydantic AI · GCPstack I owned end-to-end

Context

Proxity is a seed-stage marketplace for confidential, off-market sales of high-value 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.

Problem

Qualifying a distressed-asset opportunity required manual analyst research: 2-3 days per deal. That was the bottleneck for the entire deal flow. The founder's brief was one sentence: "we need a way to qualify opportunities faster." Everything else - scoping, architecture, delivery - was mine to own.

Discovery

I interviewed investors and analysts doing this work. 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.
The key product insight: trust is a feature. The pipeline was designed around verifiability - every extracted fact carries a link to its source, and every decision is traceable for human review.

Solution

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.

Asset intake typed inputs Research agents agentic loop · sources Matching agentic loop Pricing & related parties · deterministic Typed LLM synthesis deterministic · validated output Cited report every fact links to a source Human review analyst sign-off · export GUARDRAILS output validators anti-homonym checks circuit breakers 2-layer model failover
Simplified view of the 13-stage pipeline: agentic loops (blue) only for research and matching; everything else deterministic and typed.

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.

Quality & failure modes

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 an investor.
The loop was simple but real: observe failures in production → name the failure mode → ship a structural fix → watch it stop recurring.

Impact

  • A structured, cited due-diligence report in under 30 minutes instead of 2-3 analyst-days.
  • Shipped as a self-serve production feature used directly by investors - with export formatted for investment-committee review.
  • Turned the platform's biggest operational bottleneck into a product capability.

What I'd improve next

  • 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: model routing and caching, so cheaper and faster models handle the stages that don't need frontier reasoning.
  • Broader source coverage: every new data source compounds the value of the same pipeline.

Takeaways

  • 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.
  • Founder-level briefs ("make qualification faster") are a feature of early-stage work - owning the path from one-line problem to production system is the job.
← All cases Next: IInsider →