How AI Makes Due Diligence Faster, Deeper, and Less Allergic to Truth

On page 74 of a perfectly normal-looking contract, hiding between “notices” and “governing law,” was a sentence that basically said: we can turn you off whenever we feel like it.

Not “if you commit fraud.” Not “if you stop paying.” Just... whenever. With short notice. The corporate equivalent of your landlord installing a light switch outside your apartment.

The founder didn’t mention it, for understandable reasons. The deck didn’t mention it, for even more understandable reasons. And if you’ve ever tried to read a 120-page agreement after a long day, you know how the human brain handles page 74. It makes peace with ignorance.

Our AI caught it in minutes, flagged it as a kill switch, and forced us into the only two rational options: structure around it or walk away.

That’s the hook. Here’s the pattern.

The asymmetry problem

Early-stage investing is a game of asymmetry. A handful of outcomes matter, but the ways a company can lose are endless, and often boring. Not cinematic “we got outcompeted,” but administrative “we signed a thing,” or operational “one vendor held the keys,” or legal “nobody actually owns the code.”

Most wipeouts don’t announce themselves with a drumroll. They arrive as a footnote.

So we built a system that hunts footnotes.

Key insight: If you want better returns, you need better upside. If you want fewer zeros, you need better downside detection. The second part is less glamorous, and more controllable.

The bandwidth problem

Traditional diligence works like this:

You get access to a data room containing a small library.

You summon your finest “read everything” energy.

You read a lot, miss some things, and form a narrative anyway, because decisions hate a vacuum.

This isn’t because investors are careless. It’s because humans are built for campfires and gossip, not for reconciling six versions of a cap table while cross-referencing board consents and looking for a lien that might quietly own the IP.

Even a great investor has the same hard limit as everyone else: hours in a week and attention in a day.

AI doesn’t remove that limit. It changes where we spend it.

We use AI to do the exhausting, mechanical, high-coverage work: reading, extracting, cross-checking, and turning a messy data room into a structured set of claims with evidence.

Then we use humans to do what humans are best at: judgment, context, values, negotiation, and the final “does this smell right?”

If that sounds obvious, good. The obvious thing is often the thing that wasn’t happening.

What we mean by AI

When people hear “AI in diligence,” they imagine one of two cartoons:

Cartoon 1: A magical robot analyst that spits out truth.

Cartoon 2: A fancy autocomplete that confidently makes things up.

Reality is closer to this: a large language model is a pattern engine that can read and write like a strong generalist. Sometimes it’s brilliantly helpful. Sometimes it’s confidently wrong in the way only a machine can be, like a golden retriever proudly returning a stick that is actually a stranger’s shoe.

So we don’t ask it to “tell us if this company is good.”

We ask it to behave like a disciplined investigator inside a tightly constrained process, with rules like:

Extract facts, don’t guess

If a document is missing or unreadable, say so clearly

If documents contradict each other, surface the contradiction

Cite where each fact came from, down to the file name and clause number

Quantify risk, then explain it in plain language

We don’t treat AI like an oracle. We treat it like a machine for coverage and consistency, and we design the workflow to make “I don’t know” an acceptable, even celebrated output.

The real problem: The biggest diligence failure mode isn’t being wrong, it’s being vaguely right without realizing what you don’t know. Our system makes unknowns loud.

Red-Flag Radar Mode v1.3

The core of our approach is a prompt and workflow we call Red-Flag Radar Mode. The current version is v1.3.

That version number isn’t decoration. It’s a confession.

We’ve run this process across thousands of opportunities (we started on v0.1). We update it when reality teaches us a lesson, including the painful kind. When something breaks in the real world, we don’t file it under “edge case.” We add a check, adjust a weight, or tighten an evidence requirement so the system gets harder to fool next time.

This is what compounding looks like in diligence. Not just learning what to like, learning what can kill you.

The prompt is long because reality is long. Early-stage businesses are messy in predictable ways, and our job is to be predictably un-messy in response.

Here’s the heart of it:

We start with a standardized checklist of required artifacts: legal, financial, IP, contracts, governance, and for regulated or platform-dependent businesses, counterparty agreements that can shut the company down

We ingest every file and force a structured extraction into a single table

We run a weighted risk matrix focused on wipeout risk

We run auto-checks that behave like tripwires

We ask a set of binary “kill shot” questions designed to override vibe-based optimism

We produce a clean output in a consistent order so nothing gets buried

This isn’t about making diligence feel more scientific. It’s about making it harder to accidentally ignore the parts that matter.

How it works, step by step

Start with the data room, then assume it’s lying by omission

We begin with an input package: the data room link or attachments, plus our checklist.

Two rules matter more than they sound like they should:

Mark any missing document as ND (no data), not “probably fine”

If a document is unreadable or locked, mark ND and label it ACCESS ISSUE

This is subtle but crucial. Missing evidence isn’t neutral. It’s risk. We treat it that way.

