When a number in a regulatory filing is wrong, a person is on the hook for it. Not a model, not a vendor, not a pipeline. A person, with a name, who attested to it.
I keep that fact at the front of every architecture decision I make, because the current moment makes it very easy to forget.
What "legacy" actually means here
The industry conversation about AI integration tends to assume a greenfield: clean APIs, structured data, a system of record that means what it says. That is not what regulated reporting runs on.
It runs on a plant historian installed before the current staff arrived, reachable only over a site-to-site VPN. On farm management systems that each model an "operation" slightly differently. On scanned records, semi-structured PDFs, and spreadsheets that encode a decade of institutional judgment in cell comments. A corpus north of ten thousand pages a year, most of it produced by people who were not thinking about your schema.
None of that is going away, and it shouldn't be the goal to make it go away. Those systems are load-bearing. They are where the actual operational truth lives. The job is to build something that reads them faithfully and produces figures that survive an audit — against USDA FD-CIC guidelines and 45Z requirements that are themselves still moving.
So the question is never "what's the number." It's "what was the number last quarter, which document did it come from, which rule version applied, and what changed." Lineage from source page to reported figure has to be queryable, or the system is worthless no matter how accurate it is on average.
What's possible today wasn't possible yesterday
I want to be clear that I'm not an agent skeptic. Extraction work that was genuinely infeasible two years ago is routine now. Triage across a heterogeneous corpus — where the right strategy depends on what the document turns out to be, and the system needs to try an approach, notice the result is structurally implausible, and fall back — is a real fit for an agentic loop, and a fixed pipeline handling the union of all cases would be enormous and brittle by comparison.
I use agentic workflows extensively. When I'm exploring a new idea, testing whether an approach has legs, or doing research, I let them run. That's where the leverage is, and the capability curve is steep enough that a position I held six months ago may already be wrong.
The balance is the whole discipline. Rapidly expanding capability on one side, and the fact that someone still signs the filing on the other.
The line, and why it doesn't move
Production codebases never ship code that the developers and reviewers didn't explicitly reason over.
Concretely: an agent cannot write to a production-bound file without a developer confirming and reasoning over every line. Not skimming the diff. Not approving because the tests passed. Reading it, understanding why it is the way it is, and being able to defend it.
That rule sounds expensive. It is much cheaper than the alternative.
The alternative is a bad transformation entering a data pipeline because nobody read the change closely, that transformation quietly misstating a figure for two reporting periods, and the discovery arriving as an audit question. At that point the explanation "an agent generated it and the tests were green" is not a defense. It is an admission that no one was reviewing. I'm not willing to put myself or my team in that position, and I'm not willing to put a client there either.
Complacency is the actual failure mode
The risk isn't that a coding agent writes something wrong. Agents write wrong code the same way people do, and review exists for exactly that reason.
The risk is what sustained high-quality output does to reviewers. When the last two hundred diffs were fine, the two hundred and first gets a glance instead of a read. That drift is gradual, it feels like well-earned trust, and it is the mechanism by which review becomes a rubber stamp while everyone still believes it's happening.
And when it fails, the blame lands on the reviewer — correctly. Approving a change means asserting you understood it. If you didn't, the process didn't fail; you did. Holding the line on genuine review is partly about protecting the people doing it from a habit that will eventually make them the person who signed off.
Trust is the product
Underneath all of this is something simpler than governance policy.
Clients are not buying an extraction pipeline. They're buying the ability to report figures they can stand behind, to a regulator, under their own name. The pipeline is how that gets delivered. The reason it's worth anything is that someone competent has actually reasoned about every part of it that touches a reported number.
That's the obligation we take on as developers, maintainers, and service providers, and it doesn't get delegated to a model — no matter how good the model gets. The tools will keep improving. The accountability doesn't move.