The term worth putting down is runtime contract, and it needs a name because the thing it names does not yet exist. Start with what changed. For a decade, “AI-ready data” meant data prepared for a model to train on — clean, structured, governed, consumed in batch as data at rest. That definition assumed a specific consumer: a training job that reads a frozen snapshot once. The consumer changed. It is now an agent that reads one fact and acts on it, and most of what the old definition guaranteed quietly stops holding.
The distinction is this. Training-readiness is a quality property — established when the data is prepared, true for the life of the run. Runtime-readiness is an enforcement property — it has to hold at the instant the agent reads a fact and acts on it. Better data quality does not bridge the two, because four assumptions that were safe for the analyst invert when the reader is an agent.
| Cognitive-Era Assumption | The Runtime Inversion | |
|---|---|---|
| Time | Valid when it was published | Must be true at the read — and agents can’t tell fresh from stale |
| Identity | A human in a session, stable authority | A delegated agent that fabricates the identifier the check relies on |
| Unit of trust | The dataset, certified in aggregate | The single answer the agent reads and acts on |
| Meaning | A human carries which reading is correct | The agent resolves it probabilistically — unless governed before the read |
Three of those — time, identity, per-answer trust — are properties of the moment of consumption. They cannot be established when the data is published, because the data was true then and the question is whether it is true now, for this agent, in this answer. Only meaning can be resolved earlier, in the substrate, and the major platforms have done exactly that — Databricks with metric views, Snowflake with semantic views. That work is correct. It is also not sufficient on its own, because it answers one inversion of four.
A data contract — the field’s word, formalized in the Open Data Contract Standard — specifies what a dataset must satisfy when it is produced.
A runtime contract specifies what an answer must satisfy when it is consumed: that it is fresh enough to act on, that the identity acting on it was carried rather than invented, that this specific answer verifies. Checked at the read, not asserted at publication. Enforced where the agent acts, not where the data rests.
The data contract has a standard. The runtime contract does not. There is no shared schema that binds freshness, retrieval-grounded identity, and per-answer verification into something a platform could implement and an enterprise could audit against. The failures are documented, the fixes are appearing independently, the platforms are moving enforcement toward the boundary where the agent acts — and the artifact that would let those fixes converge has not been written.
That is the gap worth naming now, ahead of the standard, because the enterprises buying agentic platforms are buying into it today. Trust has migrated from publication to consumption. The contract that governs it hasn’t caught up.