For regulated, fintech, or platform-dependent companies, we treat counterparty contracts as primary diligence artifacts, not secondary. Because if one counterparty can freeze funds, terminate access, impose reserves, or shut off rails, that isn’t a “vendor detail.” That’s the business.

Imagine this: Your startup is a car, and your sponsor bank agreement is the steering wheel. You can have a gorgeous engine, but if someone else can remove the steering wheel with 30 days notice, you don’t really own the car.

Ingestion and extraction: turning a document pile into a map

For each checklist item, the AI creates a row with:

Doc | Facts | Status (OK / ISSUE / ND) | Comment

This is where throughput quietly explodes.

Instead of a human reading everything linearly and keeping a mental model, we force a structured model to appear on the page, quickly, consistently, and in the same format every time.

The Status column does a lot of work:

OK means we have the doc, it says what it should, and it aligns with other docs

ND means missing or insufficient evidence

ISSUE means contradiction, red flag, or material deviation

The Facts column isn’t allowed to be vibes. It must be specific extraction.

This is also where we catch contradictions that humans often miss because they read documents in isolation. The cap table says one thing. The SAFE says another. The board consent is missing. The option pool math quietly doesn’t work. The IP assignment has a gap for a key contractor. None of these are hard to spot when you’re explicitly looking. They’re hard to spot when you’re tired and reading the 19th PDF.

The table isn’t a summary, it’s an interface. It lets us see the whole company’s risk surface at once.

The weighted risk matrix: quantifying wipeout risk

Next, we run a weighted risk matrix. Categories include:

Each category gets a weight, and each gets a score from 0 to 10, with a simple rubric from low risk to extreme risk.

This isn’t an attempt to turn investing into a spreadsheet religion. It’s a forcing function:

It forces us to articulate why something is risky

It forces comparability across deals

It forces attention onto the things that create wipeout, not just the things that create excitement

It also prevents a classic early-stage failure mode: falling in love with the product and quietly discounting structural danger.

Side note: If optimism were a renewable energy source, seed investors could power entire cities. The risk matrix is our pollution control.

Auto-checks: the tripwires

Then we run a set of YES/NO checks plus key numbers.

These aren’t “nice to know.” They’re gates that trigger deeper investigation or a hard conversation.

Examples include:

Runway short: post-close runway under 12 months
Retention cliff: 90-day logo retention under 50 percent
Margin gate: variable costs too high without a credible cost-down plan
API cost concentration: one vendor representing a large share of COGS
Too much dilution sitting in SAFEs or notes
Option pool refresh needed to support the hiring plan
Secured debt with a lien on IP
Debt maturity soon, personal guarantees, UCC filings
Missing board minutes or written consents for major actions
Revenue concentration: top customer over 20 percent, top five over 50 percent
Termination-for-convenience clauses common in customer contracts
Open-source licenses with restrictive terms and no mitigation plan
Founder blocks customer references or refuses reconciliation evidence
These checks are the part of the process that feels almost unfair, in a good way.
They don’t care how charismatic the founder is. They don’t care how beautiful the story is. They don’t care what we want to be true.
They ask: is the floor solid, yes or no?

A story can be inspiring and still be standing on a trap door. Auto-checks are how we find the trap doors before we step on them.

Exit optionality and salvageability

Some businesses can fail gracefully. Others cannot.

For regulated and platform-dependent companies, we add an explicit salvageability module:

Who could plausibly acquire this in a downturn, and why

What is the sellable asset in six months: technology, licenses, data, contracts, distribution

Is acquirer dependency high, meaning only one or two buyers realistically care

What is the floor outcome: asset sale, acqui-hire, or wind-down

How fragile would a deal be: veto risk, internal politics, integration risk

This matters because, in certain business models, your downside outcome isn’t “we’ll tighten spend and keep going.” It’s “we will be disabled by a counterparty.” If that’s true, you need to structure and plan accordingly.

Kill shots: the binary questions that override wishful thinking

Finally, we ask a set of kill shot questions.

They’re intentionally blunt. Each must be answered YES or NO with one sentence and a key source.

Examples:

Is IP encumbered or at risk of creditor control?
Is survival dependent on raising within six months?
Any governance breakdown: missing approvals, unclear authority, messy docs?
Revenue fragile: concentration, easy termination, retention cliff?
Any integrity gap: inconsistent metrics, missing reconciliation, missing disclosures?
For regulated or platform-dependent businesses: can a core counterparty disable operations inside 30 days?
Can operations be restored inside 30 days without counterparty goodwill?
Is the recovery plan executable inside 90 days given team and cash?

Then a rule that sounds harsh until you remember what we’re protecting against:

If two or more kill shots are YES, default to No-Go unless we can structure around them.

We also add a repairability clock for the worst dependency shutoff scenario, with day 7, day 30, day 90 milestones, and an explicit note about whether milestones require goodwill versus contract rights.

This is where we stop pretending that “we’ll figure it out” is a plan.

The kill shots aren’t pessimism, they’re respect for physics. Some problems don’t negotiate.

A composite example

Let’s take a realistic, fictionalized deal. The details are blended from patterns we see often.

