Check the path, not just the number
A figure can be right this month and arrive by a route that’s wrong next month. Nothing in your stack is looking at the route.
A number can be right this month and arrive by a route that will be wrong next month. Nothing in your stack is looking at the route.
Agentic engineering runs two evaluations, and the second one is the interesting one. Output eval asks whether the artifact is correct: does it compile, do the tests pass. Trajectory eval asks how it got there: the sequence of steps, the tools it chose, the reasoning in between. Both, because a fluent output that skipped its verification steps is more dangerous than one with a visible error.
Read that again with a number in mind. It describes our entire problem, and we have no name for it.
Everything we check is output eval
Row counts. Nulls. Referential integrity. Freshness. A reconciliation against a known total. Every one asks the same question: is the artifact structurally sound, and every one passes on the morning your migration quietly changed the meaning of the figure on page four.
Here’s the shape of the miss. Two runs produce 4.2 million in exposure. Both pass every check you own. One aggregated at contract account, applied the flat-rate exclusion and took the join path somebody signed off. The other aggregated at meter, missed the exclusion, and landed on the same total by coincidence, because this month the two errors cancelled. Next month they won’t.
Output eval says the number is fine. Trajectory eval says the number is fine and it got here the way we agreed. Only one of those survives a change upstream.
What a data trajectory actually is
It’s not mysterious, and it’s not lineage. Lineage tells you which tables were touched. A trajectory is the sequence of semantic decisions the derivation made, and every one of them is checkable against a model somebody ruled on.
Every one of those is a comparison between what the derivation did and what the model says it should do. That comparison is computable. It just isn’t computed anywhere, because we’ve never framed it as a thing to check.
Why it gets urgent from here
Because the rate of change went up. When an agent can refactor forty queries in an afternoon, the safeguard that used to catch this, someone experienced noticing a diff looked odd, stops scaling. It was never a strong control anyway. It was a slow one, and the slowness was doing the work.
A machine-readable trajectory check doesn’t care what generated the change. Contractor, junior, or a model at three in the morning: if the derivation drifts off the ruled path, it fails, and it fails with a reason a person can argue with.
So the next time a reconciliation comes out clean, ask the second question. Not “is the number right?” but “did it get here the way we said it should?” If nothing in your stack can answer that, the clean reconciliation told you almost nothing.