Rich Sutton, who later won the Turing Award for his work on reinforcement learning, opened a March 2019 essay called The Bitter Lesson with a sentence that has been quietly reorganizing AI ever since: “general methods that leverage computation are ultimately the most effective, and by a large margin.” It runs about a thousand words and is worth reading in full.
His evidence is a pattern that repeats across seventy years. Computer chess: decades of encoded grandmaster heuristics, and then in 1997 the program that beat Kasparov won on massive, deep search. Computer Go: the same arc. Speech recognition: a 1970s DARPA competition pitted linguists who had carefully modeled phonemes and the vocal tract against statistical methods, and the statistics won. Computer vision: hand-designed edge detectors and SIFT features, replaced by convolutional nets.
Only two methods, Sutton argues, “scale arbitrarily” with computation: search and learning. Everything else is scaffolding. And the reason the scaffolding loses is not that its builders were wrong about their domain. It is that the cost of computation keeps falling exponentially, so the general method that was too expensive last year is affordable this year, and it arrives without a ceiling.
He calls the lesson bitter because the losing approach is the one that feels like progress. Encoding what you know produces real, visible wins early. Then, in his words, “it plateaus and even inhibits further progress.”
If you sell software with a semantic layer in it, that sentence should keep you up at night.
Analytics spent a decade on the losing side
Consider what the data industry built while that essay was circulating.
Certified dashboards, where a human decides in advance which questions matter. Curated question banks, where a human writes the questions the AI is permitted to answer. LookML and its descendants, where a human hand-authors thousands of lines of business logic and then maintains them forever. Prompt libraries. Few-shot example collections. Two-quarter onboarding projects whose deliverable is a map of your 2,000 tables.
Each of those is a bet that human-encoded knowledge is the durable asset. Each is the exact bet Sutton says loses.
And the plateau is visible if you look for it. An enterprise semantic model covers the questions someone thought to model. Ask something adjacent, and you get nothing, or you file a ticket. Rigid layers do not fail loudly; they fail quietly: people stop asking real questions, and trust drains away. That is what a plateau looks like from the inside. Not an error message. A slow decline in curiosity.
Sutton is blunt about the underlying reason. His second lesson from the whole pattern is “that the actual contents of minds are tremendously, irredeemably complex,” and that we should stop looking for simple ways to think about them. Any attempt to write down how a good analyst thinks is a lossy sketch of something that does not compress.
The opposite mistake
Here is where the essay gets misread.
The obvious conclusion is to skip the modeling, point a frontier model at the warehouse, and let scale sort it out. That is the text-to-SQL bet, and it fails, though not for the reason vendors usually give. It does not fail because the models are not good enough. Writing competent SQL is largely a solved problem.
It fails because search and learning need something every one of Sutton’s examples gets for free: a score.
Chess tells you when you lost. Go tells you. Speech recognition has labeled transcripts. Vision has labeled images. In each case the environment supplies ground truth cheaply and in volume, which is exactly what lets compute grind against it and improve.
Your warehouse supplies nothing. Ask for revenue by product and a model can return valid SQL that joins one-to-many and silently multiplies the row count. The query succeeds. The chart renders. Nobody is told anything is wrong. The output still looks legitimate, which is what makes this failure mode so expensive.
Compute without a reward signal is not the Bitter Lesson. It is an expensive guess.
The distinction that resolves it
Two very different things get packed into the phrase “semantic layer,” and the conflation is why this argument never ends.
The first is knowledge about how to analyze. Hard-coded cohort logic. A rule that revenue is always grouped by fiscal quarter. A list of the fourteen approved questions. Heuristics about how a good analyst reasons. This is the grandmaster’s opening book. It is the irredeemably complex thing Sutton warns about, and a better model will beat it. Every quarter spent expanding it is a quarter spent building a liability.
The second is facts about what things mean at your company. Net revenue subtracts returns and excludes intercompany transfers. “Active user” means 28 days, not 30. Orders joins to order_lines one-to-many, so summing naively inflates the total. These are not heuristics, and no smarter model can derive them, because they are not derivable. They are arbitrary institutional facts. The only reason they are knowable is that someone wrote them down.
That second category is not the opening book. It is the rules of the board.
AlphaZero learned Go from self-play with no human game knowledge at all. It did not learn the rules of Go from self-play. The rules were given, exactly, up front. That is precisely what made it possible to score a position and hand the rest to compute.
A context layer, done right, is the rules of the board. It does not exist to limit what the model is allowed to think. It exists so that when the model thinks, something can tell it whether it was right.
Where we are placing the bet
That is why Zenlytic is built the way it is, and it is a bet you can audit rather than take on faith.
Reasoning is search, not rules. Zoë works as an agentic loop: at each step she chooses whether to call a tool or to answer, and the loop runs until she responds. There is no decision tree drawn in advance. She reads the context layer to find the measures, dimensions, and joins your question actually needs, and composes from there. Which model does the reasoning is a setting, not an architecture. When a better one ships, she gets better and we rewrite nothing. That is the whole point of being on the right side of this.
Context is learned, not hand-authored. The largest store of institutional knowledge most companies own is their query history, and almost nobody uses it. Every query your team has run encodes which tables are trusted, which joins are correct, and how raw columns become business metrics. Index the queries, not just the tables, and you get that back: a company might have 2,000 tables but only 150 patterns that actually matter. Zoë also reads spreadsheets, code, Slack threads, and dashboards and proposes context updates from them, which you approve and which land in Git as a reviewable pull request.
Verification stays deterministic, on purpose. Before any query reaches your warehouse, the Clarity Engine validates every field reference, join, and aggregation against your model, enforces row and column-level security, and writes a plain-English account of what it did. This is not a model grading its own homework. It is a checker. Governed fields are visibly marked as such, and every figure carries its source tables, filters, and metrics. This is the one part we will not make probabilistic, because it is the reward signal. Remove it and you are back to guessing expensively.
Put compute on the part that scales. Keep the part that supplies ground truth exact, small, and cheap to maintain.
Four questions for your vendors
- When a better model ships next quarter, what do you have to rewrite? “Nothing, it is a setting” is the right answer.
- Where does your context come from? If the answer is a services engagement, you are buying an asset that depreciates.
- What checks the query before it runs, and is that check deterministic? “Our model is very accurate” is not an answer.
- What happens on a question nobody anticipated? That is the entire game, and it is what demos are designed to avoid.
The bitter part
For those of us who build data tools, the uncomfortable reading is that much of what our industry is proudest of is scaffolding. The elaborate models. The curated content. The onboarding methodology. It feels like the product. Sutton’s argument is that it is a bridge to the moment compute can do the work directly.
We think he is right, which is why we are trying to make the bridge short and putting the effort into the one thing a bigger model does not replace: knowing when the answer is wrong.
That part is not bitter. It is the job.