Company: a fast-growing fintech platform, early revenue, strong team, clear market need.

Data room: lots of PDFs, a sponsor bank relationship, processor agreements, customer contracts, a cap table, board consents, and financials.

What the founder story says: “We’re building the future of business banking for a new segment. Our partner handles the regulated pieces. We’re focused on product and growth.”

What Red-Flag Radar finds quickly:

The sponsor bank agreement includes termination-for-convenience with short notice

The bank can impose reserves and restrict flows unilaterally under broad definitions of “risk”

There’s no live redundancy today: no second sponsor, no second processing path

The continuity plan is aspirational, and depends on “partner collaboration”

The company is likely de minimis in the cap table unless we negotiate rights, meaning we could have limited information and governance access in a business where one contract can kill the company

In normal diligence, this might be discovered late, or discovered but softened by the excitement of the opportunity. In our system, it becomes a top-level kill shot.

Now the conversation changes.

Instead of “Seems fine, let’s move,” the conversation becomes:

What protections do we need in our rights package to match this risk?
What timeline and milestones would make redundancy real, not just promised?
What contractual changes can be negotiated today, and what cannot?
If we cannot structure around the kill switch, are we still comfortable?

Sometimes the result is a better deal: tighter terms, clearer obligations, and a more durable company.

Sometimes the result is a pass.

Both outcomes are wins.

Because the real enemy isn’t missing out. It’s walking into avoidable wipeout with a smile.

How this drives throughput without trading rigor

Throughput is a loaded word in investing. It can sound like “spray and pray.”

That’s not what we mean.

We mean something simpler: we can deeply evaluate more opportunities, with consistent coverage, and spend our scarce human attention on the parts that require judgment.

AI gives us:

Speed in first-pass reading, extraction, and organization
Coverage across long, boring documents that humans tend to skim
Consistency: every deal gets the same checklist and output structure
Cross-document checking: contradictions surface early
Faster iteration: we can refine the system as we learn

Humans still do:

Founder and customer conversations: the reality behind the documents
Contextual interpretation: what is normal for this sector and stage
Negotiation and structuring: translating risk into terms and conditions
Final decisions: including the courage to say no

AI makes it easier to be both fast and careful, which is the rare combination most investors claim and few can operationalize.

Avoiding the obvious failure modes

A serious AI diligence process has to grapple with its own risks. Here are the big ones, and how we address them.

The hallucination problem: Models can invent. So we force evidence. If the source is unclear, it must be ND. If a doc is summary-only where primary text should exist, it’s ND due to insufficient evidence.

The false confidence problem: We keep outputs constrained, structured, and source-linked. We also treat AI output as a draft for review, not a verdict.

The “garbage in, garbage out” problem: We treat missing or locked documents as risk. ACCESS ISSUE isn’t a footnote, it’s a signal.

The overfitting problem: A rigid checklist can miss new failure modes. That’s why the process is versioned, and updated based on outcomes, including the deals we pass on, the deals we do, and the cases where reality surprises us.

The values problem: AI can optimize for what you measure. We measure wipeout risk explicitly, but we don’t pretend it captures everything that matters, like founder integrity, pace of learning, or customer love. Those stay human.

The model is great at reading contracts. It’s terrible at feeling the tension in a founder’s voice when you ask, “So... who actually owns the code?” We keep both.

Why this matters for LPs

From an LP perspective, the question isn’t “Do they use AI?” because that’s quickly becoming like asking, “Do they use spreadsheets?”

The question is: “Do they have a repeatable system that turns information overload into better decisions, and do they learn fast enough to improve it?”

Our answer is yes, and here’s what that translates to:

More consistent diligence across deals: fewer blind spots created by fatigue or time pressure
Faster cycle times without skipping the boring but lethal details
A clearer view of downside, which improves decision quality and structuring
Better institutional memory: the process is documented, versioned, and iterated
Stronger conviction when we say yes, and cleaner reasons when we say no

Our edge isn’t that we read faster. It’s that we make it harder for ourselves to ignore what we read.

The bigger pattern

We live in a world where the limiting factor is no longer access to information. It’s the ability to digest it without lying to yourself.

Founders can ship faster. Markets can shift faster. Risk can compound faster. And the document trail of a startup (contracts, cap table, security terms, vendor dependencies) gets complex earlier than it used to.

In that world, diligence can’t be a heroic one-off act. It has to be an operating system.

Ours is built around a simple idea:

If something can wipe out the business, it deserves a named check, a demanded document, and a yes-or-no question.

Everything else can be debated.

No, we don’t let a model decide what to invest in. We let it do the parts that computers are good at, so humans can do the parts humans are responsible for.

If you want the one-sentence summary of our approach, it’s this:

We use AI to turn diligence from a stressful reading marathon into a structured investigation, then we use human judgment to decide what the evidence actually means.

And we keep refining the system, deal by deal, because the market is an unforgiving teacher, and we prefer to learn quickly, on paper, before we learn slowly, with losses.