Here’s a question I ask every independent who tells me they’re evaluating AI for title production: what’s your plant’s index error rate? In 26 years I have met exactly a handful of operators who could answer with a measured number instead of a feeling. Everyone else is about to point very fast, very confident software at data they’ve never audited — and AI doesn’t fix a bad index. It launders it.

The old system had a safety valve you probably never thought of as a safety valve: slowness. When an examiner pulls a search and something feels thin — a gap in the chain, a party that should have a judgment and doesn’t — an experienced human gets suspicious and digs. That suspicion is a data-quality control, and it works precisely because the human is moving slowly enough to notice. Point an AI search at the same index and you get the same gap back in two seconds, formatted beautifully, with nothing that feels like hesitation. The error didn’t go away. It just stopped announcing itself.

Where Index Errors Actually Come From

Plant indexes accumulate error the way houses accumulate settling cracks — slowly, invisibly, from multiple directions at once. Miskeyed legal descriptions from the era when indexing was manual data entry. Name variants that never got cross-referenced: the judgment against ROBERT J SMITH that doesn’t surface on a search for BOB SMITH. Instrument types misclassified by whoever did the county’s conversion in 2004. Gaps from the vendor transition where two systems disagreed about what got migrated. Every plant that’s more than a decade old is carrying all of these, and the operators running them mostly inherited the problem from a predecessor who inherited it too.

I made a version of this argument in the May post on search speed versus accuracy: the tradeoff everyone assumes is really an artifact of how the index was built. The corollary is that no amount of intelligence layered on top of the index can recover information the index doesn’t contain. The AI can only be as good as what it’s reading.

Measure It in a Day

The good news is that measuring this is genuinely easy, and almost nobody does it. Pull a random sample — a hundred documents is enough to get a real signal — and check the index entry against the source document image on every field that matters: parties, legal, instrument type, recording references. Not the documents your team flagged as problems. Random ones. You’re measuring the base rate, not the known trouble.

What you’ll typically find is an error rate somewhere between 2% and 8% at the field level, concentrated in exactly the fields that drive search risk. Whether your number is 2 or 8 matters enormously: at 2% an examiner’s judgment catches most of what slips through; at 8% you are quietly re-underwriting your own plant on every search and calling it examiner intuition. Either way, you now know something about your operation that most of your competitors don’t know about theirs — and you know it before you signed the AI contract, not after the first claim.

The Fix Scales the Same Way the Problem Does

Ten years ago, knowing your index was dirty didn’t help much, because the only fix was re-keying documents by hand — the same process that created the errors, at a cost nobody could justify. That’s the part that has actually changed. AI vision reading source document images doesn’t inherit the index’s errors, because it isn’t reading the index — it’s re-deriving the index from the documents themselves, at a per-document cost that makes full remediation a project instead of a fantasy. The same technology that makes a dirty index dangerous makes a clean one achievable.

That’s the right order of operations, and it’s the one almost everyone inverts. The industry impulse is to buy the impressive search layer first and assume the data underneath is fine. Run the hundred-document audit first. If your number is good, you’ll buy AI with justified confidence. If it’s bad, you’ve just discovered that the highest-ROI AI project in your shop isn’t search at all — it’s the index itself.

See how Autopilot re-indexes from the source documents →