Metadata is the control plane of the agentic data stack

Data platforms have always kept a polite separation between the data plane, where bytes move, and the control plane, where decisions about the bytes get made. My claim is that metadata is that control plane — and the arrival of agents as data consumers converts this from an architecture nicety into the load-bearing design decision of the stack. A human analyst who hits a badly cataloged table asks a colleague. An agent that hits one either fails silently or, worse, proceeds confidently. Everything an agent can discover, interpret, query, and be permitted to do is mediated by metadata; there is no hallway to ask in.

Walk the agent's path and count the metadata dependencies. Discovery: the catalog decides what exists and what it's called — an agent finding a metric view through a search index is doing metadata retrieval before it touches a row. Interpretation: descriptions, synonyms, and semantic annotations are the difference between an agent that queries revenue_recognized and one that helpfully sums revenue_booked. Authorization: row filters, column masks, and attribute-based access rules are metadata evaluated at query time — the permission system is a metadata interpreter. Trust: lineage answers whether the number came from the governed pipeline or somebody's forgotten notebook. At every hop, metadata isn't describing the interaction; it is executing it.

This is why "active metadata" is the phrase that matters. A passive catalog is documentation — filled in by humans, aging from the moment it's written, consulted by nobody. A control plane is enforced: contracts that reject nonconforming writes rather than lament them, policies expressed as code and evaluated on every request, lineage captured as a runtime property of query execution rather than curated by hand. The test I apply is simple: if the metadata disagreed with reality, would anything actually stop? If the answer is no, you have a wiki wearing a catalog's costume, and your agents are navigating by a map nobody is obliged to keep true.

The design consequence is that metadata deserves the engineering investment we historically spent on pipelines. Schema, semantics, ownership, quality signals, and policy need to be written where the platform can evaluate them, versioned like the interfaces they are, and exposed through the same access layer agents use for data. The platforms getting this right converge on the same shape regardless of vendor: a governance spine that owns namespace, privilege, and lineage; contracts at the producer boundary; a semantic layer at the consumer boundary; and policy-as-code across all of it. That stack is the control plane. The engines underneath are increasingly interchangeable; the metadata layer is where the platform's actual behavior is decided.

The concession: a control plane is only as real as its adoption economics, and metadata has a long history of losing that fight. Every failed data dictionary and abandoned governance council proves that mandating metadata production without answering "what's in it for the producer" yields empty fields and stale entries. The way through is to make the platform generate most of it — lineage from execution, statistics from storage, contracts from schemas — and to make good metadata immediately valuable to the team that writes it, because their own agents and dashboards run better. Metadata that must be manually maintained against no incentive isn't a control plane; it's homework, and homework doesn't get done.

The one-line version I use with clients: your agents will be exactly as good as your metadata, because metadata is the only part of the platform they can actually read. Govern the bytes through it, or watch agents improvise around it.