Resolving cascading validation errors

Validation catches bad data, but catching it is only half the job. A single upstream error cascades. One misread column header, one missed "values in thousands" qualifier, and dozens of downstream checks fail at once. The analyst then has to work backward through all of them to find the one root cause.

It's the same problem programmers have with compiler errors. The first failure is the real one and everything after it is noise, but you can't tell which is which from the list. Resolving that manually meant opening the document, finding the field, determining whether the extraction misread it or the source itself was wrong, and hunting through appendices, reference tables, and prior filings for the correct value.

After extraction was solved, the next bottleneck to resolve was validation and manual review.

An agent invoked on a specific flagged field, optionally with user-provided context about where to look. The key insight is that the validation output itself is the most useful context available. It already encodes what's wrong and how the field relates to everything else that failed.

• Assembles context from the existing value, the validation flags raised against it, the linked entity record and metadata, relevant enrichment data.
• Retrieves the most relevant text blocks and tables from the source.
• Delegates to an agent for re-extraction, choosing between deterministic capture tools, column, row, anchored text, and LLM-powered extraction, context-based, multi-hop, map-reduce, depending on the field.
• Re-validates. The same deterministic rules run again on the new value.
• Delegated back to the review agent to assess the result against the original and proposes related changes, along with a brief on what validations are resolved by this correction, for the user to accept.

Fixing the root cause resolves the dependent failures in one pass rather than forcing the analyst through each one.

Using validation output as the agent's input, rather than treating validation as a gate the agent has to pass.

Most systems run extraction, then validate, and stop. The validation messages become the human's problem. But those messages are structured, specific, and already describe the relationships between fields, which makes them the best available context for a targeted re-extraction. The error report is the prompt.

The system also distinguishes between two failures that look identical from the outside. An extraction error, which it proposes a fix for, and a genuine problem in the source document, which it escalates rather than correcting into looking right. Silently making a bad document look clean is the worst outcome in this domain, and a system that can't tell the difference will do it confidently.

The pattern applies anywhere errors cascade from a shared root, like reconciliation breaks, compliance exceptions, data quality failures across linked records. The key to making this system work well while also not exceeding access authority and leaking information to the user unknowingly is through entity resolution.

In practice, the cases that used to take an analyst the longest, the ones with five or six cascading flags, became the ones the tool helped with most, since a single root-cause fix cleared the whole chain at once.