A number owes you its assumptions.

What data is

Start further back than this industry usually starts — not at the tool, not at the query language, but at what data is.

Every datum is something said about something else. A value, said of something. The measure is what is said; the anchor — the set of coordinates it is said at — is what it is said of. A column is a measure over its anchor. Not the smallest element of data — a data point is — but the simplest structure of data: the atom of structured data operation.

And a table? A table is a container. Form, not substance. Its keys and layouts hint at meaning — but hints are not declarations, and nothing checks them. This is why fifty years of table operations have been necessarily mechanical: you can only do mechanical things to a container, because a container has no aboutness to respect. Operations over columns are substantial — they must honor what the column says, and what it is said of.

Tables are how data is stored. Columns are what data says.

Your average-order-value question went wrong exactly here. The answer had to be computed over something — lines, orders, customers — and that "over" is a property of the column, not of the table it happened to be stored in. The table couldn't tell you. Tables can't. It isn't their job.

The algebra that was never written

Half a century ago — Codd, 1970 — the container got its mathematics. Relational algebra — select, project, join — closed over tables, indifferent to meaning. It was a genuine triumph, and it built everything you use. But it is an algebra of form.

The algebra of the substance was never written. The great rebellion against the table — key-value, objects, documents, graphs — reached for substance and won everywhere retrieval rules. But it won everywhere except where structured data live: the moment the workload turned analytical, every rebel surrendered back to SQL, or bolted on a map-reduce with no theory of legality at all. Structured analytical data stayed the container's last kingdom — not because tables are right for it, but because nobody had written the substance-side algebra.

So we wrote it. The framework is called Columna, and the name is the thesis: it stands for Column Algebra. Columns and their operators — mappers and reducers — composing into expressions; some grammatically well-formed, some not; and the line between them drawn by the nature of each column, captured in three anchors: where its values live, where they leak and by what mechanism, which directions of reduction are barred. From these, legality follows. Whether you may sum this, roll that up, divide these two — not policy, not convention, not a style guide.

Two kinds of metadata

Here is the part the industry will recognize, because it has been paying for the confusion for decades.

Metadata was never one thing. Some of it is load-bearing: change it and you change what operations are legal, or what value results — which unit an average reduces over, which population a count is drawn from. And some is communicative: it exists so that a person — or now a model — can understand. The test is decidable, not aesthetic: does changing it change legality or value?

For fifty years the two kinds lived fused — some in schema structure, some baked into column names, some in documentation, and the decisive remainder in the analyst's mind. Because the load-bearing kind had no home, the industry forced names to carry it — ARPU forks into ARPPU because a denominator had nowhere else to live — and then built a governance regime to police the names, and called it the semantic layer. Look closely: it was never semantic. It was correctness wearing meaning's clothes — and therefore frozen. Governance solves drift. It cannot solve ambiguity. You cannot decree your way out of a grain.

Language solved this before we were born: grammar decides well-formedness independent of meaning, and that autonomy is what makes language both checkable and infinitely expressive. Data deserves the same constitution. Put correctness in the grammar layer — the algebra above: small, closed, machine-checkable. The moment it has a home, meaning is demobilized: names become pure communication — colloquial, translated, plural, generated — because nothing operational rides on a string anymore.

Codd separated logical from physical and called it data independence. This is the sequel: metadata independence — meaning separated from correctness so each can finally do its job. One inversion, two liberations.

The stakes: the analyst who never hesitates

Now return to the machine that answered in a second.

A language model is a semantic engine — magnificent at meaning, constitutionally incapable of guaranteeing correctness. Hand it today's fused metadata and its greatest strength becomes its signature failure: it reads avg_order_value and confidently means something by it. For fifty years, the argument between human analysts was the safety mechanism — three people with three numbers is visible disagreement, and visible disagreement gets caught in the meeting. The AI analyst answers instantly, confidently, singularly. The argument never happens. The debt came due the day the analyst stopped being human.

Split the layers and the model is finally in its element: living entirely in semantics — names, descriptions, intent, conversation — while every operation it proposes is adjudicated by a grammar it cannot touch. Hallucination, injection, drift can corrupt only the semantic layer. The grammar layer is the blast wall. The model proposes; the grammar disposes; the human decides among genuine alternatives.

And the system's answers gain the vocabulary honesty requires — four moods, as structured data: serve the number; disclose it with its assumptions attached; clarify when the question admits several legitimate readings; refuse what the data cannot answer, with the reason. "It depends," said precisely, is often the most correct answer there is.

That is a claim about running software. So watch it run.