The Semantic Layer That Heals Itself

Somewhere in your warehouse is a column called is_active. It came from Django’s built-in user model, where it means one narrow thing: the account hasn’t been deactivated. An analyst or agent reasonably reads it as “active user,” meaning someone who actually uses the product. Now the dashboard counts every customer who signed up and never came back, and nobody notices until the number lands in a board deck.

Most data teams fix this by having someone write the definitions. I think there’s a better answer, and it’s buildable today. With an LLM in the loop, a semantic layer can heal itself. The people and agents who use the data tell it what things mean, in tools they already use, and the system proposes, tests, and versions the change. Meaning stops being declared by the data team and starts being learned from users.

That’s a cybernetic system, and it’s the most practical illustration of cybernetics I know.

What I mean by cybernetics

Cybernetics has a rich history tied to early AI, but a working definition is enough here. A cybernetic system is a feedback and control loop (sense, interpret, respond) in which people and machines both take part, and the machine brings some reasoning of its own. A person acts, and the machine responds. The machine acts, and the person responds.

It’s close to John Boyd’s OODA loop (observe, orient, decide, act), which he drew from fighter combat. The difference is that a cybernetic system can run the loop itself.

We’ve had systems like this for a while, but they’ve been mostly human-directed and deterministic. LLMs can handle the “interpret” step that used to need a person, which hands more of the loop to the machine. The autonomous loop is no longer theoretical.

Why meaning drifts

Observational data, collected from apps, operational systems, and web clients, is a log of what actually happened. Much of what a company believes rests on it. Beliefs drive action, and action generates more data. (OODA loop, anyone?)

But that data is shaped by what the application needs, not what the analyst or agent downstream needs. is_active is a perfectly good field inside Django. It only becomes misleading once it leaves. And “active” keeps moving with every new free tier, pricing change, or shift from monthly to weekly engagement. A semantic layer exists to bridge that gap, but when it’s maintained by hand, it always lags behind what the business means.

The ingredients already exist

Most companies already have two of the three pieces. The first is chat. Microsoft has said 91 of the Fortune 100 use Teams, and most mid-size and large companies run on Teams, Slack, or both. The second is an analytical database like Snowflake, BigQuery, or Redshift, though that’s less common at smaller businesses.

Add a semantic layer like dbt’s MetricFlow (or plain dbt Core) and you have everything. One concrete stack would be MetricFlow for definitions, DuckDB for the database (especially with the recent 2.0 launch), and Slack’s Bolt framework for the interface.

How the loop runs

Feedback is decentralized. No single team owns meaning. The people closest to the data do, and the system meets them in Slack. There are two ways in.

Check-ins. On a schedule, but on a random day, a bot picks a definition and asks someone who works with it: “Does ‘active customer’ still mean logged in within 30 days with a paid seat, and is this how it should be composed?” Small questions spread across many people and days replace the quarterly audit and catch drift as it happens.

Questions. People can also query the data directly: “How many active customers did we have last month?” The LLM answers from the semantic layer, which reduces uncertainty on the spot. Each answer is also a test. If it isn’t what the person meant, their reply becomes feedback.

Either way, the loop is the same:

1. Sense. A check-in reply or a question surfaces what someone believes a thing means.
2. Interpret. The LLM works out which model, metric, or dimension needs to change, and how.
3. Update the semantic layer. It revises the definition and validates it against DuckDB to confirm the meaning holds in the data.
4. Update the physical layer. The change propagates to the underlying tables and models, versioned for review or rollback.
5. Repeat. The next check-in or question starts from the improved definitions.

So the loop does two jobs. Decentralized check-ins preserve meaning and catch drift at a scale no central team could manage, and Slack Q&A reduces uncertainty for whoever is asking. Users supply the meaning. The machine does the reasoning to make that meaning true in the system. Neither could do it alone, and every pass leaves the layer a little more accurate. That’s what I mean by self-healing.

We’re just getting started

This is a small loop, but it shows something we keep relearning as these systems grow more capable: the hard part isn’t the loop. It’s what the loop optimizes for. That objective, stated or not, decides where the system ends up. A semantic layer that optimizes for whatever users say drifts with opinion. One that optimizes for agreement settles on comfortable definitions instead of accurate ones.

We rarely know the right objective in advance. We find it by running the loop and adjusting, which is why grounding matters. Observational data records what actually happened, and that gives the loop an epistemically honest anchor. If someone says an active customer is anyone who logged in this month, the data can push back: does that group actually pay, renew, and keep using the product? Each validation tests a belief against reality, not preference.

Grounding won’t hand us the right objective. It keeps us honest while we search for one, and it steers us toward an objective we can see, question, and correct together. That’s what makes the loop worth interacting with: people and machines working from the same record, slowly learning what to optimize for.

We’re at the beginning, and early versions will be clumsy. But if they stay rooted in what actually happened, every turn of the loop brings us closer to something worth optimizing for.