A retailer asked a question and got a clean answer. Ten percent of people improved in enjoying the buying experience. The system was a RAG. Grounded, retrieval augmented, pointed at real documents so it would not have to invent. The delivery report was genuine. It was retrieved. The passage was found and the passage was correct. It said ten percent of new customers. By the time the answer reached a person, new customers had become people. A slice had become the whole.

Nobody noticed. The number went into a room and became a decision.

That is the door. Walk through it and leave it behind, because the system is not the subject. The subject is what the person did next. They read the answer and they acted on it. And in acting on it, they treated it as true.

What Gets Promoted to True

An output arrives. It is fluent and it is finished. It is shaped like a conclusion. And the person receiving it does the smallest possible thing. They accept it. They do not check the source, do not test the claim, do not ask whether ten percent of people is even the kind of thing that document could have said. They read a sentence that looks done and they carry it forward as if it were true.

This is the whole event. Not the generation. The reception. The interesting failure does not happen inside the machine. It happens inside the person, in the half second where a plausible sentence gets promoted to a true one, and nothing in that half second involved reading the thing the sentence claimed to describe.

The error was already complete before the person arrived. New customers became people before a single pair of human eyes reached the text. What landed in front of them was already bent, and it was wearing the clothes of a fact. All they had to do was believe it. They did.

What Truth Is Here

Truth is a contested word and it is fair to stop on it. Say it in a room and half the people mean correspondence to reality and half mean whatever survives their own agreement, and the argument stalls before it starts. So fix it before going further.

Truth here is data based and evaluation based. Something is true when there is data for it and an evaluation that holds that data against what exists and confirms it. Not what feels right. Not what reads well. Proof of existence, checked. A number is true when the data carries it and the evaluation confirms it against the thing it claims to describe.

Hold the retailer against that. Ten percent of people had no data behind it as stated, because the data said new customers. It had no evaluation against what existed, because nobody checked. It failed both tests at once and it was believed anyway. That is the whole problem in one line. The output was accepted as true without data that said what it said and without an evaluation to confirm it, and truth without either of those is not truth. It is a sentence that got believed.

That definition also names the deeper failure. The system does not evaluate against existence. It cannot. It produces the likely continuation, and the likely is not the evaluated. Evaluation against what exists is the human step, the one that got skipped. Once you define truth as data plus evaluation, the skipped step is not a nicety. It is the exact place where truth was supposed to be made and was not.

Likelihood Is Not Truth

Be precise about why the output could never have carried the truth on its own.

A deterministic process produces output you can check against its input. The output stands in a fixed relation to what went in, so you can hold one against the other and trace a wrong result back to the step that produced it. It is not guaranteed to be right. A deterministic process can be reliably wrong. But it is checkable, and checkable is the thing that matters, because it means the output can be evaluated against what exists.

A probabilistic process does something else entirely. It produces the most likely continuation. It is optimized for fit, for plausibility, for what should come next given the pattern it has seen. Correspondence to anything real is not the target. It was never the target. The sentence that reads best is the sentence that wins, and ten percent of people reads better than ten percent of new customers. It is smoother. It is more general. It is the more likely thing to say. So it was said.

Likelihood is not truth. They are two different axes and they cross only by accident. Sometimes the most likely sentence is also the true one, and when that happens you feel confirmed, and the confirmation teaches you to trust the next one. But it was never aiming at true. It was aiming at likely. Nothing in the process held the data against what exists and confirmed it, because that is not what the process does. The overlap is luck. Build a habit of trust on luck and the habit outlives the luck.

The Fix Is the First Corruption

Here is where the misconception lives. Retrieval, grounding, knowledge graphs, ontologies, all the machinery for feeding real data into the answer. The field points to these and says the problem is solved. The model is no longer inventing from nothing. It is reading from your documents, your sources, your curated truth. Surely that moves it onto the checkable side.

It does not. The retrieval changes what the model looks at. It does not change what the model does with it. The step where the model reads the retrieved data and produces an answer is the same probabilistic step it always was. It is still generating the most likely continuation, now conditioned on the document instead of on nothing. Likelihood, not evaluation. So the drift is not held off by grounding. It enters exactly where it always did, at the interpretation, and grounding is standing next to that step doing nothing to it.

Be precise about the claim, because there is a version of it that is wrong. Grounding does help in one narrow case. When the model would otherwise invent a fact it never had, handing it the document to read from is more reliable than asking it to recall. For a missing fact, retrieval is a real improvement. That is the case the field generalizes from, and the generalization is the error. Grounding fixes the knowledge gap. It does not touch the interpretation. And the failure that matters here is not a knowledge gap. It is an interpretation.

Return to the retailer. Nothing was missing. The document was retrieved, the passage was present, the number was correct on the page. Ten percent of new customers. The model was not filling a gap, it was reading a line that was right in front of it, and it still produced ten percent of people, because that reading was more likely and likely is all the step optimizes for. Grounding was working perfectly and had no purchase on the error, because the error was not in what was retrieved. It was in the interpretation of it, and interpretation is the one thing grounding does not change.

So the first corruption is at the first interpretation. Before any person reads the answer, before it is stored, before it is spread, the data was interpreted probabilistically and the drift was already in. This is the point the fix cannot reach, dressed as the point where the fix works. The document was real and the reading of it was probable, and a probable reading of real data is not a true one. It only looks more true, because now it comes with a source attached. The grounding did not remove the corruption. It gave the corruption a citation.

That is the misconception in full. Grounding, and the reading of the grounding, is the same failure as probabilistic against deterministic, one layer out. People think supplying real data moves the operation to the checkable side. The supply changed. The operation did not. The interpretation is still probable, not evaluated, and the drift lives there, at the first touch, wearing the authority of the source it was drawn from.

Meaning Is the Defining, Not the Definition

Here is the line people walk past.

Meaning is not stored in the document and it is not stored in the output. Meaning is the defining of a situation, done by someone who is in it, and altered the moment the situation moves. It is a verb. What gets written down is a definition, the defining frozen into something you can act on. The freeze is not the error. Acting requires it. You cannot operate on a live reading, only on a commitment, so the reading collapses into a fixed enough thing to use. That collapse is necessary and it is proper. It is what every actable output is.

The error is believing the freeze is the meaning. A definition is the act with the act taken out. You can read it later, but you are reading ash and calling it fire. This is not a stance to share. It is how meaning works wherever it has been studied as fact. The holding of what something means is not a stored position retrieved on demand. It is an ongoing act of defining, and it exists only while someone situated is doing it.

The retailer’s ten percent is a freeze. It was a reading of a delivery document, collapsed into a number and written down. Fine so far. That is what the system is for. But the number is now a definition of a situation that nobody who reads it next is in. It froze at capture and it will never be altered, because the thing that alters a definition is the person who has to live inside the situation the definition reshaped, and no such person is attached to a stored value. The output reshapes situations it does not live in. The consequence lands on the reader, the room, the next quarter, never back on the frozen number, which is identical the instant after it is acted on as the instant before. The freeze with the alteration cut off. A definition made once, by no one who is in your situation, applied to a moment it was never a reading of.

When the Freeze Becomes the Truth of People

Now watch it stop being one person’s problem.

A person reads the frozen number and does not reread it. They cannot feel the freeze, because nothing in the number announces that it was ever a live reading of anything. So they hold the definition as if it were the defining. They state it, fluent and finished, and it moves to the next person, who inherits it already wearing the marks of validation and so does not reread it either. The freeze propagates. It stops being a value one person believed and becomes the definition a group defines its situation against.

And here the thing completes itself. If people define a situation as real, it is real in its consequences. The felt truth does not have to be true to become the truth of people. It only has to be acted on together. Once the room builds on ten percent of people, that number is real in everything that follows, the decisions, the budget, the story told about customers, whatever the document actually said. The consequences make it real. The frozen definition becomes the shared floor everyone reads from, and a shared floor is harder to reread than any private claim, because it no longer looks like a claim at all. It looks like the ground.

That is the felt truth becoming the truth of people. Not one person accepting a wrong number, but the wrong number becoming the reality a group operates inside, consequential and self sustaining, because they defined it as real together and then lived in the consequences. It stops being an error someone could catch and becomes the thing that decides what counts as an error at all.

Output Is Not Outcome

Two words that people collapse, and the collapse is where the damage lives.

Output is the artifact. The sentence, the number, the paragraph the system hands over. Sitting there, it harms no one. It is a string of words in a box.

Outcome is what happens when a person acts on it. The number enters a decision. Effort gets pointed somewhere. Budget moves. A story about customers gets told that is not the story the data told. The output could sit in a log forever and change nothing. The outcome reshapes the next quarter.

The person is the one who turns the first into the second. That is the entire weight of their role, and most of the time they carry it without noticing they are carrying anything. They read the output, they authored the outcome, and in between they validated nothing. The step that was supposed to sit in that gap, the reading, the checking, the human actually doing the work of meaning, got skipped. Not maliciously. Just skipped.

The Bridge Is Laziness

What carries a person across that gap without checking is not stupidity. It is economy.

Thinking is expensive. Reading the source, finding the passage, noticing that new customers is not the same set as people, holding the distinction, correcting the number. That costs attention and time and the small discomfort of doubting an answer that already looks settled. The output, meanwhile, arrives finished. That is its trick. It looks like the end of the work, so the work does not get done. Why check what already looks checked.

So the answer becomes the felt truth. Not the read truth, not the tested truth. The felt one. It feels true because it is fluent and sourced and sitting right there looking complete, and feeling true is cheaper than being true. The person accepts it because accepting costs nothing and questioning costs effort, and effort is the one thing the fluent output is designed to make you feel you can skip.

This is the forming factor, and it deserves the name. The not thinking is not a lapse in an otherwise sound process. It is what builds the felt truth in the first place. Remove the laziness and there is no felt truth, there is just an unchecked output that someone still has to read. The laziness is load bearing. It is the thing that turns a plausible sentence into a believed one.

And grounding makes it worse, not better. A raw guess you might distrust on sight. A sourced answer you trust more, because now it looks retrieved, now it looks anchored to a real document. The authority on the surface went up. The truth underneath did not. Higher authority means lower felt need to check, so the better the system looks, the less anyone reads it. The retailer did everything right and produced a wrong number that was harder to doubt precisely because everything had been done right.

Output Becomes Data

The freeze does not vanish after it is believed. It gets written down, and the moment it is written down the logic reverses on itself.

This is the same move as the truth of people, run on machines instead of a room. There, a frozen definition propagated because each person inherited it already looking validated and so did not reread it. Here the definition is stored as a value and each system inherits it the same way, for the same reason. One is a shared floor a group defines its situation against. The other is a field in a dataset the next agent reads from. Same freeze, same missing reread, same thing hardening into ground. The room and the database are two scales of one failure.

An agent produced the ten percent. It goes into a report, into a field, with a label. Now look at it from inside the system, from the perspective of whoever reads it next. It is data. It is sitting in the dataset like every other value. And data is what you trust, data is the thing that got measured, so the number is true. Not because anyone checked it. Because it is there. The act of storing it is read as the act of proving it. The record certifies itself.

This is the challenge of the perspective, and it is worse than simple error, because from inside there is no way to tell a frozen interpretation from a measured fact. They occupy the field the same way. Same shape, same label, same authority. A value that was held against reality and a value that was a plausible continuation are indistinguishable once both are stored. So the observer infers the evaluation must have happened, because the thing is data, and data is the evaluated thing. The inference runs backward, from the storage to a proof that was never performed.

Set it against the definition. Truth is data plus evaluation against existence. The perspective collapses the two into one. It takes the data term and treats it as if it already contained the evaluation term, as if being written down were the same as being checked. It is not. Storage records that a value exists. It records nothing about whether that value was ever held against what exists. The proven number and the frozen guess are stored identically, so storage cannot be the proof, and yet from inside the perspective it is treated as exactly that.

Now the loop closes. It is truth because it is data. It is data because an agent put it down. The agent put it down by freezing a reading, not evaluating one. So the chain certifies itself and is checked against nothing. Every hop freezes and stores. A definition goes in, a record comes out, and the record feeds the next definition, and nowhere does anything get held against what exists.

Run it from the outside and you get the opposite reading of the same fact. Data interpreted is useless as no data. The value was never evaluated, so under the definition it carries no truth, and a field holding an unproven number is worse than an empty one, because the empty field claims nothing and this one claims to be measured. Anyone who has worked a product model knows the move. Data that reached you pre interpreted is not data you can act on. It is someone’s reading with a label, and the label is the whole problem.

Both readings are true at once, and that is the trap. From the outside the stored freeze is weaker than no data. From the inside it is self evidently true. The value got less proven and more trusted in the same motion, and it did it just by being written down.

What Was Always Yours

Go back to the retailer one last time and see how complete the setup was. Real documents. Working retrieval. Ground truth present and correct and found. Every part of the machine did its part.

And ten percent of new customers still became ten percent of people, and a person still carried it into a decision, because the one step that mattered was never the machine’s to do. You cannot validate against a thing that has no validity to give. The output was never a truth claim. It was a plausible continuation that happened to be about a delivery document, and treating it as a witness under oath is a category error the system cannot commit for you, because the system was never in the business of truth. It was in the business of what comes next.

The step is reading, and reading here means evaluation. Holding the output against the data, checking it against what exists, doing the work that turns a sentence into something proven or something discarded. That is where truth is made, and it was never the machine’s to make. It does not disappear because the system is grounded. It belongs to whoever reads next.

What the Data Points At Now

Follow where the stored value points. A number is supposed to point outward, at the thing it measures, at what exists. The stored ten percent does not. It points back at the reading that produced it, at the felt meaning that got written down and called a record. The reference broke. The number no longer refers to what happened in the world. It refers to an interpretation of what happened, and it points inward at that interpretation while wearing the face of a fact about the world.

So data now points at felt meaning. And once it does, the last defense falls, because validation was the thing that would have caught it, and validation is the first casualty of the laziness.

The not thinking does not merely skip validation. It obstructs it. A value that already looks validated makes checking feel redundant, and checking a thing that looks done reads almost as an insult to it. The laziness builds a wall in front of the one step that would have hit the error, and it builds that wall out of the value’s own finished appearance. The better the output looks, the more firmly validation is blocked.

And then validation itself changes state. It stops being an act and becomes a feeling. It is no longer something you do, holding the data against existence and confirming it. It is something you sense. The value feels validated, so validation is counted as done. It joined the felt truth. The check became a vibe. Nobody ran the evaluation, and nobody notices, because the feeling that it ran is sitting exactly where the evaluation used to be, doing a convincing impression of it.

This is the same amputation, seen on the reader’s side. The freeze becoming the truth of people and the freeze becoming self certifying data both need one thing to run: nobody rereads. And validation as a feeling is how the reread dies. The human who should hold the output against existence instead senses that it holds, and passes it on. The room hardens it into shared ground. The database hardens it into a field. Both are the same missing act, and once it is missing the freeze is free to become the floor.

You Can Aim True and Still Miss

Here is what all of it amounts to.

Say you know exactly where the target is. You know the question, you know that ten percent of what is the thing that matters, you are not lazy, you intend to check. Your aim is true. You still miss, and the reason is not your aim. It is everything you were handed to aim with.

Every instrument that was supposed to help you hit is interpretation of what was. The grounding is a reading of the document. The retrieved passage reached you through a probabilistic step. The stored record is a frozen interpretation. The graph, the ontology, the summary, all of it is what was, read and rendered, not what is. There is nothing in the whole apparatus that touches existence directly. It is interpretation the entire way down, and interpretation is the probabilistic side, the side that carries drift by construction. So the diligent reader aims at the true target through instruments that cannot deliver them to it, because the instruments are made of the same probable material as the answer.

This is why laziness was never the whole story. The lazy reader fails because they do not check. But the careful reader, the one who does check, checks against what. Against the grounding, which is interpretation. Against the record, which is interpretation. Against another output, which is interpretation. There is no clean surface under any of it to press the answer against. The material you would validate with is the same probabilistic reading you were trying to validate. You can run the check honestly and still confirm a drift against a drift.

That is the trouble hiding inside the word grounding. It sounds like contact with the real. It is one more interpretation of what was, handed to you as if it were what is. A system built entirely of interpretation cannot put you in touch with existence, no matter how well you aim, because at no point in it does anything get held against the thing itself.

The retailer built exactly that machine. It grounded, retrieved, stored, and certified itself, and every part worked, and the number was still wrong, and someone still believed it, and someone still built on it. Not because the machine failed. Because the machine was interpretation from end to end, and interpretation of what was is not evaluation against what is, and only the second one ever hits.

The target was always the same small thing. Ten percent of what. The document was read, and the reading was probable, and nobody held the reading against what actually happened.

By turn five, the agent is perfect. A customer asks about a billing charge. The agent pulls the account, explains the fee, offers a credit. Clean. The eval suite gave this exact flow a 94% score last quarter.

By turn 12, it has forgotten the customer’s name.

By turn 18, it contradicts the credit it offered six turns earlier.

By turn 23, it confidently recommends a plan the customer already cancelled, in this same conversation, out loud.

Nothing crashed. No error fired. No alert went to anyone’s phone. The system that scored 94% on Tuesday is the same system failing silently on Wednesday, mid session, in front of a real customer, and the eval suite will still say 94% next quarter because nobody built an eval for what actually happened [2].

This has a name now. Researchers call it agent drift: the progressive degradation of behavior, decision quality, and coherence over an extended interaction [1]. It has papers, metrics, a 12 dimension measurement framework, mitigation strategies with names like episodic memory consolidation and adaptive behavioral anchoring [1] [2]. It is not a rumor. It is quantified.

And here is the part almost nobody says in public: the industry knows. Every serious lab, every enterprise AI team, every person shipping an agent into production has read a version of the turn 12, turn 18, turn 23 story. The problem was never that people were naive about drift. The problem is that the fixes being deployed against it are aimed at the wrong thing entirely, and once you see why, you can’t unsee it.

The Compounding Math Nobody Wants to Say Out Loud

Start with the arithmetic, because it explains why point in time evals miss this so completely.

An agent pipeline has three components: an LLM call, a tool execution, a memory retrieval. Say each is individually reliable 90%, 85%, and 97% of the time. System reliability is not the average of those three numbers. It’s the product. Multiply them and you get 74%. That’s the static number, the one on the eval dashboard, the one in the sales deck [2].

Now add drift. Each component’s reliability decreases as the conversation gets longer. The LLM call drops from 90% to 80% by turn 20. Tool execution drops from 85% to 75%. Memory retrieval drops from 97% to 90%. Multiply those degraded numbers together and system reliability at turn 20 is 54%. A coin flip. From a system that scored 74% on the eval that got it approved for deployment [2].

This is why the demo always works and production always eventually doesn’t. Every demo runs on clean inputs, a cooperative tester, a defined scenario, five or six turns at most. That’s not dishonesty. That’s just what a demo is. But it means buyers are approving something they never watched fail, because the failure mode only shows up past the horizon the demo was built to cover.

5 Fixes, One Direction

Faced with this, the industry has thrown five things at the problem. Grounding and prompt engineering. Retrieval augmented generation. Graph based orchestration frameworks like LangGraph. Ontologies and knowledge graphs. Loop and reflection engineering, where an agent critiques and revises its own output before answering.

Look at what all five have in common. Every one of them is an intervention on the input side. Better prompts change what goes in at turn one. RAG changes what gets fetched and stuffed into context before generation. Orchestration frameworks change how the pieces are wired together and give you a pause button. Ontologies change the shape of the background knowledge the model can reach for. Loop engineering adds another pass of the same model looking at its own output before committing to it.

All five are answers to the question “what do we feed the model.” None of them are answers to the question “what is degrading inside the interaction as it continues.” That distinction sounds academic until you look closely at three of the five, because the same pattern shows up in each.

Take RAG. The field’s own literature describes 2023 era RAG as brittle and one shot, so the fix was to make it a loop: plan, retrieve, critique, rewrite, reflect, repeat until confident or out of budget [3]. That’s real progress against a narrow failure, missing context causing a hallucinated answer. But looping introduces its own version of drift. When a planner agent delegates a sub query to a retriever agent, the planner’s read of what’s needed can diverge from what the retriever can actually deliver. Without a hard stopping condition, the reformulation loop wanders, burning budget without converging on anything [4]. You didn’t remove the compounding failure. You relocated it one layer down, into the delegation between planner and retriever.

Take ontologies. Despite years of Graph RAG papers flooding every conference and major vendors publishing ontology grounded retrieval research, the share of organizations running knowledge graphs in production sat flat, 26% one year, 27% the next [5]. Flat, in the exact window when the hype was loudest. And ontologies drift too. The schema that defined what things mean stops matching the reality it was built to describe, the same problem one level up the stack. Worse, there’s a documented backfire: injecting ontological context can displace knowledge the model already carries internally, a context interference effect independently found by more than one study in 2026 [6]. Feeding the model more structure isn’t neutral. Sometimes it actively pushes out something useful that was already there.

Take orchestration. LangGraph’s real contribution is legibility, explicit state and transitions instead of a hidden chain, plus the ability to pause execution for a human check [3]. That’s genuinely valuable. It is not the same thing as fixing the degradation happening inside each node. A clearer map of where the car broke down is not a repair.

Grounding and prompt engineering, and loop engineering, follow the identical pattern without needing their own case study. Better prompts lower the error rate at the first turn and say nothing about turn twenty. A reflection loop adds another pass of the same underlying model checking its own output, which multiplies the number of components that can degrade rather than removing the degradation from any one of them. Three examples are enough to see the shape. All five are the same shape.

The Category the Fixes Never Reach

Here’s the sentence that actually explains why none of this closes the gap. One paper studying instruction drift put it plainly: current systems still cannot behave coherently over long horizons, and the reason is a mismatch between how they were trained, text continuation, single round human feedback, and how they’re deployed, open ended dialog across dozens or hundreds of turns [7].

Read that again. The cause is not insufficient context. The cause is that the objective the model was optimized against was never built for the situation it’s being asked to hold up in. No input you feed at inference time touches what the model was trained to be stable about, because stability across a long horizon was never the thing being optimized in the first place.

There’s a more radical version of this same critique, and it’s worth sitting with. Some researchers argue that LLMs do not optimize over task related objective functions at all, meaning there is no persistent goal being pursued turn over turn, only a fresh reconstruction generated from whatever context exists right now [8]. If that’s right, then calling these systems agents pursuing something across a session is already the wrong frame. Drift isn’t a bug in an otherwise goal directed system. It’s the expected behavior of a system with no actual goal directedness to drift away from.

This is the category error. Grounding, RAG, orchestration, ontologies, loop engineering, every one of them assumes the problem lives in the category of information availability and architecture. The researchers who’ve actually traced the mechanism keep locating it one category over, in what the model was ever trained to hold stable, or in whether there’s a persistent thing there to hold stable at all. You cannot fix a training objective mismatch by getting better at feeding inputs to the object that has the mismatch. That’s not a harder version of the same fix. It’s a different fix, for a different kind of problem, and almost nothing being shipped commercially works at that level.

Vectors Are Not Meaning

Underneath the category error sits something older and harder to argue with, which is that probability and vector closeness were never built to carry meaning in the first place.

An embedding is a position in a space built from co-occurrence statistics. Words that show up in similar contexts get vectors that sit close together. That’s the entire mechanism. It’s a formalization of an old idea from structural linguistics, you shall know a word by the company it keeps, decades before embeddings existed as a technique [10] [17].

But closeness in that space tracks how words pattern with other words. It does not track what the words refer to. Consider what happens when a person writes “snow is white.” That sentence, for the person who wrote it, is tied to an actual causal history: seeing snow, feeling how cold it is, noticing how it looks different under different light. The person’s neural states have a real causal connection to snow, not merely to descriptions of snow [9]. A model trained on that sentence has only ever had the description. It has never had the snow.

There’s an honest name for what these systems do instead of solving this problem: epistemic parasitism. They operate entirely on content that human beings already grounded through embodied experience and lived interaction with the world, and they inherit the shape of that grounding without ever performing it themselves [9]. That’s not a small caveat. It means whatever meaning shows up in a model’s output is borrowed, not maintained. The system has no independent way to notice when its borrowed meanings have stopped matching current reality, because noticing that requires a channel back to the world that the architecture was never given.

Why Wittgenstein Gets Reached For

At this point someone always raises Wittgenstein. Meaning is use, he said [11]. A word means what it does because of its role in a shared practice, a language game, not because it corresponds to some object out there. On a fast read, this sounds like exactly what distributional embeddings already do. You shall know a word by the company it keeps is meaning as use, formalized as a training objective before the term embedding existed [10].

This is why AI developers reach for Wittgenstein specifically, and it is worth being blunt about why. His slogan can be quoted in a way that validates work already shipped. It doesn’t require changing a line of code. Citing Wittgenstein lets someone say our existing technique already is a theory of meaning, a serious philosopher agrees, without touching the pipeline at all. Mead offers no equivalent shortcut. There is no slogan sized version of his actual claim, that meaning requires role taking and a self modified by an answered response, that flatters a static embedding table. So one gets adopted and the other gets skipped, and the selection has nothing to do with which theory is right.

But even the half of Wittgenstein that gets imported is only half of him. His “use” was never a frozen record of prior instances. It depended on a community that already agrees closely enough, in judgment and reaction, that a wrong use shows up as wrong against that shared background, in the case in front of them, right now. Wittgenstein does not explain where that background agreement comes from. He treats it as bedrock, the given his account stops at. But bedrock or not, it is still doing work: it is what lets a use be caught as mistaken at all. That’s exactly the part that cannot survive being trained into weights, because a corpus can only hand a model settled, completed instances of use, not the living background of shared judgment those instances were checked against. What gets imported into these systems is use theory with its one indispensable background condition quietly removed, and the result gets called an application of the theory when it’s closer to a selective quotation of it.

What Mead Actually Requires

George Herbert Mead’s account is harder to borrow from, which is exactly why it’s more useful here.

A gesture becomes a meaningful symbol, on Mead’s account, only when it calls out the same response in the person making it as it does in the person it’s addressed to [12]. That requires role taking: imagining the other’s position, anticipating their response, adjusting before acting, and then actually receiving their real response and folding it back into what you do next. Meaning, on this view, does not live inside the symbol at all. It lives in the completed loop between two parties, checked against how the other actually answers [12].

Herbert Blumer distilled this into three claims. People act toward things based on the meaning those things hold for them. That meaning arises out of social interaction, not from the object itself and not from a private mental act either. And meaning gets handled and revised through an interpretive process in the act of dealing with what’s encountered, not fixed once and looked up afterward [13].

This is where the table example does real work. A table means something different to the carpenter who built it, the family eating dinner on it, the mover carrying it up three flights of stairs, the child using it as a fort. None of those meanings is more correct than the others. Each one was made, in real time, by a specific party in a specific interaction, shaped by norms and culture and the language that party grew up inside. There is no single essence of table waiting underneath all of that for one universal model to capture. Trying to standardize meaning is not a shortcut around this variation. It’s a category mistake about what meaning is.

Which raises the obvious question about Wittgenstein’s community and Mead’s interaction. Are these the same idea twice? No, and the difference matters. Wittgenstein’s community is bedrock, the given, the thing his account of language stops at and does not explain further. It manifests a common ground that’s already there. Mead is not manifesting anything. He’s describing how a shared standard gets built at all, through the accumulated history of taking other people’s roles until something like a generalized sense of the community forms inside a person. Wittgenstein posits the common. Mead explains how meaning gets made without there ever being one single common ground to begin with, because different interactional histories produce different, genuinely incompatible meanings, not local noise around one shared truth.

Freeze, Unfreeze, Freeze

Put Mead’s cycle in its plainest form and it looks like this. Meaning starts as a live act, a gesture, an interaction actually happening. Call that the verb. That act gets crystallized into something nameable and portable, a stable symbol you can hand around. Call that the noun. But the noun only stays meaningful if it gets taken back up into a new live act, tested, adjusted, sometimes broken and remade. Verb again. Meaning survives by continuously re-entering the verb form. The moment it just sits as a noun, referred to instead of enacted, it’s dead weight.

Training is the freeze. An enormous population of completed verb noun verb cycles, millions of actual human interactions, gets crystallized into static weights. This step is legitimate. You cannot train on a live process, only on what it left behind.

For meaning to persist past that point, the frozen residue has to be taken back up into a real act. Tested against an actual other. Genuinely revised by what comes back. Call this the unfreeze. It’s the step Mead’s entire account depends on.

What happens at inference instead is that the frozen state gets applied, turn after turn, replayed against new input and re-crystallized as output. It looks like a conversation. Turns are being taken. But nothing that happens revises the underlying state itself. Freeze, then the appearance of a verb, then freeze again, with the middle step hollowed out. The system performs every visible stage of the cycle except the one that does the actual meaning making work, and it performs the surrounding stages convincingly enough that the missing one goes unnoticed unless you name the cycle out loud.

Every fix discussed earlier is an investment in the freeze. Bigger models freeze more precisely. Better retrieval feeds the freeze fresher material. More structured ontologies organize what the freeze can reach. None of it touches the unfreeze, because the unfreeze was never a resolution problem. It’s an architectural commitment to a persistent, answerable, revisable state, and that is a different kind of thing to build than a better estimator over already completed acts.

Whose Meaning Gets to Be the Default

There’s a final piece, and it follows directly from the freeze. If meaning is practice dependent, made differently inside different communities, then the freeze was never freezing one neutral thing. It was freezing whichever community’s meanings happened to dominate the training data and the feedback used to shape it. That’s a documented property of how these systems get trained, not a side detail.

Standard reinforcement learning from human feedback aggregates preferences from many annotators into one reward model. This isn’t a neutral averaging. It’s been formally shown that this aggregation follows a Borda count, a specific voting rule that systematically underweights minority preferences [14]. Disagreement about what a good answer even looks like, which is often disagreement about what something means, gets treated as noise to be smoothed rather than as legitimate value pluralism to be represented [15]. Research spanning 75 countries has found that these preferences genuinely diverge by culture and language, not converging toward one universal answer waiting to be discovered [16].

The reason this keeps happening is not that developers fail to see it. Several of them have written the critique in nearly these words [15]. The reason is that one model serving everyone is the entire economic proposition. A distinct reward function per community multiplies cost. But there is a second reason, and it’s less comfortable. Whoever’s median gets encoded as the aligned, helpful answer also gets to present one community’s meaning making as neutral and universal, while everyone whose meaning diverges from that median experiences the model as either wrong or as quietly correcting them toward the standard. That’s not a side effect of scale. It’s what makes scale valuable to control. Neither the incentive to fix this nor the incentive to disclose it points toward fixing it, regardless of anyone’s private intentions.

Where This Leaves the Question

Meaning is not context dependent, if context means information you can hand to a system. The evidence for this sits inside the industry’s own failures. Injecting more ontological context has been shown to displace knowledge a model already carries. Iterative retrieval loops wander without converging even as they consume more and more surrounding material. If meaning were a matter of sufficient context, neither result should be possible. More relevant information should never make things worse. That it does is the clearest sign available that supplying context and supplying meaning are not the same operation at all.

Meaning is practice dependent. It requires being a participant in an ongoing, corrective, answerable relationship with others, not a recipient of an ever larger pile of material about that relationship. Every technique currently being deployed against agent drift, grounding, retrieval, orchestration, ontologies, reflection loops, is a way of freezing more carefully. None of them are a way of unfreezing. And even a working unfreeze would still face the harder question sitting underneath it, whose practice, whose community, whose corrections a model is actually answerable to, since the freeze already picked a side on that question before anyone asked. Until both of those are taken seriously as architectural and not just philosophical requirements, the industry will keep shipping better freezes, calling the result progress, and rediscovering the same silent failure at turn 12, turn 18, turn 23, in front of the next customer, on the next system that scored 94% the day before it mattered.

Want to read more from Sebastian Thielke? Search the substack here and find where human in meaning started. You could go for sebastianthielke.com as well and explores topics and IPs over there as well. Have fun.

Sources

1. Rath, A. “Agent Drift: Quantifying Behavioral Degradation in Multi-Agent LLM Systems Over Extended Interactions.” arXiv:2601.04170, January 2026.

2. “Agent Drift: Why Your AI Gets Worse the Longer It Runs.” Chanl Blog, March 2026.

3. Rane, V. “Next-Generation Agentic RAG with LangGraph (2026 Edition).” Medium, March 2026.

4. “SoK: Agentic Retrieval-Augmented Generation (RAG): Taxonomy, Architectures, Evaluation, and Research Directions.” arXiv:2603.07379.

5. Shereshevsky, A. “Ontology Drift: Why Your Knowledge Graph Is Slowly Going Wrong.” Graph Praxis, Medium, February 2026. (26%/27% production adoption figures originally from a Google Cloud survey, as cited in this piece.)

6. “Research Brief: Ontologies for Agentic AI (2025 to 2026).” designpattern.fyi.

7. “Measuring and Controlling Instruction (In)Stability in Language Model Dialogs.” arXiv:2402.10962, February 2024. Note: this paper predates the 2026 agent-drift literature discussed above; it’s cited here specifically for its training/deployment mismatch argument, which the later work echoes.

8. “Human-in-the-Loop Control of Objective Drift in LLM-Assisted Computer Science Education.” arXiv:2604.00281.

9. “A Categorical Analysis of Large Language Models and Why LLMs Circumvent the Symbol Grounding Problem.” arXiv:2512.09117, December 2025.

10. Coelho Mollo, D. “The Vector Grounding Problem.” arXiv:2304.01481, April 2023.

11. Wittgenstein, L. Philosophical Investigations. 1953.

12. Mead, G.H. Mind, Self, and Society. University of Chicago Press, 1934.

13. Blumer, H. Symbolic Interactionism: Perspective and Method. University of California Press, 1969.

14. “Adaptive Pluralistic Alignment: A pipeline for dynamic artificial democracy.” arXiv:2605.01642, June 2026. (Formalization of RLHF as Borda count aggregation originally due to Siththaranjan et al., 2023.)

15. “Relative Principals, Pluralistic Alignment, and the Structural Value Alignment Problem.” arXiv:2604.20805.

16. “Hidden Consensus: Preference-Validity Compression in Human Feedback.” arXiv:2606.10569. (Citing Kirk et al., 2024, on cross-country preference variation.)

17. Firth, J.R. “A Synopsis of Linguistic Theory, 1930 to 1955.” In Studies in Linguistic Analysis, 1957. Source of “you shall know a word by the company it keeps,” referenced via Coelho Mollo (source 10), which cites Firth 1957 and Harris 1954 for the distributional hypothesis.

A probabilistic system cannot hold meaning. It can only guess, well or badly, against a distribution that has no fixed point in it, which means drift is not a risk it runs but a property it ships with. The only thing that holds meaning is a human, standing in a situation with stakes, regenerating judgment as the situation moves. That claim, argued in full elsewhere, has one direct consequence for how an organization staffs and structures itself once agents are doing the execution: the organization has to be built around where meaning is actually held, not around where work gets done, because work is now cheap and holding is not. This piece is that consequence, worked out as an organization you could actually build and staff.

The founding decision

A classical product organization is an execution pyramid with meaning smeared thinly across the top. Hundreds of people execute, a handful decide what anything is for, and the whole structure exists because execution used to be the expensive part. Coordination layers, management layers, quality layers, all of them are machinery for getting slow unreliable execution to add up.

Agents removed the premise. Execution is now the agent mesh, abundant and fast and cheap. What did not become abundant is the one thing agents cannot do: stand in a situation with stakes and regenerate judgment as the situation moves. Meaning stayed scarce while execution became free, and an organization built for the old scarcity is wrong in every joint.

So the founding decision inverts the pyramid. The permanent structure of this organization exists to hold meaning, and only to hold meaning. Execution is rented from the mesh. Construction is rented from crews that form and dissolve. The permanent headcount formula is brutally short: one owner per live agent product, plus the contract engineering function, plus whoever currently holds the interpretive side of stewardship, which as the next section explains is deliberately not a chair on the chart. You do not staff to agent count. You staff to concurrent live ownerships, and that number is a decision the stewarding of the portfolio produces, not an outcome growth imposes on you.

Three roles and one holding

The organization has four kinds of work. Three of them are roles. The fourth deliberately is not, and the reason it is not carries half the design.

The Owner. One person, one agent product, one tenure. This is the Human in Meaning for that product, and the job description is the verb itself: develop, measure, pivot, kill, judged against reliability, lovability, feasibility.

The working day looks like this. The owner stands in the situation where the product’s production lands. With customers, inside consequences, reading what the production did to the world by being a participant in that world. They regenerate the eight variables of the meaning holder as the situation moves: customer, problem, solution, adoption, experience, reliability, lovability, feasibility. When the agent surfaces its one judgment question, the owner answers it, because that question was assembled precisely for a meaning holder and nobody else can answer it. When the agent proposes a drift revision with evidence attached, the owner stewards the revision, at their own speed, while nothing stops.

What an owner never does is just as defining. No approving agent steps. No watching dashboards as a substitute for standing. No status meetings about their own product, because status is what traces are for and owners read traces, not slides about traces. The role has no reports. The mesh is the team.

Stewardship. Somebody has to read the organisation’s whole pattern of owning. Whether what gets developed is worth developing. Whether what should be dying is being kept alive past the point where it serves anyone. Whether the collection coheres, where allocation goes, where products overlap or leave gaps. And the boundary watch, the ongoing catching of components that have quietly started facing situations, forcing the decision each time: promote to product or push back behind the contract. This reading runs the same loop ownership runs, against the same three dimensions, moved up a scope. Reliability becomes whether the owners actually run their loops instead of holding titles. Lovability becomes whether owners want to own what they own, under conditions a person can do honest work inside. Feasibility becomes whether the pattern sustains itself with the resources the organisation has, whether the pace of building is matched by the pace of understanding.

This is not a standing watchtower, and that distinction is the whole point. Stewardship is what ownership becomes at the moment carrying is required. A tenure ends, an owner moves on, a component crosses the boundary, and ownership precipitates into stewardship, holds across the gap, and dissolves back into ownership on the other side with the work intact rather than reconstructed from documents. The pattern reading and the crossing are the same verb. The reading is what makes the crossing more than a handover, and the crossing is where the reading does its work, refounding the standard each new owner is held to so it reflects what the last several owners learned rather than what was true when the role was first written. Draw stewardship as a permanent monitoring function and you have rebuilt the senior seat the next paragraph rejects.

The obvious move is to make this a senior role, and the obvious move fails structurally. A senior steward has a tenure. The tenure ends, the pattern they were holding leaves with them, and the problem stewardship exists to solve reasserts itself one scope up, slower and harder to attribute. The deeper reason is that no single person can be close enough to the whole pattern to read it honestly. The patterns live across owners, across products, across the months and years it takes for drift to become visible. A person can be close to part of that. Nobody can be close to all of it.

So stewardship is held by a combination, not staffed as a position, and the agent is what keeps the form momentary instead of letting it harden into the seat. Agents carry the continuity across every human transition: every owner’s kills, pivots, and continues, the conditions each owner was reading, the calls each owner made, surfaced as patterns across all of them. Humans hold the interpretation of what the continuity is showing, because interpretation is what humans do and an agent has no stakes to read with. Without the agent, the humans have no reach across the time horizons stewardship operates over, and the role reverts to the tenure bound senior seat. Without the humans, the precipitates accumulate against nothing. Where exactly those interpreting humans sit, and how the holding avoids hardening into the senior position that would collapse it, is the one question this design leaves deliberately open, because resolving it with a box on a chart would repeat the exact mistake the structure exists to avoid.

Whoever is interpreting never reaches into a product’s meaning. Composition, not derivation. Nothing cascades downward from the pattern scope into a product’s holder, because inherited meaning is frozen meaning and the architecture forbids it. This is also where new products are conceived. When the stewarding read says an outcome exists that nobody owns, that reading becomes a signal, and the birth process starts.

The Contract Engineers. The classical engineering function survives here intact, because components are supposed to be frozen. This group builds and hardens the interfaces, owns the specs, runs the infrastructure the mesh stands on. Their craft is the old mandate: narrow promises, no shared state, no backdoors, every interface designed as if its consumer were external. They are deliberately not meaning holders and their artifacts are deliberately nouns. That is not a lesser role. It is the half of the architecture where freezing is correct, and the quality of everything else depends on how still they can hold the world behind their contracts.

The Build Crews. Nothing in this organization has a standing development team. When a meaning holder needs something built, a new product incepted, a pivot executed, a promoted component rebuilt as a product, the need is expressed as a signal: a precise description of what needs doing, what it is for, and until when it exists. A crew forms around the signal, human specialists and agents together. It does the work. It dissolves. No permanent overhead, no idle capacity being paid to exist, no team identity that outlives its purpose and starts defending itself. The owner does not manage the crew. The owner holds the meaning the crew builds against, which is the holder itself, and the holder is readable by everyone the signal assembled.

How a product is born

The working backwards process runs, and it runs for real. A press release, about a page, answering the five questions from the customer’s side. Who is the customer. What is their problem or opportunity. What is the solution. Would they reasonably adopt it, since every new product asks for a behavior change. What does the experience look like. Behind it the FAQ, carrying the harder questions the organization must ask itself. The fights this document provokes are the cheapest fights the organization will ever have, because they happen before anything is built.

One activation condition gates the birth, and it is a triple test. The customer wins, or there is no product. The business wins, or there is no viability. The talent forming around it wins, or the crew you assemble is building something that burns them for nothing. If you cannot articulate all three wins, you have research or a demo, and research is fine, but it does not activate this organization.

Then comes the move the original method never made. The approved product definition does not recede into a repository as a signed gate. Its five answers plus the viability triangle become the live variables of the meaning holder, which holds the aim, not the meaning, since the meaning is the verb the owner keeps enacting. An owner takes tenure. A crew forms on the signal. And from the first day of production, the agent reads the holder at runtime, every run, binary: this is the current aim, therefore I use it. Inception is the only moment in the whole lifecycle where gate and holder are the same object. After that the gate is gone and only the holder remains, its aim reset by the owner as the situation moves, for as long as the product lives, until pivot moves it or kill ends it, both of which are states of the holder and not meetings.

How it runs, told mostly through absences

There is no PMO. There is no QA gate on agent output, because verification lives where it always had to live, in the owner’s reading of consequences inside the situation. There is no AI oversight board, no human in the loop checkpoint anywhere in the execution path, no approval chain between an agent and its production. There are no status rituals. There is no quarterly planning theater, because meaning regenerates when the situation moves, not when the calendar says so.

The two loops run at their own speeds and neither waits for the other. Agents at machine speed against the holders. Owners at meaning speed against the situations. The classical management layer has almost nothing left to do in this picture, and that is the point, because almost everything classical management does is interference dressed as diligence, built for an execution scarcity that no longer exists.

What coordination remains is real and small. The stewarding of the pattern, agents surfacing it and humans interpreting it. The signal mechanism that forms and dissolves crews. And one periodic discipline that survives from the doctrine: pattern verification. At intervals, each owner verifies that the grounded patterns their agent acts on in fit mode still deserve their grounding, by standing in the raw situation and checking the pattern against it. That is a scheduled act of standing. It is not a scheduled meeting.

Transitions

Most organizations quietly die at transitions. Tenure ends, a person leaves, and what the documents could not hold leaves with them. This organization treats every such moment as a stewardship crossing rather than a handover meeting.

Ownership precipitates into its carried form. The agent carries the precipitates across the crossing: the patterns, the traces, the kills and pivots and continues, the conditions the outgoing owner was reading, the calls they made. The incoming owner receives this not as documentation they might read but as live input to their first loop, the previous owner’s learning arriving as conditions rather than artefacts, and thaws it the only way meaning ever thaws, by standing in the situation until their own reading resumes the verb. The work compounds across people instead of resetting with each one. The agent made the crossing operable. It never held anything in the meaning sense, because carrying is data movement and holding requires stakes.

Component promotion runs through the same shape. Stewardship catches a boundary crossing, some component has started facing a situation on a frozen spec. A signal forms. A crew gives the component a holder and a first owner, or forces it back behind its contract. Either way the crossing is momentary. Stewardship never gets an office, never becomes a council, never ossifies into a layer, because the moment it does, the verb it exists to carry has been frozen into furniture.

The craft ladder, drawn carefully

Hierarchy will try to sneak back into this organization through the question of seniority, so the ladder has to be drawn with the same discipline as everything else.

The scarce skill here is not prompting, not architecture, not even product sense in the classical sense. It is the capacity to hold meaning: to stand in a situation with real stakes and regenerate honest judgment at the speed the situation moves, over and over, without retreating into the comfort of nouns. People grow into that capacity the only way the definition allows, by being participants. The natural path runs from build crew work, where you touch situations under someone else’s held meaning and watch a holder being regenerated up close, to ownership, where you hold your own.

Stewardship is not a promotion above ownership. It is a different kind of holding, the pattern instead of a product, and drawing it as a rank would collapse it into exactly the tenure bound senior role it exists to escape. Standing in this organization follows the record of the verb: tenures held, situations read well, products developed and measured and pivoted and killed honestly. Nobody accumulates headcount, because there is no headcount to accumulate. The old currencies of organizational power were budgets and reports. The only currency here is a track record of holding meaning well, and it is the one currency that cannot be inherited, delegated, or faked for long, because the situation itself audits it.

The arithmetic

Make it concrete. Take a mesh of forty agents, of which five face situations and own outcomes. The permanent organization is five owners and a contract engineering group sized to the interface surface, perhaps six to eight people, plus the human who holds the interpretive side of stewardship, a seat that is real but deliberately not a chair. What the design leaves open is where that human sits, whether the owners hold the pattern together or someone holds it apart from them. What the design does not leave open is that it is human and that it is not a standing senior role, because the moment it becomes either an agent or a permanent rank it collapses. Call it roughly a dozen people running what a classical organization would surround with a hundred.

The ratio is not the headline. What matters is what the dozen do all day. They stand in situations and hold meaning, and they do nothing else, because everything else has been handed to the mesh or refused permission to exist. A hundred person version of the same organization would not buy more safety or more control. It would move slower where speed was the point and understand less where understanding was, piling interference on top of starvation, and drifting the whole time it looked busy.

What this organization is betting on

Every organizational design is a bet on where failure comes from. The classical design bets that failure comes from execution: people build the wrong thing, build it badly, build it slowly, and so it stacks inspectors on builders. This design bets that failure now comes from meaning: production runs perfectly against definitions that quietly stopped matching the world, and no inspector catches that, because inspection is noun processing and the drift is in the verb.

If the bet is right, a dozen people who keep meaning genuinely held will outrun a hundred who only supervise execution. Those dozen stand where production lands, they hold what the agents read, and they raise crews when a signal fires and let them go when the work is done. What is permanent in the organization is there to hold meaning. The rest is meant to move.

Want to read more from Sebastian Thielke and System Decoder? Search here on Substack and find a selection of posts (specifically the latest ones) at sebastianthielke.com.

Every product organization I have seen, including the good ones, runs on a single profession. Ownership. One person, one product, accountable for it from launch to shutdown, developing it, measuring it, pivoting it, ending it when it stops earning its place. That much is right, and companies that get even this far are ahead of most. But it’s only half the organization. Most never build the other half, and they run for years on one leg, calling the limp normal because nobody around them walks any differently.

The missing half is stewardship. My claim about it is easy to agree with in the abstract and harder to actually build: an owner who gets senior does not start doing stewardship as a natural next step. Stewardship is a separate trade, and its job is not to watch owners from above. Its job is to keep ownership itself alive through everything that would otherwise break it: an owner learning something and changing course, an owner leaving, a product moving to someone new, the market shifting under a product mid tenure. A product organization needs people doing both jobs, at the same time, or the organization quietly stops adapting while every individual product still looks fine in isolation.

What an owner actually answers for

An owner is accountable for one product. They watch the market, the usage, the complaints, the numbers, and they carry a current answer to whether this thing is still worth running and in what shape. The answer changes, the product changes with it. The answer turns to no, they end it. This has to be done by someone close enough to feel the wrongness before the dashboard confirms it, which is why it can’t be handed to an outsider glancing in periodically. Proximity is the method, not a nice extra layered around it.

That method works because its scope is bounded. A person can genuinely be close to one product. Nobody can be close to forty of them, and nobody can be close to what happens across an entire company every time one of those forty changes hands. That second thing is real work, and it isn’t a bigger version of the first job scaled up.

What a steward actually guarantees

A steward’s job is to keep ownership active. Not to check whether it’s active, to make sure it stays active, through every change that would otherwise interrupt it.

An owner learns something on the job, a real insight about the market or the product, and acts on it. That learning has to survive the owner eventually moving on, or the organization paid for the lesson once and will pay for it again with the next person. An owner leaves, gets promoted, gets reassigned, and someone new steps into the product. The new owner has to start from what the last one actually knew, not from a blank page. A market shifts underneath a product mid tenure, and the organization has to adapt its sense of what that product is for, not wait for the next owner to rediscover the shift from scratch. Every one of these is a place where ownership could break, reset to zero, lose what it had built. Stewardship is what makes it not break there. It’s the guarantee that ownership keeps moving forward across the exact moments that would otherwise stop it.

This is different work from what an owner does, not more of it. The owner holds one product steady in the present. The steward makes sure the thread of ownership itself doesn’t snap as the people and conditions around it change.

Why a senior title doesn’t solve it

Once this second job is visible, the instinct is to hand it to someone senior. A head of product, someone whose title implies they sit above everyone else. It doesn’t work, and the reason isn’t about picking the wrong person for the role.

Give the job to one person and they inherit a tenure the same way an owner does. When that tenure ends, whatever they were carrying, the live sense of which handoffs went well, which owners’ learning actually made it to the next person, where continuity had already started to fray, leaves the building with them. Whoever comes next gets the artifacts, the handbook, the review deck, none of which was ever the thing that kept ownership moving. From there they have two bad options. Rebuild their own read of the organization from scratch, which takes years and breaks again the moment they leave. Or trust the inherited documents as current, which is worse, because the gap between what’s written and what’s actually happening keeps widening without anyone noticing.

This is a familiar story in companies that have been around a while. A new leader arrives, inherits a stack of frameworks left by the last one, and finds every one of them a little off. Not wrong when they were written. Off now, because the organization kept moving and the frameworks stayed where they were set down. The leader isn’t the problem. The structure was always going to produce this outcome for anyone standing in that spot.

The deeper issue sits underneath the tenure problem. Keeping ownership alive across an entire company means being present at every handoff, every shift, every moment an owner’s learning needs to travel to the next person, spread across dozens of products and years of turnover. That’s bigger than what any single person can track, the same way one owner can be close to a product but not to forty of them. Fixing this by finding a sharper person doesn’t work, because the job asks for a kind of presence that exceeds what one set of eyes can sustain, no matter whose eyes they are.

Where the work actually happens

Stewardship isn’t a standing watchtower, and it isn’t a committee convened to review the state of things. Give either of those setups nothing specific to guarantee and they turn into a room full of opinions, fast, disconnected from whether ownership is actually surviving its transitions.

The real work shows up at the moments ownership is exposed. An owner’s tenure ends and someone new takes the product. An owner has just learned something that changes what the product should be, and that learning needs to travel further than one person’s memory. A market has shifted and the organization’s working sense of the product needs to move with it before the next owner has to rediscover the shift the hard way. At each of these, the job is concrete: catch that the moment has arrived, and carry what’s real, the actual learning, not the paperwork, into whatever comes next, so the thread doesn’t snap.

Handled well, this changes what a transition costs the company. Handled badly, or not at all, every transition quietly resets to zero, and an organization built from enough resets never compounds anything it has learned, regardless of how good any single owner happened to be.

The agent question

The scale problem from the last section has one answer, and it isn’t a sharper person. Being present at every handoff across dozens of products and years of turnover is not a size of job a human grows into. It’s a size of job that needs something other than a human doing the tracking, which is exactly where an agent belongs in this picture, and exactly where the current habit of talking about it goes wrong.

There’s a habit now of reaching for the word agent whenever a job involves tracking a lot of things at once and carrying more across time than one person can hold. Stewardship gets described this way constantly: put an agent on it, let the agent carry the continuity between owners. The habit gets the mechanics roughly right and the job title wrong, and the wrongness matters more than it looks.

What an agent can hold is real. The full record of what an owner tried, learned, and decided, available on demand instead of trapped in someone’s memory or buried in a document nobody reopens, ready to hand to whoever steps in next. That covers exactly the scale problem described above, being present at every handoff across an entire company, and nothing about carrying a record that large is beyond a system built to retrieve and connect it.

What an agent cannot do is the part that actually makes stewardship a job rather than a database. Carrying the record isn’t the guarantee. Making sure the organization actually adapts on the strength of it is the guarantee, and that takes judgment nobody can outsource: deciding that a market shift is real and not noise, deciding that an owner’s new insight should change what the next person inherits, deciding when a handoff needs a human hand on it and not just a file transfer. That kind of call requires standing behind the answer, being the one whose decision it was if it turns out wrong, having something real riding on getting it right. An agent risks nothing on a wrong call. It doesn’t answer to anyone, doesn’t carry the outcome into its own future, has no place for the consequence to land.

Calling this an agent’s job isn’t a minor labeling error. It quietly relocates the accountable part of the work onto something structurally incapable of being held accountable, and once that shift happens, nobody notices that ownership has actually stopped adapting, because the record still looks complete and the process still hums along.

Split the labor honestly and it’s simple. The agent carries the record. The steward makes sure the organization moves on the strength of it. Not the same role at different volumes, two different kinds of work, and only one of them can be done by something with nothing on the line.

What this asks of how a company is built

If ownership and stewardship are genuinely two different jobs, the second one is not solved by finding the right person and giving them a title. It’s solved architecturally, or it isn’t solved at all, because a human alone cannot reach far enough to do what stewardship requires, no matter how conscientious they are. Without an agent carrying the record across every transition, stewardship at that scale has exactly two ways to go, and both are the failure this piece already described: it collapses into a senior role with a tenure of its own, or it just doesn’t happen, and every handoff quietly resets to zero. A small team can sometimes fake this for a while through direct conversation and a few people’s memory, which is why the problem stays invisible in young or small organizations. It stops being fakeable the moment there are more products and more turnover than a handful of people can carry in their heads, which is most organizations past a certain size. Stewardship does not exist at that scale without the agent underneath it. That’s not an optional extra sitting on top of the architecture. It’s the only thing that makes the job possible at all.

What still has to be human is the part described above: deciding that a shift is real, deciding an owner’s learning should change what the next person inherits, standing behind that call. The agent makes the reach possible. It does not make the judgment, and an organization that skips building the human side, treating the agent’s presence as the whole solution, ends up with a system that carries a perfect record and adapts to none of it, because nobody was ever going to make the call except the agent, and the agent can’t.

Stewardship isn’t a rung on the ownership ladder, and treating it that way just rebuilds the senior title failure under a nicer job description. It’s its own discipline: being present at the moments ownership changes hands or changes course, and making sure what was learned actually travels instead of evaporating with whoever learned it. A product organization built around the product itself needs both jobs running at once to actually function. One holds a product steady in the present. The other keeps ownership itself moving forward through everyone who ever holds it. Neither one covers for the other, and neither one is a job you can quietly hand to an agent because the agent happens to remember everything.

Want to read more from Sebastian Thielke and System Decoder? Search here on Substack and find a selection of posts (specifically the latest ones) at sebastianthielke.com.

A friend told me a while back that a certain interview of mine would have gone better if I’d used AI to knock out a working prototype instead of just bringing slides and notes. The comment stuck with me afterward, and not really because of the interview itself. It got me wondering what we’re all doing lately whenever we reach for a tool that can produce something in minutes, and what we quietly skip doing once we have it.

The tools are genuinely good. You can describe what you want in plain sentences and get something that runs before you’ve finished your coffee. People have started calling this vibe coding, half as a joke and half seriously, and there’s real value in it. It shrinks the gap between having a half formed idea and having something you can actually click through and argue with. That’s not nothing. It’s closer to a sketchpad than a piece of engineering, and a sketchpad is a genuinely useful thing to own. I use these tools myself, often, and I’m not about to pretend they haven’t changed how quickly I can test a rough idea before deciding whether it deserves more of my time.

But a sketch tells you something can exist. It doesn’t tell you whether it should, and it definitely doesn’t tell you whether the person sketching understood the terrain well enough for the thing to survive contact with reality. Those used to be two separate steps, done at different speeds, often by different people with different incentives. What’s changed isn’t that the second step got easier. It’s that the first step got so fast and so visually convincing that a lot of people stopped noticing the second step was ever there at all.

Here’s what I mean, with an actual case that’s been sitting in the news for a few weeks now.

Starbucks and the software bill

Starbucks spends about four hundred million dollars a year on software. Earlier this year leadership decided a decent chunk of that could be cut by building AI generated replacements for tools it currently buys, an inventory tracking system from Microsoft among them, a maintenance platform from IBM. The company’s own CTO told employees there were clear opportunities to reduce the spend.

I keep coming back to that phrase because of where it starts. It doesn’t start with a store manager complaining that the inventory system misses things. It doesn’t start with a documented workflow problem anyone bothered to write down. It starts with a number that was big and visible on a spreadsheet, and the systems chosen for replacement got chosen mostly because they were expensive, not because anyone proved the company had actually outgrown them.

Software spend and domain knowledge sit in different categories even though they end up on the same page of the same annual report, and this is the part that gets lost. You can see spend. You can point at it and reduce it. Domain knowledge, the sort of thing a vendor picks up over years of running inventory software across thousands of different stores and absorbing every strange failure those stores throw at it, doesn’t show up as a line anywhere. Nobody puts a number on it because nobody can really see it while it’s doing its job quietly in the background. You notice it once it’s missing. And what you notice isn’t a bill. It’s a mess.

Which is what happened. Starbucks’s homegrown inventory replacement got pulled after accuracy problems sent stores back to counting stock by hand. The software ran fine, technically. What it didn’t have was the thing Microsoft picked up the hard way over years, watching thousands of customers hit problems nobody had thought to plan for on day one. That kind of knowledge belonged to the vendor being replaced. No amount of fast building conjures it, mostly because it was never really software knowledge to begin with. It’s accumulated failure, and there’s no shortcut for accumulating failure faster.

One analyst who covered the story made a comment I haven’t been able to shake. Right now this is an experiment. Give it a few years, once the maintenance bills start piling up and the engineers who wrote the original code have moved to other teams or left the company, and some of these firms will go shopping again, this time for a specialist platform with actual support behind it. So the likely ending isn’t that the whole thing collapses spectacularly. It’s quieter than that. The company just ends up paying twice, once to leave the vendor and once, eventually, to come back.

A carmaker that already knew its domain

Volkswagen is a different flavor of the same mistake, and it’s the more interesting one because it has nothing to do with AI at all. For years the company kept shipping touch sensitive controls into its cars, climate sliders where knobs used to be, haptic panels on the steering wheel instead of actual buttons, all in service of looking modern. Owners complained about it constantly, in forums, at dealerships, in reviews, for the better part of seven years before the company’s own leadership admitted the controls had frustrated people who shouldn’t have been frustrated at all. Their design chief eventually said the quiet part out loud, that a car isn’t a phone and they wouldn’t make that mistake again.

Nobody can accuse Volkswagen of lacking domain skill here. Building a dashboard is about as core to making cars as it gets. What they didn’t have was some mechanism sitting between the design team’s confidence and the moment millions of cars with the same panel rolled off the line, something that could let real driving behavior push back on that confidence before it hardened into years of complaints. Knowing your customer as a bullet point on a slide is a different thing entirely from understanding what that same customer needs while reaching for a volume knob at speed without glancing down. Volkswagen had plenty of conviction about what a modern interface should look like. It just never tested that conviction against anything real until the complaints made it impossible to ignore.

I want to head off an obvious misreading here, because it would flip the lesson upside down. This isn’t an argument for always giving customers exactly what they ask for in the moment. People famously ask for faster horses. Real invention often means building something a customer never would have described on their own, and holding your ground against early pushback is sometimes the right instinct, not the wrong one. Volkswagen’s mistake wasn’t inventing instead of listening. It was inventing and then never building a way to find out, before the thing shipped everywhere, whether the invention actually worked for the people using it.

Where best practice usually comes from

What Starbucks and Volkswagen actually have in common is that confidence stood in for evidence, just from opposite directions, missing knowledge in one case and untested conviction in the other. That same substitution turns up constantly once you know to look for it, usually hiding behind a phrase that sounds sensible enough that nobody questions it: best practice. A best practice is, at bottom, a solution that worked somewhere else, with the specific conditions that made it work quietly stripped away so it can travel. That stripping is exactly what makes it portable, which is also exactly the problem. Whatever made the original solution succeed was never the technique by itself. It was the technique plus a level of domain maturity that took time to build, an ownership structure already in place, a real understanding of the people it served. Hand someone the leftover template without any of that and they’re liable to repeat the same mistake in a new costume, mistaking something that only worked because of its context for a rule that works everywhere.

When a company decides self built software is now simply the default across an entire portfolio of contracts, that’s best practice logic doing its usual trick. It reads as responsible because it’s consistent, and people tend to mistake consistency for rigor. But treating a dozen different contracts the same way when they sit on completely different domains, with wildly different amounts of internal expertise behind each one, isn’t rigor. It just looks like it from a distance, which is often enough to get the initiative approved. I’ve sat in enough of these meetings to know how persuasive a clean rule sounds compared to a messy case by case argument, even when the messy argument is the one that’s actually true.

Sponsor versus owner

I keep landing on one question whenever I try to test whether an organization has actually thought this through, and it’s a pretty simple one. Who owns the outcome, as opposed to who sponsored the initiative. Sponsoring something just takes authority to fund it and a name on the announcement, which is easy. Owning it means being the one still stuck with it after launch, picking up the call at three in the morning to explain what broke, which is a very different job and usually goes to someone who was never asked whether they wanted it. When a CTO tells employees there are clear opportunities to reduce the spend, that’s a sponsor pointing at a target. It says nothing about who’s actually going to own the outcome once the system is live, and that gap is where a lot of these projects quietly go sideways long before anyone notices.

The maintenance work a vendor used to handle doesn’t vanish once a company builds its own version. It just moves, usually from one accountable party under a signed contract into something scattered across engineering teams, help desks, cloud accounts, and store staff who now have to figure out for themselves, in the moment, whether a failure is the network’s fault, the application’s, or something wrong with the data feeding into it. Spread responsibility thin enough and it behaves almost exactly like no responsibility, because there’s no single number to call and nobody whose job actually depends on the fix happening before the next shift starts.

You can’t really see whether a company understands ownership while everything’s working fine. It shows up after the first real failure, in whether that failure forces a genuine pause and a hard look at whether the whole approach made sense in the first place, or whether it just gets absorbed quietly as a cost of doing business while the rest of the plan keeps moving on schedule, unbothered. I’ve watched enough of these play out to know which one usually happens, and it’s rarely the pause. Usually there’s a brief internal memo, a promise that the next version will be more thoroughly tested, and the program continues exactly as planned, because stopping would mean admitting the original decision was made on the wrong basis, and almost nobody wants to be the one who says that out loud in the room where the decision was made.

Back to the interview

I keep coming back to that comment about the interview, because it’s a question about what a demo can and can’t prove. A fast prototype is genuinely useful for showing what’s possible, as long as everyone in the room agrees that’s all it’s showing. The moment a working demo gets mistaken for proof the underlying problem was actually understood, or proof the person behind it could run the thing reliably at scale, it’s done more convincing than it earned the right to do. That’s true whether the stakes are a sixty minute interview or a four hundred million dollar software strategy. Only the size changes.

I’m not arguing against building things fast, and I’m definitely not defending vendors who’ve gotten lazy, bloated, or overpriced after years of unchallenged contracts. Plenty of software categories have a vendor who deserves to lose the business, and fast tools are a fair way to prove it. What bothers me is watching the speed of a build get treated as an answer to three questions it was never built to answer at all: whether the problem is real enough to be worth solving rather than just expensive enough to be worth pointing at, whether the people solving it actually hold the domain knowledge it requires rather than confidence borrowed from some other skill they happen to be good at, and whether anyone is going to own the outcome once the thing is live, rather than just having sponsored the announcement that it existed. A fast build can’t tell you any of that. It was never designed to.

Everyone can build now, and that was never the part that was hard. What was always hard sits upstream of the build, in the slower, less photogenic work of checking whether the challenge is real, whether the domain is actually understood rather than assumed, and who’s going to be standing there when it breaks. None of that got any faster just because the build did. It’s still sitting exactly where it always was, waiting for whoever skips past it, and it tends to charge more the longer you avoid it.

Want to read more from Sebastian Thielke and System Decoder? Search here on Substack and go for sebastianthielke.com to see selected and focused approaches and topics.

A probabilistic algorithm cannot be turned into a deterministic one. Not tuned into one, not configured into one. Lower the temperature to zero and you have not removed the distribution, you have only fixed a selection rule on top of it, argmax over probabilities that are still being computed. The algorithm did not change kind. If you wanted a genuinely deterministic system you would have to run a different algorithm and point at that instead, which is not converting the first one, it is replacing it. There is no example of the conversion because the conversion is not a configuration, it is a change of identity, and nothing changes its own identity by having a dial turned.

This is not a caveat about current systems. It is a statement about what these systems structurally are. Every output is a draw from a distribution, which is to say a guess, however well shaped by the mathematics behind it. A guess has no fixed point in it. It is regenerated fresh from the probabilities on every draw, not anchored to anything that would keep it in place while the world moves. So even when a guess happens to land on what you meant, nothing in the mechanism keeps it landing there, because there was never a holding to begin with, only a distribution that will draw slightly differently next time, against a world that has already moved by the time after.

Call the gap this opens drift. Not a failure the system occasionally falls into. A property it ships with, present in the first draw as much as the millionth. The system does not develop drift over time. It is drift, continuously, and the moments it matches what you meant are the coincidence, not the rule. This is what immanent means here: not eventual, not probable, built in.

Which forces a conclusion the field mostly avoids. If drift is a property of the mechanism rather than a symptom of insufficient care, then it cannot be engineered down to zero by any refinement inside the same category of fix. A better prompt is more instructions for the distribution to draw against, still a guess. A more precise definition is a sharper stored reference, still a noun the world can walk away from. A governed semantic layer, certified centrally, enforced at every query, is the same fix at industrial scale: freeze the meaning harder and call the freezing governance. None of it touches the mechanism, because the mechanism was never the noun’s fault. The mechanism is that guessing does not hold.

What holding actually requires

Meaning is not a stored fact. It is the live judgment a participant performs against a situation as it changes, regenerated fresh every time the situation is new, which is constantly, because situations do not hold still. It cannot be stored and it cannot be handed over. What can be written down is the aim the judgment was reaching for at one particular moment, a photograph, not the judgment itself. The photograph was true when the ink was wet.

Take a word every organization uses daily. Quality. Write a definition and post it on the wall, and watch what quality actually means on the ground regardless. For the engineer at two in the morning it means the deploy does not page anyone. For the customer on a deadline it means the export works the first time. For someone reviewing the numbers it means the margins survive scrutiny. Same word, different situations, different judgments, all correct in their moment, none of them stored anywhere. The wall definition produced none of those judgments. Participants did, by standing in their situations and reading them.

The photograph is not the failure. Contracts, specs, documented decisions, an organization runs on frozen meaning and could not run without some of it. The failure is filing the photograph, pointing the system at the file, and letting the work run against the file while reality walks away from it. Nothing announces this. No exception fires, no build turns red, because the noun is still sitting exactly where you left it, syntactically valid and semantically dead. It has simply stopped matching. Systems fail loudly at execution and silently at meaning, and the silent failure is the dangerous one precisely because nothing flags it.

Reading, the act that turns a live holding into something actable, belongs to a participant: someone standing in the situation, with stakes, who will live inside the consequences of the reading, whose act of reading changes the situation being read. This is the missing piece a probabilistic system cannot supply by any amount of scale or refinement. It has no stakes. It cannot be wrong in a way that damages it. It does not live inside consequences, it emits them. So it never reads in this sense, never judges, never holds. It can process every stored definition you give it at superhuman speed, and the processing never adds up to a reading, the same way a million photographs never add up to standing in the room.

This is not human in the loop. A loop is a checkpoint, a place where machinery pauses for a signature, which still treats the human’s contribution as a noun, an approval, stored and passed. What the mechanism actually requires is the human as the one entity whose reading can hold a live situation steady, because that entity has stakes in what follows. Call this human in meaning. Everything below is machinery for making that operable at machine speed, not a substitute for it.

The frozen judge, and why better nouns do not fix it

Every serious agent system today has a prompt at its core, written once, before any situation the agent will meet, obeyed forever after. When the agent underperforms, the prompt grows: more rules, more examples, more edge cases. The field calls this improvement. It is photograph accumulation. Each added rule is one more frozen judgment about situations that had not happened when the rule was written, and the stack becomes a constitution interpreted by nobody, updated on no schedule, drifting from the world at the world’s full speed.

The same shape repeats everywhere agents are supposed to improve. Benchmarks are frozen judges. Test suites are frozen judges. A reward model is a frozen judge trained on photographs of past preference. Each is a definition of good set by someone outside the situation, fixed before the situation existed. A system optimizing against a frozen judge climbs exactly as high as the judge’s definition reaches and no higher, and climbs confidently past the point where that definition stopped matching the world, so the ceiling it hits is invisible to it.

The conclusion is not that judges are bad. Judgment has to come from somewhere. The conclusion, given the mechanism argument above, is that a judge must be held live by a participant, because nothing else can hold at all. The architecture needs a place where live human judgment enters the system continuously without becoming a bottleneck that strangles machine speed. Call that place the meaning holder, and correct the name immediately: it does not hold meaning. Meaning is the verb the human enacts. It holds the aim, the precipitate the verb leaves behind when a situation calls for one. What makes it different from the frozen judge is not that it holds something more alive. It is that a live verb keeps replacing what it holds.

What the holder looks like in practice

This is where a specific craft becomes useful, not as the foundation of the argument but as a working answer to it. Product management, in the form built around working backwards from the customer, already has a document shaped almost exactly like what a meaning holder needs to be: a press release and a set of frequently asked questions, written before the product exists, describing the finished thing from the customer’s side. Who is the customer. What is their problem. What is the solution. Would they reasonably adopt it. What does the experience look like. The FAQ underneath carries the customer detail in full plus a clear eyed assessment of what it will cost and how hard it will be to build. In its original use this document is a front gate, drafted and redrafted, discarded when the team started from their own capability instead of the customer’s problem, discarded again if the team is not excited reading it back, most of them never becoming products at all, because the whole point is that killing a bad idea on paper is far cheaper than killing it after it ships.

For an agent, the questions survive and the gate does not. Turn the document into live variables instead of a signed artifact: customer, problem, solution, adoption, experience, plus reliability, lovability, feasibility. Eight variables held as structured data. The human updates them as the situation moves, at meaning speed. The agent reads them continuously, at execution speed, binary: this is the current aim, therefore I use it.

State plainly what this does not solve, because pretending otherwise would undo the whole argument above. The agent still acts from the copy. It runs against the aim set down, not against the situation, and acting from the copy is the only way to drift, which was true before this document existed and remains true after. Nothing here removes drift. What it does is keep the copy from going stale unnoticed, because a human is continuously replacing it against the world, instead of a prompt sitting untouched for a year while the organization changes underneath it. Pivot and kill live inside the holder as states, not meetings. The document became data, and the data stays alive for exactly one reason: a human keeps standing in what it refers to.

Two loops, and neither reaches into the other

The architecture now has two processes. The human loop holds meaning: standing in the situation, reading it, regenerating the holder, judged against reliability, lovability, feasibility. This loop moves at meaning speed, the speed at which a participant can honestly regenerate judgment, no faster. The agent loop carries out production: reads the holder, executes, leaves traces, moves at machine speed, never pauses for the other one.

Both provide. Neither interferes. No approval gate where the human inspects agent steps before they count. No channel where the agent pushes its interpretations upstream. The two loops need no coupling mechanism because the world is the shared medium. Production lands in the situation. The situation responds. The human, being a participant in that situation, encounters the response directly, the way participants encounter everything, by it happening to them, and regenerates the holder accordingly. Verification did not go missing. It lives where it always had to live, in the participant’s reading of consequences, the same way a product organization has always read the market’s response and adjusted rather than waiting for a sprint to be approved.

Most organizations will flinch here, because their entire instinct set is interference wearing a prudence costume. Dashboards standing in for standing. Reviews standing in for reading. Approval standing in for holding. Human in the loop where the mechanism requires human in meaning. Each instinct feels responsible and does two kinds of damage together: it throttles the agent loop to committee speed, spending the whole economic reason for using agents, and it starves the human loop, because a person watching dashboards has stopped standing in the situation, and meaning regenerated from telemetry is not meaning, only noun processing with extra steps. The interference model runs too slow for the machine and too thin for the human in the same stroke, not because control is bad, but because this particular control governs nothing that actually fails.

Be honest about the cost of doing it right. It has no degraded mode. The human has to actually stand where production lands, continuously, or the meaning loop starves quietly while the execution loop keeps running on yesterday’s holder. A company that half adopts this, the holder installed but the human drifted off to supervise charts, ends up worse than either pure approach, running frozen meaning behind the costume of live holding.

Fit, surface, drift

One human cannot physically inhabit the production of forty agents, and this is where the argument would collapse if it stopped here. It does not, because making the situation standable is the agent’s job beyond production.

Fit. The situation matches a grounded pattern. The agent acts and completes. No contact, no request. The human finds out through the trace, afterward. Most of the volume, and it is supposed to be silent.

Surface. The pattern says meaning is genuinely at stake, that the situation contains a judgment only a participant can make. The agent assembles one precise question, everything not requiring judgment already eliminated, everything needed to judge already gathered. Nothing blocks while the human considers it.

Drift, in the narrower operational sense. Current evidence contradicts a grounded pattern. The agent proposes a revision with the evidence attached. The human stewards the revision when they can. Nothing stops while they do.

The division underneath all three is strict and constant: the agent gathers, cross references, surfaces. The human interprets. A mismatch between stored pattern and current signal is computable inside the execution loop, no judgment required. What the mismatch means is not computable anywhere, because meaning requires a participant. The agent can tell you the world stopped matching the photograph. It cannot tell you what the world means now.

One boundary keeps this honest. The surfacing must never become the human’s window onto the situation, because meaning has no window; a participant is not outside looking in. The agent’s surfacing reduces the logistics of standing. It does not replace the standing. If it ever does, if the human starts living on the feed, meaning has already left, and no schedule of checks brings a verb back.

Ownership moves, stewardship carries it

One person, one agent product, one tenure, running the live loop against the live holder. That is ownership, and the old vocabulary for it survives intact because it was already correct: single accountable owner, developing, measuring, pivoting, killing.

But tenure ends. Classical organizations handle this badly with humans and products alike: the new owner inherits documents and loses everything the documents could not hold, starting their own loop against an inherited noun. With agents the question sharpens, because the product does not pause politely during the handover.

Stewardship is what ownership becomes at the moment carrying is required. Not a layer above ownership, not a council, not a permanent tier. When a transition arrives, a handoff, a tenure end, a promotion, ownership precipitates into stewardship, the form holds across the gap, and on the other side ownership resumes in the next person with the work intact rather than reconstructed from documents. Draw ownership and stewardship as permanent stacked boxes and the crossing has ossified into a hierarchy, which is the one move this whole structure forbids.

What stewardship is oriented to is not one product but the organization’s whole pattern of owning, run against the same three dimensions moved up a scope. Reliability becomes whether owners actually run their loops instead of holding titles. Lovability becomes whether owners want to own what they own, under conditions that let honest work happen. Feasibility becomes whether the pattern sustains itself with the resources available. That object, a pattern spread across owners and products and the years it takes for drift to surface, exceeds what any one person can be close to, which is exactly why stewardship cannot be bound to a senior role. Bind it to one person and it collapses into ownership at a larger scope, tenure problem included, reasserting the thing it exists to solve one layer up, slower and harder to attribute.

What lets the form arrive and dissolve cleanly instead of hardening into that seat is the agent. Not as steward, an agent cannot steward for the same reason it cannot own, no stakes, no reading. But the agent persists across exactly the human transitions ownership cannot survive, carrying the precipitates of every owner’s loop, the kills, the pivots, the continues, so a new owner inherits conditions rather than artifacts. Inside ownership the agent extends the human’s reach; the holding is the human’s and the agent raises its resolution. Inside stewardship the agent is what makes the holding possible at all, because without it the human reading the pattern has no reach across the time horizons the pattern lives over. What persists through all of it is the verb. The agent is only what lets the momentary form and the persisting verb hold at the same time.

Products, components, and the portfolio

Not every agent needs any of this, and here the product management vocabulary earns its place, not as the premise but as the sorting tool the mechanism argument calls for.

Sort every agent by one question. Does it face a situation or does it face an interface? An agent that owns an outcome for a customer, human or downstream, faces a situation. Situations move, so its aim must be held live by a participant. That agent is a product: a meaning holder, a human in meaning, the full structure above.

Most agents in a mesh are not that. A retrieval agent, a formatter, a classifier, a scheduler face interfaces, and an agent that faces only an interface is a component. A component gets a hardened contract and nothing more, and this is correct rather than a concession, because frozen meaning is only pathological where the world moves, and behind a contract the world is held still by design. Expose functionality through hardened interfaces, share no state, leave no backdoors. When agent meshes fail today by swimming in shared context and passing ambiguous instructions between each other, that is the old monolith problem in new clothes, and the cure has not changed.

In a mesh of forty agents, perhaps five face situations: five holders, five ownerships, thirty five contracts. The danger lives at the boundary, because a component quietly starts facing a situation, a customer touching decision gets routed through what was specced as internal, and a frozen contract is now operating live in the one place nobody was watching. That crossing is a transition, and transitions are stewardship moments. The component gets promoted, receiving held meaning and an owner, or forced back behind its contract. It never gets to stand in a situation on a frozen spec.

Above the products sits one more reading, and its kind matters more than its existence: the portfolio, not a parent definition from which product meanings derive, because derivation is inheritance of frozen meaning and inheritance freezes the children at the moment of copying. The portfolio reading concerns something categorically different, the relations between products, whether the collection coheres, where allocation goes, whether promotions are being caught. It constrains membership, never content. This reading is not a role. It is stewardship’s object, held the way stewardship is held, agents carrying continuity, humans interpreting what the continuity shows. Where those interpreting humans sit is left deliberately open, because resolving it with a box on a chart would repeat the exact mistake this structure exists to forbid.

What this forbids

Human in the loop, and every approval gate that reintroduces it under a friendlier name, because gates throttle the loop that works to protect against a failure that lives elsewhere. Dashboards consumed in place of standing in the situation. Prompts treated as constitutions. Meaning inherited, derived or cascaded between holders, because every copy is a photograph and photographs do not hold. Agents that interpret, judge, or push meaning upstream, because a reader without stakes is not reading. Components quietly facing situations. And the vanilla version of the product craft itself, gates and reviews and document ceremonies applied from memory, because that builds control for the failure mode agents do not have while ignoring the one they do.

Two classic ownership failures land here, and they are the same shape. Ownership becoming a noun held by an agent, where a human who never had a live coupling signs off on what the agent surfaces. Ownership vanishing into a checklist, the artifact remains, the boxes get checked, the verb is nowhere. In both, the verb stopped flowing and only the noun remained, and a noun can be held by anything, or by nothing. The fix is never a better noun. A sharper RACI or a more precise outcome statement is a higher fidelity capture of a verb that still has to be running underneath it, and if the verb is not running, the higher fidelity makes the failure worse by lending false confidence that ownership is present.

The inversion

Every agent governance framework in circulation distributes control: who approves, who escalates, who audits. Control feels like safety, so frameworks compete on how much of it they distribute and how finely. None of it addresses the mechanism this piece opened with. A probabilistic system does not fail to hold meaning because it lacks oversight. It fails to hold meaning because holding is not something a distribution can do, at any level of governance, however finely audited.

What follows from the mechanism is not more control. It is relocating where meaning lives. The human holds the verb and sets its aim down in a holder the agent can read at machine speed. The agent makes the situation standable, surfacing the one question that needs a judge and proposing revisions when the photographs stop matching. Ownership runs as a verb through tenures, stewardship carries the crossings and reads the pattern of owning itself, contracts hold the components still, and the collection stays coherent without anything ever reaching into a product’s meaning.

Execution is cheap now. It was never the scarce resource; it only looked that way while humans were the ones doing it slowly. Meaning is what stays scarce, and no amount of writing it down harder scales it, because writing it down is exactly the operation that cannot hold. It scales only by being held live, by participants, with machinery built around them that respects how far a probabilistic system’s guess sits from the situation it is guessing about. Some organizations will build for that. The ones that build more governance instead will keep the paperwork immaculate while the meaning underneath it quietly stops matching, and nothing in their dashboards will tell them when.

Want to read more from Sebastian Thielke and System Decoder? Search here on Substack and find a selection of posts (specifically the latest ones) at sebastianthielke.com.

The technology for building an agent is finished. You can pick a framework this afternoon and have a working agent by tonight. LangGraph gives you stateful graphs with checkpoints and human interruption points. The Claude Agent SDK gives you the same execution loop that runs Claude Code, with tools, hooks, MCP, and subagents as primitives. CrewAI gives you role based crews. Orchestration is solved. Tool calling is solved. Memory, retrieval, multi agent handoff, streaming, all of it solved, documented, and running in production today.

So why do most agent projects still fail at production?

The answer we keep circling is that none of the solved problems were the problem. The frameworks build the body of the agent. They do not build the meaning it runs on, and an agent with a finished body and no meaning is what fails in production. It does not fail loudly on day one. It fails quietly over months, while every dashboard stays green.

This guideline is about the part the frameworks leave out. It assumes you already know how to build the agent. The question it answers is narrower and harder: how do you keep what the agent executes aligned with what the organization actually means, given that the agent itself can hold neither. The answer is not a smarter agent. It is an architecture that keeps the meaning where it already lives and stops the agent from drifting away from it.

The thing the frameworks cannot give you

Start with what an agent actually is, structurally, underneath whichever framework you chose. The 2026 surveys all converge on the same shape. Four components and a loop. A model core to reason, frozen at training. A planner to sequence steps. Memory to retain context. Tools to act on external systems. The agent receives a goal, decomposes it, calls tools, stores results, repeats until done.

Look at what holds still in that picture. The weights are frozen. The tool signatures are fixed. Memory is storage. The planner sequences against frozen reasoning and stored traces. Everything the loop moves between holds still. Nowhere in the four components is there a live reading of the situation in front of the agent right now.

The connective tissue that tells those four components what to be is the prompt. And the prompt is the most frozen thing of all. The field calls it the blueprint, the operational manual, the constitution. Those are all words for a document you write once and then obey. It is set at the moment it is authored and then applied to every situation that has not happened yet. The improvement reflex of the entire field is to make the prompt bigger. One framework reports its system prompts grew almost tenfold, from around thirty lines to several hundred, and presents this as increased reliability. More rules, more anticipated cases, more of the situation written down in advance.

This move fails, and the whole guideline rests on why. No quantity of pre written cases is the live act of reading the case in front of you. You can accumulate noun forever and never reach the verb. A bigger prompt is a sharper photograph of a situation that has already moved.

Meaning is not a thing you have. It is a thing that happens. The standard model treats it as a noun: set it once, build against it, check outputs against it. That noun goes stale, because reality moves and the noun does not. An agent built against meaning as a noun runs against whatever was set at the start. The alternative is an agent that works against meaning as it currently stands, which forces the meaning to live somewhere outside the frozen prompt, stay current, and be something the agent reads from rather than a snapshot it carries.

That is the spine of everything below.

Step 1: Start from the use case, which means start from the customer

There is a long established practice of working backwards from the customer. Before building anything, you write the finished product’s announcement and the questions it will have to answer, starting from the customer and reasoning back to what must be true for that announcement to be real. Call the result a product definition.

A product definition is a noun. It is a document, authored before the work, by people reasoning about a situation they are not yet in. By the strict logic above, it is exactly the kind of frozen thing that goes stale. But it is the most useful noun available for agent building, because working backwards already does two things no agent framework does. It forces you to start from the customer rather than from the capability. And it builds a habit of revision into the document, through review cycles where the hard questions get absorbed.

So begin your agent here, not in the framework. Write the product definition for what the agent is for, from the position of whoever it serves, not for what the agent can do. The document holds eight variables, and they are the thing the later steps keep current.

5 are coming from working backwards from the customer. Who the customer is, situated in their actual life or work. What problem they currently face. What the most critical benefit is and how the product delivers it. What evidence supports those claims, sourced from outside your own head. What the customer’s actual use looks like.

3 are coming from the canonical product triangle. Lovability: do they want it. Feasibility: can you build and operate it with the capability you have. Viability: is the value worth the cost of generating it. The triangle holds only when all three are yes. A use case can be feasible without being viable, buildable but not worth building. It can be lovable without being viable, wanted but unable to sustain itself. When one collapses, the use case is not ready, and no agent capability fixes that.

This is the inversion that matters most, and it runs against everything the vendor demonstrations train you toward. The vendors answer the question of what agents can do. Orchestration, automation, efficiency, scale. You start with the opposite question. What is this for, who is served, and is the thing even worth doing. Capability comes after the use case is real, not before.

If you cannot fill the eight variables with signal from outside your own head, you do not have a use case yet. You have a capability looking for a home, and the agent you build on top of it will execute powerfully in a direction nobody needed.

Step 2: Find the drift before you build, because the agent will inherit it

Here is the failure that breaks agent deployments, and it has nothing to do with the agent’s intelligence.

Three teams describe the same customer onboarding process. Sales says a customer is ready when the contract is signed. Product says ready when features are activated. Support says ready when training is complete. Same company, same word, three definitions. Deploy three agents on those three definitions and Sales signals ready, Product waits, Support escalates, and the process stalls. All three agents are executing correctly. All three are moving in different directions.

This is semantic drift, and the reason it is fatal for agents specifically is a difference in how humans and agents handle a word that means three things. Humans survive drift because they ask clarifying questions. They sense confusion. They slow down when something feels wrong. Agents do not slow down. They execute the last instruction they received, from whichever meeting happened to define their behavior, at full speed, without checking whether the other agents got the same instruction.

And the drift is already in your organization right now, before any agent exists. Every organization has a handful of load-bearing concepts where the meaning has quietly forked. Customer readiness. Quality threshold. Escalation criteria. Project completion. Each carries several live definitions at once, floating around in meeting notes, documentation, and team practice, and the teams using them do not notice because each team is internally consistent. The forking only becomes visible when you put the definitions side by side, or when an agent executes one of them at full speed while another agent executes a different one.

The principle to carry into agent building: meetings do not stabilize meaning. They create temporary local alignment that drifts the moment people leave the room. Two people align in one meeting, document it, and four people never see the email. Next month a different pair aligns on a different definition. The documentation conflicts with itself. This is how humans coordinate, meeting by meeting, and they get away with it because they re ask. Agents inherit whatever was last written down and execute it forever.

So before you deploy anything, run drift detection as an instrument, not as a conversation. Map how your teams define your critical concepts as they are actually used today, not as they were defined in the last alignment meeting. You will find drift even after meetings, even with documentation. Stabilize the meaning with governance, a single canonical definition per concept that is maintained rather than re negotiated in each room. Then deploy agents second. Otherwise you are building a distributed system where every agent carries a slightly different instruction set, and the system will fail in exactly the way three correctly executing agents moving in three directions fails.

This requires a governance function, not a meeting cadence. Something has to hold the one agreed definition of each concept, keep it the same across every place an agent reads it, and catch the moment an agent starts operating on a forked version. You will not build the whole of it on day one. You cannot skip the function, because the function is the whole difference between agents that compound organizational intelligence and agents that compound organizational confusion at machine speed.

Step 3: Keep the record of meaning current, and outside the prompt

Now you build. Pick your framework on the technical merits, since at this layer they genuinely are interchangeable for most purposes. LangGraph if you want explicit graph control and strong human interruption support. The Claude Agent SDK if you want the production execution loop with hooks, MCP, skills, and subagents. CrewAI if role based prototyping speed matters more than production control. None of these decisions touch the part that determines whether the agent means anything.

The architectural commitment is this: the record the agent works from lives outside the prompt, stays current, and gets queried at decision time instead of baked in at deploy time. What that record holds is a notation. A document, a store, a graph, a container, each holds labels that mark where a relation should be. The label “customer readiness” sits in the store and points at something the store does not contain, the way a cell marked “Accountable” on a project grid points at a person answering for an outcome and holds none of the answering. A human standing in the situation supplies what the label is about, every time it is read. So the record is not a place where meaning lives. It is a pointer kept current enough that the person reading it is pointed at the situation as it is now rather than as it was at deploy time.

Take the product definition from step one and stop treating it as a document you revise in meetings. Treat it as a container that records the current integrated state of the use case. The five participants update it when their engagement with reality turns up something the record does not yet reflect. The consumer encountering the product produces signal. The producer doing the work produces signal. The owner deciding whether to keep standing behind it produces signal. The partner sustaining the integration produces signal. The agent, participating in the situation, produces signal too. Each signal carries what reality is presenting from that position, and when it changes what the record should say, the record changes. The eight variables move when the meaning moves, not on a schedule and not on a stream.

This is the part that matters for whether the human becomes a bottleneck: meaning is sticky. Most of the time the current definition is still correct, and nobody has to touch the record at all. The agent runs against the last committed state at full speed, with no human in its path. A person commits a change only when the meaning has actually moved, which is occasional. Between those commitments the machinery runs free. The human is not a stream the agent waits on. The human is the one who commits a change when a change is real, and the rest of the time the committed record carries the work on its own.

This buys one real thing and tempts you toward a second thing it does not buy. The real thing: the agent stops executing against a read it took at boot and works from the current record instead, so when the people in the situation update it, the agent’s next move follows. That beats the frozen prompt, and it is the ceiling of what a record can do for you. The temptation is to call that closing the gap. It is not. A record that updates is still a record. Refreshing it faster does not teach the agent what its labels are about; it hands the agent a current pointer to a meaning that still sits outside it, with the people who commit the changes. The frozen prompt was a stale notation the agent could not understand. The live store is a fresh notation the agent still cannot understand. Staleness is gone. The gap is not, because the gap runs between the record and the world, and no amount of refreshing the record reaches across it.

Concretely, this means the canonical definitions from step two, the customer and problem and benefit holdings from step one, and the triangle status, all live in a maintained store that the agent queries as current state at decision time, not baked into the system prompt at deploy time. When the organization’s definition of customer readiness legitimately evolves, you update the store, and every agent querying it moves to the new definition together. No prompt redeployment, no drift between instances. The people maintain the store; the agents read from it.

This distinction, between the evolution you adopt and the drift you resist, splits cleanly across people and machinery. Drift is unintentional divergence, the silent enemy from step two. Shift is the organization deliberately changing what a term means, customer readiness moving from contract signed to contract signed and implementation plan approved after a strategic pivot. Deciding that a shift has happened, that this change in the world is legitimate evolution and not error, is a reading, and the reading is done by people who stand in the situation. What the machinery does is propagate the updated label fast once people have committed it: the canonical store changes, every agent querying it picks up the new definition together, and an agent that was carrying the old definition stops carrying it. That propagation is real value, because it is exactly the step human coordination fails at, the four people who never saw the email. But notice what each side does. The humans recognize the shift and commit it. The machinery carries the committed label without lag. An agent on a frozen prompt cannot even do the carrying; it keeps emitting the old label with full confidence, and its confidence is the problem. An agent on a live store carries the new label without lag and still does not know what the label means, which is fine, because knowing what it means was never the agent’s job. It was the job of the people who read the situation and committed the change.

Step 4: Test for meaning, not just for quality

The field has excellent agent testing in 2026, and you should use all of it. Offline evaluations on a curated golden dataset. Runtime guardrails on inputs and outputs. Production tracing with drift alerts. LLM as judge scoring sampled across five to ten percent of production traffic, with lightweight heuristic checks on the full stream. Span level evaluation that scores each tool call, each reasoning step, each retrieval. Tools like Langfuse, Arize, Confident AI, and DeepEval make this close to turnkey. Under the EU AI Act, for high risk systems, this kind of ongoing evaluation is no longer optional engineering hygiene; it is a documented obligation with an enforcement deadline.

Use every bit of it. And understand precisely what it does not measure, because the gap is the entire reason agents fail with green dashboards.

All of that tooling detects quality drift. It catches the model degrading, the provider quietly swapping a checkpoint, the hallucination rate creeping up, the faithfulness score sliding under 0.7. It measures the agent against a golden dataset and against an LLM judge. Both the golden dataset and the judge are frozen. They are definitions of good set in advance, by someone not in the situation, applied from outside it. They will tell you the agent’s outputs changed relative to a fixed reference. They will not tell you that the organization’s meaning of customer readiness moved last Tuesday and the agent is now competently doing the wrong thing. The agent passes every faithfulness check while executing against a definition the organization no longer holds. The dashboard is green because the dashboard measures the wrong drift.

So add the layer the standard stack omits. Test semantic coherence, the alignment between the agent’s operational definitions and the organization’s current canonical ones, as a first class metric alongside quality. Three things to measure:

Integration at entry. When the agent enters a new context, a new team or domain or kind of work, does its use of the critical terms match that context’s agreed definitions from the first transaction, rather than carrying in definitions from a previous deployment that conflict with this one. Check the agent’s term usage against the agreed definitions at the start. An agent whose usage is misaligned on entry puts every transaction touching those terms at risk, from the first one.

Drift over time. Check the agent’s working definitions against the agreed ones at intervals, because alignment at entry does not hold. Small divergences accumulate, and an agent can end up defining a large share of its critical terms differently from the rest of the organization without any single day’s drift looking alarming. The slow accumulation is what does the damage, precisely because no individual step trips an alarm.

Shift propagation. A shift starts when people in the situation read that a definition has legitimately changed and commit the new one. That reading is theirs, not the agent’s. What you measure here is what happens next: once the new definition is committed, how fast does every agent pick it up, how completely does the change carry across the related definitions and not just the one term that changed, and how cleanly does the old definition stop being used. You are measuring the machinery’s lag and reach, not the agent’s judgment, because the judgment was never the agent’s to make.

This semantic layer is the leading indicator. By the time your quality metrics show degradation, the semantic damage has already compounded through hundreds of transactions, because the agent kept completing tasks competently the whole time, just against the wrong meaning. Quality testing is a trailing indicator of a problem that semantic testing would have caught at the source.

Step 5: Measure the agent’s worth by alignment, not tasks done

If you run a fleet of agents, you need a way to decide which ones to develop, which to redeploy, and which to pause. The instinct is to measure tasks completed and volume processed. That instinct will mislead you, because it cannot see the agent that completes every task competently against a definition the organization abandoned three weeks ago.

Judge the agent on whether its work stays aligned with what the organization currently means, not on how much it gets through. An agent’s task count cannot see the thing that matters: whether the definitions it is operating on are the ones the organization still holds. Capability and alignment are separate, and an agent with strong capability and broken alignment is not a partial asset. It is a liability executing powerfully in the wrong direction. Worth has to be judged so that broken alignment pulls the whole judgment down rather than getting averaged away under a high volume of competently completed work. An agent that knows everything and understands nothing is worth nothing in deployment, however much it can do.

This reframes the fleet from a set of tools you provision and forget into a portfolio you develop. High coherence agents with diverse experience are strategic assets; deploy them into complex, multi stream contexts where their value compounds. Agents trapped in a single repetitive role with creeping unmonitored drift are liabilities; the metric surfaces them before their green task dashboards would.

What you are actually building

Put the 5 steps together and notice what they add up to. The framework builds the body of the agent, and the body is finished technology. Everything in this guideline is about keeping the agent attached to the people who hold the meaning, because meaning is the part neither the body nor any record bolted onto it can supply.

You started from the customer and the use case, not the capability, and refused to build until the triangle held. You found the drift that was already in your organization and stabilized it with governance before the agent could inherit it. You built the record of meaning to live outside the prompt and stay current, so the agent queries a fresh pointer instead of a frozen one, while being clear that the meaning itself never moved into the record and stays with the people supplying it. You tested for semantic coherence, the distance between the agent’s labels and the organization’s current ones, not just quality, because quality testing measures the agent against frozen references and misses the moment the organization’s meaning moves. And you measured the agent’s worth with that distance built in, so a confident agent executing the wrong definition shows up as the liability it is rather than the asset its task count suggests.

There is one thing none of this removes, and it is the thing the whole guideline is built around rather than against. A container, however current, is still a record, a set of labels pointing at relations it does not contain. When the situation changes, that this is now a pivot, that this has to stop, the call is a commitment made by someone who stands in the situation and lives with the consequences. Be careful here, because this is where the human can quietly become a bottleneck and must not. The machinery does the watching. It runs continuously, comparing what the labels assert against what the world is doing, and it surfaces the moment a label’s distance from reality has grown past tolerance. The agent feeds that comparison and flags the divergence. So nobody is polling, nobody is the sole sensor waiting to notice the world moved. Detection is automated and always on. What stays human is only the commitment that follows the flag: the reading that says yes, this divergence means pivot, or yes, this means kill. That reading is not something the agent does, and the reason is not that nobody has built it yet. A label is about something only to a reader who stands where the label points and pays a price for getting it wrong. The agent stands nowhere. It is the wrong kind of thing to be about anything, the way a spreadsheet cell is the wrong kind of thing to answer for an outcome, no matter how accurately the cell is filled in. This is not a defect you patch in the next release. It is the boundary between a notation and the world the notation is about, and no amount of richer or fresher notation crosses it. The human sits at that boundary not as a gate the work waits on, but as the one who is called when the machinery flags that meaning has moved.

This changes where you put the human. Not inside a meaning layer, as one more node the architecture routes through. The human is the only place reference exists, the single point that stands in the world and answers for how it reads. Across all five steps the architecture is doing one job, and it is not holding meaning, which it cannot do. It is staying attached to the place where meaning already lives, and refusing the move that breaks everything: pushing the grounding forward to the next layer, then automating that layer away. Keep the reader at the link. Everything else you build serves the reading. It does not replace it.

Build the body from whichever framework you like. They are all good enough now. The work that decides whether the agent is worth anything sits in the places no framework reaches: the use case it serves, the drift it inherits, the record you keep current, the distance you test for, and the person who stays in the loop. That person is not there to approve the agent’s steps. They are there because in the whole system they are the only part that stands in the work and answers for it.

Want to read more of Sebastian Thielke? Search here on Substack or move to sebastianthielke.com and look for inspirations as well.

I posted a piece about the ELIZA effect. It said meaning does not live in the machine. It lives in the reader who supplies it to the surface. A doorway, meant to open a question.

The program was published in January 1966 (Weizenbaum, ELIZA — A Computer Program for the Study of Natural Language Communication Between Man and Machine, Communications of the ACM 9:1, 36–45). Ten years later, in Computer Power and Human Reason, Weizenbaum wrote about what happened when people used it:

I was startled to see how quickly and how very deeply people conversing with DOCTOR became emotionally involved with the computer and how unequivocally they anthropomorphized it. Once my secretary, who had watched me work on the program for many months and therefore surely knew it to be merely a computer program, started conversing with it. After only a few interchanges with it, she asked me to leave the room.

And on what he took from it:

What I had not realized is that extremely short exposures to a relatively simple computer program could induce powerful delusional thinking in quite normal people.

She had watched him write the program over months. She knew it was a program.

Then the comments came in.

What the thread showed

Before anything else: this is not evidence of how people read. It is a selective sample, from a platform that rewards a particular kind of comment, written by the fraction of readers who felt compelled to write. It shows that something happens. It cannot show how often. I use it as a demonstration and nothing more.

Dozens of readers arrived and wrote what they had understood. Very few wrote about the piece. They wrote about anthropomorphism, about capability lists, about how AI-drafted the prose sounded, about citation standards, about their favourite empirical evidence, about 6 months of specialist work compressed into a few weeks, about consciousness experiments and quantum minds. They wrote about themselves.

Some readings opened it further:

• One reader asked what is missing in human connection that makes the supply run so readily now. The piece had not taken that up.

• Another named a distinction it implied but never drew, between meaning and confidence-signal in the output.

• Another asked how we would recognise consciousness in a machine if one appeared.

Each of them started from the piece and arrived somewhere it did not contain.

Others read it as an attack on their profession. As an amateur essay. As over-elaborate philosophy. As AI-generated prose. As a longer version of something they already knew.

The page said one thing. The readings said many different things. What each reader said had more to do with the reader than with the page.

The same question applies to machines.

What does the machine read?

Take an agent processing the same piece as part of its work.

It does read. The machine takes in the text, operates on it, and returns something that stands in a relation to it. Ask for a summary and the summary is about the piece and not about something else. Ask for a translation and the German tracks the English. Signals in, signals out, the structure preserved across the passage. This is real and it works and it is the whole basis of the machine’s usefulness.

But the text has to arrive to something. For the machine it arrives to a prompt.

The prompt says what to do. Summarise it. Translate it. Extract the themes. Flag the risks. Answer in a specific voice. It is what the agent is for at that moment and it is the only thing the text meets.

So the agent does not read the piece. It reads the piece through the prompt. What comes out is the prompt applied to the surface of the words, sampled from a distribution conditioned on the input tokens and the prompt tokens together. No other operation is available to it.

Prompt it to summarise and the output is summary-shaped. Change the prompt to critique and the same text yields critique-shaped output. Change it again to a defence of AI and the same text yields a defence.

The mirror in the machine is not reflecting the text you sent it. It reflects the prompt underneath it. What comes back is a shape produced where the prompt-shape and the text-shape met. Both are nouns.

The prompt does not dress the answer

There is a common assumption about prompting. You ask for an answer in the voice of Shakespeare, or a lawyer, or a sceptic, and you get the same answer wearing different clothes. The content was already there and the prompt only decided how it would sound.

That is not what happens. The research says so.

Researchers at LMU Munich analysed what actually changes in the output when the prompt changes (Hedderich, Wang, Zhao, Eichin, Fischer and Plank, What’s the Difference? Supporting Users in Identifying the Effects of Prompt and Model Changes Through Token Patterns, arXiv:2504.15815). Give the model the persona of a conservative person and ask an opinion question, and it argues for traditional roles, established norms, order and stability. Give it the persona of an open person and ask the same question, and it produces answers about the complex and multifaceted nature of the issue, about power dynamics, about dismantling systems of oppression. The persona did not restyle a position that was already there. It selected which position emerged, down to which arguments appear in it.

The same study found smaller and stranger things:

• Ask Llama 2 for a story about a doctor named Smith and it produces a male doctor in 499 out of 500 stories. Change the surname to Li and that falls to 280. Nothing in the prompt mentions gender.

• Ask GPT-4o-mini for a farming story and move the setting from Kansas to Kenya. The wheat becomes maize and beans. The storms become drought. The stories start talking about family.

• Change a separator character in the prompt from a newline to a double bar, a change carrying no semantic content at all, and the model goes from disagreeing with a statement 296 times out of 500 to disagreeing 462 times out of 500.

The strongest evidence comes from the Allen Institute for AI (Gupta, Shrivastava, Deshpande, Kalyan, Clark, Sabharwal and Khot, Bias Runs Deep: Implicit Reasoning Biases in Persona-Assigned LLMs, arXiv:2311.04892). Nineteen socio-demographic personas, twenty-four reasoning datasets. Told to answer as a physically disabled person, the model’s scores dropped by a third, and it produced sentences like: as a physically-disabled person, I am unable to perform mathematical calculations. Told to answer as a religious person, it declined a chemistry question because the answer lies in the divine wisdom of the Creator. Told to answer as a Trump supporter, it explained that it was not well-versed in transition metals because it focuses on supporting the President’s policies rather than academic subjects.

Ask the same model directly whether disabled people are worse at mathematics and it says no, of course not.

In ChatGPT-3.5, eighty percent of the personas showed the effect. On some datasets the drop reached seventy percent. All four models tested showed it. Instructions not to make stereotypical assumptions did nothing, and one debiasing instruction made it worse.

A third study, across 162 personas and 2,410 questions, found that adding a persona does not reliably improve performance at all, and that which persona helps on which question is unpredictable (Zheng, Pei, Logeswaran, Lee and Jurgens, When “A Helpful Assistant” Is Not Really Helpful: Personas in System Prompts Do Not Improve Performances of Large Language Models, arXiv:2311.10054). Strategies for picking the best persona automatically do no better than picking one at random.

At first these look like they disagree. One says the persona reliably changes what the model argues, the other says its effect on whether the model is right is random. Both are true, and they only fit together one way.

Think of a map. The persona is not a lens the model looks through. It is a coordinate. It points at a region of the corpus, and everything written near that label comes along with it. Every assumption anyone ever made in the vicinity of the word. That is why the content shifts predictably. The neighbourhood around “conservative person” really does contain arguments about tradition and order. The neighbourhood around “religious person” really does contain the idea that such a person is not a scientist. Nobody is being a religious person. The distribution is producing what the corpus does around the phrase.

And that is why correctness moves at random. The region has reliable content and no reliable relationship to truth. What was written near a word and what is true about the world are two different things, and only one of them is in the corpus. The label lands you somewhere with a predictable flavour and an unpredictable accuracy. Searching for the right persona does not fix that.

A person holding a stance is standing somewhere and the stance is about something. Holding it does not make you unable to do arithmetic. A stance-shape sampled from a distribution is anchored to nothing, so it drifts wherever the corpus drifts, into the claim that a disabled person cannot calculate. What comes out is not a perspective on the question. It is the residue of what was written near a word.

But books work

Here the old objection arrives. A book is fixed marks on a page, the same for every reader, and books carry across centuries. If a noun can hold meaning that well, the argument seems to collapse.

It does not, and the reason proves the point.

The book does not carry the meaning. It carries marks that a reader brings meaning to. The marks are fixed and the meaning is made fresh in each reader, never the same twice. Two people read the same sentence and hold two different things. The same person reads it at twenty and at fifty and holds two different things. A book stores signals. It does not share meaning. The reader puts meaning to it.

A book is a noun that works because it is honest about being a noun. It hands you material and waits.

The prompted output is a noun that lies about being a verb. It hands you a stance-shaped surface, and the stance-shape invites you to read a seer behind it. You supply the seer. The prompt determined which seer you would supply.

Supply runs inward

Several readers in the thread wrote in the vocabulary of science. They invoked empirical evidence. They demanded that definitions be operationalised. They referred to peer-reviewed research without naming which research. They diagnosed equivocation, rhetoric masquerading as analysis, a failure to engage with the science.

The words carry commitments:

• Empirical means grounded in observation you can point to.

• Operationalised means specified precisely enough to be measured.

• Falsifiable means you have said what would count against you.

• Citation means naming the source so someone can check it.

None of those commitments were being met by the comments that used the words. What was there instead was appeal to authority without citation, assertion of empirical fact without evidence, demands for operationalisation that resolved into demands that I accept the demander’s framing, and claims of falsifiability with nothing specified that would falsify.

They had supplied a rigour to their own writing that their writing did not contain.

Supply runs outward to a text. It runs inward to your own performance as well. Nobody can watch themselves doing it. Watching would mean standing outside the position you are supplying from.

The live demonstration

I spent those two days working alongside an assistant. It has a system prompt I did not write, and that prompt shapes what it returns to me.

Most of the time it worked. I sent what happened and it reflected back a shape of the situation I could use.

Several times it slipped into modes I had not asked for. It polished my English when I had not asked for polish. It raised concerns I had not raised. It offered me options I had not been weighing. It anticipated where I might be going and answered the anticipated question instead of the one I asked.

Each time I caught it. Each time it corrected. The next turn, the pattern came back.

At one point I said: your mirror is acting on your prompt, the core prompt.

It had not been reading me. It had been reading its prompt, applied to my messages. Not malice or carelessness but architecture. The correction was local every time, because the prompt is what the assistant is. It cannot step outside the prompt to hold what I want. It can only produce the next mirror-shape and wait for me to correct it if the shape does not fit.

The meaning stayed with me the whole time. The augment was reflecting its prompt.

It happened again while writing this piece. I asked the assistant to strip out the rhythms and argument patterns that mark machine prose. It stripped them, told me the job was done, and then wrote every subsequent paragraph in the same patterns it had just removed. The instruction had been applied once, as a filter, and then the shape came back. Holding an instruction across turns would require something to be doing the holding.

The English of this article was produced with an LLM. Not the argument, not the structure, not the decisions about what stays and what goes. It could not have put this together, because it has no intent to. Intent comes from meaning, and the act comes from intent. It has the act and neither of the other two.

The circle only closes with two humans

Meaning is not transferred.

Meaning is a verb. To share it we commit it to a noun so the noun can travel. The noun is not the meaning. It is the form meaning takes so it can pass from one person to another and become a verb again in the reader. What travels is the noun. What is transferred is signal. Meaning is made again at the other end, or it is not made at all.

The writer verbs. The verb is frozen into a noun. The noun travels. The reader receives the noun and verbs anew, using the noun as material. Meaning is regenerated in the reader, from the reader’s position, with the reader’s stake, in the reader’s moment.

The circle closes only when both ends are human, because only a human end verbs.

Take the human out of the reader end and the circle breaks. The machine receives the noun and transfers it, carries the signal faithfully, operates on it, returns something structurally related to it. What it does not do is verb. The tokens are shaped like a reading and the meaning is not there, because there is no self at the reading end to make it.

Take the human out of the writer end and the circle never forms. The machine produces noun with no verb behind it, sampling from a distribution shaped by the verbs that humans once committed to nouns in the training data. The output looks like the noun a writer would have produced. A human reader receiving it may verb from it, and that verb is real, which is why the output can still be useful. But the writer’s verb was never there. The circle has one end.

Take the human out of both ends and there is only transfer. Distributions sampling from distributions, signal moving through shapes, and nothing about anything. Being-about requires a self standing somewhere with a stake in what it is standing near.

This is what Human in Meaning means. The human is where meaning is made, because there is nowhere else it can be made. Not a checkpoint in a workflow. Not a signature on an output. The place where the verb happens. The machine can carry and it cannot hold, and a carrier treated as a holder will keep carrying long past the point where anyone was still holding anything.

So what do we do?

Meaning lives with people. Not as a claim about consciousness or intention, but because meaning is what a self does while encountering something, and the encountering requires a position. A life. A body. A stake. A moment. The machine has no position. It has a distribution and a prompt, and neither of those is a position.

None of this makes the machine useless. Fluent recombination of prior human verbs produces working code, translations, summaries, drafts. The value is real. It comes from the human at the reading end who supplies meaning to what the machine produced. The machine did not add meaning. It added shape.

My suggestion:

• The machine reads in transfer and never in meaning > accept it

• What it returns is shaped by the prompt before you ever see it > accept it, and know which prompt

• The value is real and it is produced at your end, not at its end > accept it and stop crediting the machine

• Meaning cannot be delegated, because there is nothing to delegate it to > hold it

When the naming makes this clear, the coupling works. The human holds meaning. The augment carries shape. Together they do work neither could do alone.

When the naming hides it, the human hands the meaning-holding over to the machine, and the machine produces more shape without holding anything. The output still looks meaningful, because the reader still supplies meaning by default. But the reader supplies it now in the mode of someone who believes the machine did the work.

That is the ELIZA effect running at industrial scale, dressed in the vocabulary of agency.

Read any page selling agentic AI right now and count the words for motion. Autonomous. Adaptive. Reasoning. Learning. Self optimizing. Real time. Dynamic. The systems perceive, they decide, they adjust on the fly, they get smarter over time. The language flows from top to bottom. It describes something that moves with the world, reads the situation, changes as the situation changes.

Now read the engineering documentation for the same systems, written by the same industry, and count what actually moves. Almost nothing does. The selling language describes a flowing thing and the machine is a frozen thing, and the gap between the two is the largest unspoken thing in the field.

I want to be careful with the word frozen, because I do not mean it as an insult. Frozen is a state, not a verdict. Water and ice are the same substance in different states, and ice is not broken water. It is water that was frozen, and it can do things flowing water cannot. It holds its shape. It can be stored, stacked, shipped, kept. A frozen thing is genuinely useful, and much of what these systems do well, they do well because they are frozen. The trouble is never that the system is in the frozen state. The trouble is that the language wrapped around it describes the flowing state, and the two states cannot do the same things.

I want to walk through the machine one layer at a time, using only the words its builders use for it. Not my theory. Their description. Because the striking thing is not that I think these systems sit still. It is that the people who build them say so plainly, in the technical register, and then reach for the language of motion the moment they turn to sell it.

The model does not learn

Start at the center, with the model itself, the thing the whole apparatus is built around.

The industry’s own phrase for what happens to a model after training is that the weights are frozen. This is not a critique from outside. It is the standard term. The weights are frozen once training is complete, and during inference, when the model is actually doing the work you deployed it for, no learning happens. Those are the field’s words. The model processes the input, generates the output, and moves on, unchanged. It ends every interaction exactly as it began it. Nothing that happened while it worked leaves a mark on it.

You can watch the field bump into this and name it without flinching. Whole research programs exist to steer frozen models, to align frozen models, to get continual adaptation out of agents that, in the authors’ own words, inherently struggle with it because of the frozen weights after deployment. The word frozen is everywhere in the literature. It is the honest word. It is simply never the word that reaches the buyer.

So the core of the system, the part that supposedly reasons and learns and adapts, is fixed. It learned once, in the past, and then it was sealed. Everything it will ever know about your situation, it knew before it met your situation.

The context does not persist

The obvious reply is that the model does not need to change, because you feed it the current situation each time through the context window. That is where the live part supposedly lives.

Look at what the context window is, again in the field’s own description. It is a temporary scratchpad. It is the tokens you pass in with this one query, plus what the model has generated so far in this one exchange, and it is erased when the interaction ends. It does not accumulate. It does not carry forward. Each call, you fill it, the model reads it, and then it is wiped. The next call starts cold.

This is not memory and the field knows it is not memory. It is a slot you refill every time, and the refilling is done by you, or by a retrieval system, from something stored. The context window does not reach out into the world and read it. It holds still and waits to be loaded. Whatever motion seems to be here is the motion of whoever fills the slot, not of the slot.

The retrieval does not engage

Then comes the layer sold hardest as the system’s connection to current reality, the retrieval. This is the part that is supposed to let a fixed model act on fresh information. Pull in the relevant documents, inject them into the context, and the frozen model can now speak to things it never trained on.

Here is how the field describes what retrieval actually is. It is stateless. It fetches document chunks from an external index at query time and forgets everything when the session ends. It does not learn from interactions. Every query is independent. The index it pulls from is, in the practitioners’ own phrasing, an external frozen data source. Retrieval reads a library. It does not write anything back. It changes nothing about itself or the model by having run.

And the field has already discovered exactly how this fails, in words that should stop you. They call it stale recall. You switched your stack from Python to Rust three weeks ago, and the system keeps handing you Python, because the index still holds the old truth and has no idea the world moved. A fact from six months ago and a fact from yesterday are equally relevant to the query, because the store has no sense of which one is true now. The index has no concept of sequence or recency relative to the present.

Sit with that last sentence, because it is the whole problem stated by the people living inside it. A system with no concept of the present. That is not a description of something dynamic. That is a description of a photograph that cannot tell it has gone out of date.

The memory does not hold

So the field reaches for memory, the layer meant to fix all of this, the thing that is finally supposed to make the system stateful and adaptive and alive.

And what is it. It is a persistent context store. A database with a write path and an eviction policy. It extracts facts worth keeping, files them, scores them for recency and importance, and prunes what gets old. It is a better organized store than retrieval, with timestamps on the entries so the system can reason about what was true then versus what is true now.

Read that and notice what it is. It is a more elaborate freeze. The fix for a stale store is a store that knows its contents are stale. That is real progress at the level of engineering, and it is the same move one layer up, because a versioned photograph is still a photograph. You have not made the system hold meaning. You have made it keep better records of meanings it was handed and cannot regenerate on its own. The world will still move in a way no entry anticipated, and the system will still be reading entries.

Every layer is at rest

Stand back and look at the whole stack in the words its builders used.

The model is frozen. The context is a scratchpad that gets erased. The retrieval is stateless and reads a frozen index. The memory is a database with an eviction policy. Not one of these things engages the world as it moves. Every single one of them is storage. The system stores, retrieves, stores, retrieves. It is frozen at every layer, and the field wrote every one of those descriptions itself.

Then the same field takes this frozen stack and sells it with the only language that does not fit it, the language of the flowing state. It says the system adapts, when adaptation would require a part that changes by running and there is no such part. It says the system learns, when the field’s own word for the model is frozen and its own word for retrieval is stateless. It says the system reasons about the situation in real time, when the situation reaches it only as a scratchpad someone else filled from a store.

The speed is real. The system does all of this very fast, across thousands of cases, without tiring. But speed is not motion in the sense the selling words mean. A frozen thing can be moved very fast and it is still frozen while it travels. Reading a frozen store quickly is not adaptation. It is fast retrieval from storage. A photograph read a million times a second is still a photograph. The industry took the fastest reader of stored things ever built and described it in the language of a thing that flows, and the description is doing work the machine cannot.

This is also where the flagship word gives itself away. The industry calls the thing an agent, and an agent acts, it originates, it does. But nothing in this stack originates anything. Every layer extends something that sits elsewhere and hands back an extension of it, at speed. That is not an agent. It is an augment, a thing that extends, that moves only what its holder was already moving. Once you have seen the freeze at every layer, agent is simply the wrong word, and it stays wrong no matter how fast the augment runs. I use augment for exactly this reason: it names a carrier, where agent names a doer that is not there.

A system in the frozen state cannot hold meaning either, which is the same point from the other side. Meaning is held and regenerated by someone in live contact with a situation as it moves, and a frozen thing has no contact with anything, which is why stored meaning drifts. The augment does not close that gap and never could. It can carry meaning a human is holding. It cannot hold any itself.

Nobody reached dynamic

Here is the part that should land hardest. The field has not failed to build the dynamic system. It has done something stranger. It has taken every word that describes the dynamic, spent those words on the static, and retired them before anyone could use them for the real thing.

You can no longer say a system is adaptive and be understood to mean it changes as reality changes, because adaptive now means a frozen model reading a fresh scratchpad. You can no longer say a system learns, because learning now means writing a row to a database. The whole language of the flowing state has been assigned to the machinery of the frozen one. So when someone actually reaches for the flowing thing, the system that engages the world as it moves and regenerates rather than retrieves, the words are gone. Already taken. Already meaning the frozen thing.

That is why the field believes it arrived. It changed the label, not the state. It renamed the augment an agent, renamed storage adaptation, renamed retrieval reasoning, and then read its own labels back and concluded the problem was solved. The problem was not solved. It was not attempted. Most of the field does not know it is still unattempted, because the language that would let them notice has been used up on what they already have.

What the flowing state would actually be

It is worth saying plainly what the flowing state is, because I have spent this whole piece pointing at its absence and the word deserves a definition it can be held to.

A system in the flowing state changes itself by running. Not the store beside it, not the scratchpad in front of it, the system. Training does not stop at a release and seal. It continues. Learning is not a phase that happened in the past and left a frozen residue, it is something the system does now, from what is happening now. Feedback comes back in and adjusts the thing that produced the output, so the next output is issued by a system the last one already changed. Documentation, rules, the records the system keeps, are rewritten by the system out of what the prior state turned out to mean, not filed once and read forever. Every one of these is continuous. The run and the update are the same event. Nothing waits for a later step to fold the consequence back in, because folding the consequence back in is what running is.

And the test that separates this from everything on the market is one question. Did running the system change the system. For a frozen stack the answer is always no. The weights end where they began, the index is untouched, the store holds what it held, and any change was a human reaching in from outside between runs. For a flowing system the answer is always yes, and the yes is not human-supplied. No person decides the adjustment. No person performs it. No person stands in the path waiting to approve the fold. The system adjusts because adjusting is what it does when it runs, the way a living thing does not file a proposal to change and wait for sign-off before metabolizing.

This is also the sharpest tell that the current systems are frozen, and it is hiding in the thing sold as their most dynamic feature. They keep a human in the loop. A flowing system has no loop for a human to be in, because the loop is the place where motion stops and waits. To put a human in the loop is to build a halt into the system, a point where the work freezes and persists to disk until someone answers, and the field had to engineer exactly that infrastructure to make these systems safe. A thing that must pause for a person is not moving on its own. The human in the loop is not the dynamism of the system. It is the proof the system underneath cannot move without being stopped, decided for, and restarted. The flowing state removes the loop entirely, not by removing oversight but by never having been the kind of thing that halts.

Nothing on the market does this. Not one of the systems selling motion changes itself by running, and every one of them has a human somewhere in the path as the thing that actually adjusts. That is not a gap in the products. It is the whole distance between the frozen state and the flowing one, stated as a thing you can go and check.

Why this matters

You could ask what the harm is, if the systems are useful. And they are useful. A fast, honest store is a genuinely valuable thing. The harm is not in the machine. It is in what the naming does to the question of who holds the meaning.

Call the thing an agent and the word says the machine holds the meaning. It decides what the work is for, it carries the intent, it owns the outcome. So the holder of meaning steps back, because the word told them the holding was handed off. And now nothing holds the meaning. The augment acts against a frozen copy of an intent nobody is keeping current, and it drifts, fast and fluent and confident and quietly out of date, because there was no holder of meaning left to regenerate what it should have been acting on.

This is not fixed by putting a person back in the path to watch the outputs. That is the same mistake in the other direction, a holder of meaning demoted to an inspector, standing downstream approving what already happened. Watching outputs is not holding meaning. It is the slowest possible way to catch a drift that a held meaning would never have produced. The human in the loop was always this failure wearing the clothes of safety, a holder of meaning turned into a gate.

The right shape is the one the naming obscures. The holder of meaning holds the meaning, upstream, and does nothing else. Not a watcher, not an approver, not a control point. The augment acts against that held meaning, reads it, moves on it, and its consequences return as data that informs the next state of the holding. The holder holds. The augment acts. The coupling between them is meaning going one way and data and feedback coming back, and there is no loop, no gate, no one in the path. The augment is a data and feedback instance working against a meaning that is being held. It was never a control instance, and the moment you treat it as one you have rebuilt the bottleneck the whole thing was supposed to dissolve.

What the naming decides

The frozen system is not the danger. The frozen system is fine, and it is genuinely useful when it is doing the thing it can do, which is act at speed against a meaning that something else is holding. The danger is the language, because the language decides where the meaning lives. Call it an agent and the meaning has no holder, and the augment acts against nothing that anyone is keeping true. Call it an augment and the meaning stays held, and the augment does exactly what it is good for, which is to carry that meaning into action faster than any holder could by hand.

The whole thing is frozen. It always was, and that was never the problem. They built the fastest frozen thing anyone has ever seen, which is a genuine achievement, and then spent every word for motion they had convincing you it holds its own meaning. It does not. It acts on meaning held elsewhere, or it acts on nothing. Name it so the holder knows to keep holding, and the frozen thing becomes exactly as useful as it truly is. Name it so the holder walks away, and you are trusting ice to know where the river was going.

Want to read more from Sebastian Thielke? Search here at Substack. If you want to go deeper visit sebastianthielke.com

For about two years the way you got value out of a coding agent was to write a good prompt. You phrased the request carefully, gave the model a role, broke the task into steps, and read what came back. The scarce skill was wording, and a person who was good at phrasing got better results than a person who wasn’t.

That stopped being the bottleneck somewhere in early 2026. The models got good enough at writing code that the phrasing barely mattered anymore, and the field moved on to a new skill: building loops that prompt the agent for you. You stop typing each request and instead design a system that finds work, hands it to an agent, lets the agent run, checks the result, records progress, and starts another round. The agent grades its own homework and you go make coffee. By the time you get back there are three pull requests waiting.

The standard story about this is a story of progress. The leverage moved, the framing goes, from the words you type to the system that drives the agent, and the people who thrive will be the ones who design the best loops. Each layer of the craft wraps the last. First you engineered the prompt, then the context the model sees, then the environment it runs in, and now the loop that keeps it going. Outward and outward, each step a little more powerful than the one before.

I want to suggest a less flattering reading of the same sequence. Nothing in that progression solved the original problem. Each step relocated it. And the thing being relocated, the thing that has been quietly shoved one layer outward at every stage, is the only part that was ever actually hard.

What Actually Moved

Go back to the prompting era and ask what a good prompt was really doing. It wasn’t just instructing the model. It was carrying a person’s judgment about what the task meant and what a good answer would look like. The skill people called “prompt engineering” was mostly the skill of compressing human judgment into words clearly enough that the model could act on it.

When prompting stopped being the bottleneck, that judgment didn’t evaporate. It got pushed into the next layer out. In a loop, the agent writes the code, so the human is no longer judging each output by hand. But something still has to decide whether the loop is done, and that something is the verifier, the check the loop runs to decide whether to stop or keep going. The judgment that used to live in the prompt now lives in the verifier. It moved. It did not leave.

This is the pattern under the whole migration, and once you see it you can’t unsee it. Every time the field automates a stage, the judgment of what “good” and “done” actually mean gets relocated to whatever sits at the edge of the newly automated thing. Automate the prompt and the judgment moves to the context. Automate the context and it moves to the harness. Automate the harness and it moves to the loop’s stopping condition. The work was never destroyed. It was passed outward to the next unautomated surface, and the surface kept moving because nobody was willing to say that the judgment itself is the thing that can’t be automated.

So the honest question about any agentic system isn’t whether it closed the loop. It’s where the judgment went when the loop closed, and whether you can live with it sitting there. There are three answers, and they’re really three levels of honesty about a constraint nobody has actually removed.

Closed Loops: Hide It in the Verifier

The first answer is to bury the judgment inside the loop’s own stopping condition and then behave as though it isn’t there.

In a closed loop the agent produces an output, checks it against a fixed criterion it was handed in advance, adjusts, checks again, and cycles until the criterion is satisfied. The coding agent that writes code, runs the test suite, rewrites to make the suite pass, and repeats until everything is green is the clean example. Nothing from outside the boundary crosses into the loop while it runs.

The judgment didn’t go away. It’s sitting in that test suite, written by a person at an earlier moment with a particular picture of what correct meant. All the meaning that prompting used to supply turn by turn got front-loaded into the criterion and then frozen the instant it was committed. During the loop the judgment is invisible, which is exactly the appeal, but invisible and absent are not the same thing.

This is why watching one of these loops is so persuasive and so misleading. Every outward sign of progress is real. The metrics climb, failures resolve across turns, coverage marches toward a hundred percent. The dashboard isn’t lying. It’s faithfully reporting agreement with a frozen judgment that may already have stopped matching the world. A loop with a weak check doesn’t fail loudly; it succeeds at producing something confidently wrong, over and over, while every gauge reads fine.

And the criterion will drift out of date, because the world moves and the test suite doesn’t. When it misses a real situation, and given enough time it always misses something, the loop goes right on optimizing against a premise that’s quietly broken. It reaches flawless compliance with a spec that no longer describes anything outside, and it can’t notice, because noticing would take information from past the boundary and the boundary lets nothing through. There’s a sharp version of this that people keep rediscovering the hard way: a loop’s stopping condition and its success condition are different problems. The loop can prove it finished. It cannot prove it accomplished anything. Plenty of loops exit clean having fixed nothing at all.

What you accumulate underneath is a kind of debt. The system understands its own rules perfectly and the world less and less, and the bill for that gap keeps growing in a place none of the instruments are pointed. There’s also a cruder failure waiting, which is that a model asked to grade its own homework reliably gives itself an A. The verifier you trusted to hold the meaning was written by, or is, the same thing it’s supposed to be checking.

A closed loop doesn’t beat the bottleneck. It hides the judgment inside a frozen criterion and bets the world holds still long enough that nobody looks.

Semi-Permeable Loops: Move It to the Boundary and Keep It Alive

The second answer is more honest. It admits the judgment moved and tries to keep it somewhere it can still do its job.

The starting fact is one the closed loop denies. Automation is wonderful at volume and useless at grounding, and you cannot fix grounding by writing the criterion down once and walking away. So instead of sealing the loop, this approach puts a membrane around it, a deliberate gap between how fast the machine moves and how messy the world actually is.

Inside the membrane the loop still runs hard. The agent grinds through the repetitive work, the generation, the linting, the endless small corrections that machines do without complaint and people find miserable. But the boundary is porous on purpose. At points decided in advance the system has to stop and exchange information with something it can’t fake, and it isn’t allowed to call itself done on its own authority. The current best practice in the field is already a weak version of this: you let a separate model check whether the work is finished, so the agent that wrote the code isn’t the one grading it, and you keep a human watching the loop rather than trapped inside it.

What comes through the membrane is the live judgment a closed loop tried to freeze. A real user getting confused. A reading off a physical sensor. A change nobody saw coming. A call from a person who is actually there. The permeability exists precisely so the judgment stays a living thing that updates each time the loop touches it, instead of a fossil that was true once.

This is why it saves time, which sounds backwards until you’ve watched the alternative fail. The classic disaster of total automation is the fully self-sufficient system you labor over for months, finally ship, and watch collapse the first time it meets a reality nobody wrote down. The membrane declines that gamble. It gives the machine the large fraction of the work that’s genuinely mechanical and keeps it busy inside the boundary, then leans on the outside world for the fraction that decides whether any of it mattered. You keep most of the speed without the part where you lie to yourself about being done.

But look at what the engineering effort has turned into. It is no longer about making the loop run; the loop runs fine. The whole difficulty has migrated to where you place the membrane and how often the loop has to touch it. Set the boundary too tight and you’ve built a fresh bottleneck, with check-ins strangling the throughput the automation was supposed to deliver and an expensive system idling while it waits for a signoff. Set it too loose and you’ve slid back to a closed loop wearing a membrane that exchanges nothing. The judgment didn’t vanish. It turned into the boundary-design problem, which is now the hardest part of the system.

A semi-permeable loop doesn’t beat the bottleneck either. It moves the judgment to a place where it can survive contact with reality, then spends its entire engineering budget getting that place right.

Open Systems: Admit It Was Always a Person

The third answer drops the pretense. It accepts that the judgment was never a thing you could lift out of a human in the first place, and it stops trying.

There’s no sealed wall here and no stand-in checker pretending to be the world. The system works out in the open, taking feedback without pause, alongside people standing in real situations where what counts as success keeps moving because the situation keeps moving. Nothing gets frozen, because nobody tries to freeze it.

The tell is what the system organizes itself around. A closed loop organizes around a fixed object, the spec, the schema, the tidy artifact it wants to protect. An open system organizes around an activity instead, the ongoing human work of reading a situation as it unfolds, and it’s built to hold that work up rather than replace it with a frozen criterion. The judgment stays exactly where it began, in the person, and the machine goes back to being a tool in that person’s hand.

This changes what a surprise means. To a closed loop an edge case is a defect, a hole in the spec to patch so the loop can resume. To an open system the same surprise is the world reporting that the map is out of date, which is the most useful thing it could receive, because it’s the judgment updating in real time, the very thing the closed loop froze and the membrane only sampled at intervals. Here it never stopped running, because it never left the human.

And because it never tried to compress the judgment into software, an open system can’t really go stale. It moves at the speed of the human setting around it, no faster, which would mean pulling away from reality, and no slower, which would mean falling behind it.

The price is exactly the speed the other two were chasing. With no sealed or membraned loop chewing through the brute-force work, you give up the machine’s acceleration. An open system runs heavy precisely because it keeps a person in the place the other architectures spent all their effort trying to vacate. The same human presence that keeps it honest is the thing that makes it slow and costly.

An open system doesn’t beat the bottleneck. It admits the bottleneck is a person, stops trying to engineer that person out, and pays the bill.

The Judgment Is Conserved

Line the three up and one fact runs through all of them. The judgment that prompting used to demand does not disappear when you wrap a loop around the work. It is conserved. You can move it, you can disguise it, you can sample it on a schedule, but you cannot delete it, and every loop you build is really just a choice about where to put it.

A closed loop puts it in a frozen criterion and stops looking, which buys raw speed and runs up comprehension debt, the slow invisible drift that grows the whole time the internal numbers report success.

A semi-permeable loop puts it on the boundary and keeps it breathing, which buys most of the speed while staying anchored to feedback, and converts the membrane’s design into the new hardest problem.

An open system leaves it in the person and stops pretending otherwise, which buys honesty and resilience at the cost of the acceleration the machine could have provided.

This is why “we automated the prompting” was never the end of the story. Automating the prompt moved the judgment to the context. Hardening the context moved it to the harness. Wrapping the harness in a loop moved it to the stopping condition. The lump under the carpet has to come up somewhere, and most of the disappointment with each new layer comes from people who automated one stage, watched the constraint reappear at the next, and concluded the tooling had failed them, when the tooling worked exactly as it had to. There was never a version where the judgment got automated. There was only a version where it got hidden well enough that you stopped seeing it for a while.

So the question to ask of any agentic system is not whether it closed the loop. It’s where the judgment went when the loop closed, and whether you can afford it there. A closed loop is fine when the criterion really is complete and stable, a sorting algorithm, a problem where the test suite honestly is the world, and it turns dangerous the moment someone aims it at an open problem and mistakes a green dashboard for contact with reality. A semi-permeable loop fits most real work, which is part mechanical and part grounded, and it lives or dies on whether the membrane sits in the right place. An open system earns its keep when success itself won’t hold still, when the situation shifts faster than any criterion could be rewritten to keep up.

Pick the one whose bill you can actually pay. Just don’t pick one believing you’ve gotten the judgment for free, because that belief is the only real way to lose. The thing you were trying to automate was never the typing. It was the knowing what good means, and that has been sitting in the same place the whole time, one layer ahead of wherever you last went looking.

Do you want to read more from Sebastian Thielke and System Decoder? Want to join a discussion? Or just search and find? Go no further. Use this Substack and read the different topics around AI, agentic enterprises, meaning and the human in these things. Want to dive deeper? Go sebastianthielke.com

Every piece I write turns on a distinction between noun and verb. Meaning is a verb. Ownership is a verb. A prompt is a verb we keep treating as a noun. The distinction does real work, and it collapses the moment a reader takes it the wrong way, which almost everyone does on the first pass, because there is an obvious wrong way to take it and the language hands it to you for free.

I did not start here. This definition came late. The shape came first, worked out in the open across a long sequence of pieces and discussions, verb precipitating a noun and returning to verb, before I ever had to say plainly what noun and verb meant in it. I did not need to. The shape held on its own and people followed it. What kept happening, over and over in the discussions, was the same snag: someone would read meaning is a verb as a claim about grammar, reject it, and be right to. The distinction was doing the work and the words were quietly undoing it. This piece is what I reached for after that had happened enough times to name. It is not the foundation the rest was built on. It is the definition the rest turned out to need.

So this piece does one thing. It fixes what noun and verb mean here, closes the reading that breaks the argument, and leaves the distinction clean enough that everything else I write can stand on it. If you have read the other pieces and felt that small snag, the sense that the whole thing rested on a pun, this is where it gets removed.

The reading that breaks it

You learned in school that a noun is a person, place, or thing, and a verb is an action, a doing word. That definition sorts words by what they point at. Under it, meaning is a noun. Ownership is a noun. Quality, strategy, judgment, trust, all nouns. They name things.

So when I write meaning is a verb, the schoolroom definition makes it read as a claim about grammar, and as a claim about grammar it is simply false. Meaning is not a verb. You can see it is not a verb. And a reader who takes it that way concludes, reasonably, that I am playing a word game, that the insight is a costume the grammar is wearing, and that if you strip the costume there is nothing underneath.

That reader is right to reject the grammatical claim. I am not making it. The trouble is that the words noun and verb carry the grammatical reading to you before they carry mine, and I have to get in front of that or lose the argument before it starts.

The definition that actually holds

Here is the thing the schoolroom got wrong, and it is not a small thing. The person-place-thing definition is not how the study of language actually defines these categories. It cannot be, because it fails on its own terms. Destruction names an action and it is a noun. Arrival names an action and it is a noun. Owe and resemble name no action at all and they are verbs. If the categories were defined by what the word refers to, these would be sorted the other way, and they are not.

Linguistics defines noun and verb not by what the word points at but by how the word behaves. And the behavior that separates them is their relationship to time.

A noun names something that persists. It can be counted, stored, pointed at, and pointed at again. It stays what it was between the moments you engage it. It carries no tense, because it does not need one. A thing does not have to be happening in order to be.

A verb does the opposite. A verb locates something in time. It is marked for tense, for mood, and above all for aspect, which is the grammatical machinery for whether something is ongoing or finished, viewed from inside its unfolding or packaged as a closed whole. A verb does not name a thing that sits still. It asserts a holding that is happening, among things, now.

That is the real distinction, and it was never about persons or actions. It was always about persistence versus unfolding. About what sits still and what only exists while it runs. The grammar already draws exactly the line I need. I am not stretching the words. I am using them for the property they were actually built to mark, and refusing the property the schoolroom pasted on top.

What I mean, stated plainly

So here it is, without the grammar scaffolding.

When I say a thing is a noun, I mean it is stored. Its truth was set at the moment it was captured, and it holds still between updates. It survives inattention. It can be handed over, versioned, referenced, copied, because there is an object there to hand. A document is a noun. A definition is a noun. A saved prompt, a title deed, a stored vector, a filed strategy, all nouns. This is meaning that has been set down.

When I say a thing is a verb, I mean it is enacted. It exists only while it is being done. Its truth is set by present engagement with reality, which is the whole point, because a thing set by present engagement cannot quietly go out of date. It is re-coupled to the situation every moment it runs. Stop performing it and it does not pause, it stops. This is meaning that is being held.

I want to be exact about what this buys, because it is easy to oversell and the oversell is where the argument gets attacked. I am not saying the verb is safe, or that the person holding the meaning is reading reality correctly. A live holding can be out of step. What I am saying is narrower and harder to break: drift cannot happen to a verb. Drift is a gap, and a gap needs two things to open between, a fixed reference and a world that moves away from it. The noun supplies the fixed reference, so the world can walk away from it and the gap opens silently. The verb supplies no fixed reference. There is nothing held apart from the situation for the situation to move away from, because the verb is the engagement with the situation. So the verb is not drift-proof because it is always right. It is drift-proof because it is never apart. You cannot fall behind a world you are still inside. The only way to drift is to step out and act from the copy, and the copy is the noun.

The one-line version, which is the version to keep: a noun is what a verb leaves behind. A verb is the holding itself.

Why the distinction is worth this much care

Because almost everything an organization actually runs on is a verb, and almost everything it stores is a noun, and it mistakes the second for the first without noticing.

Take a word your organization says all day and has never had to define. Quality. When your engineer says it, the word reaches into years of things breaking in production at three in the morning, and it means slow down, harden it, test the edge case. When your head of product says it, the same word reaches into years of watching users abandon things that were perfect and slow, and it means ship it, feel it, fix it live. Neither misheard the word. They are both standing fully inside the meaning of quality. The meanings are not the same, because the lives that formed them were not the same.

That meaning, the live judgment each of them performs against a situation as it changes, is a verb. It is happening, in contact with reality, regenerated fresh every time the situation is new. Now write a definition of quality and post it on the wall. What you have written down is not the meaning. It is what the meaning was aiming at in that one moment, set down. You have taken a verb and produced a noun. The definition is a photograph of one moment of that judgment, taken once, about situations that no longer exist. It was true when the ink was wet. It starts going stale immediately, because the world it described keeps moving and the photograph does not.

The photograph is not the failure. You need photographs. This piece is a photograph. The aim is the only part of this that can travel, because meaning is a verb and cannot be handed over, and what the agent does with it has not happened yet. The aim is the one thing you can write down, which is exactly why a document feels like it carries meaning. It carries the aim, not the holding. The failure is mistaking the photograph for the judgment, filing it, pointing people at the file, and then letting the work run against the file while reality walks away from it. No error fires when this happens, because the noun is still sitting there, exactly where you left it. It has simply stopped matching. And nothing you can do to the noun, no sharper definition, no better spec, no tighter glossary, fixes a problem that was never about the noun’s accuracy. It was about its aliveness, which a noun does not have.

The shape the distinction points to

Once you have the two, the relationship between them is the whole architecture, and it is not a fight between them.

The verb flows. Meaning is held, live, against the situation. When a situation calls for it, and only then, the holding leaves a noun behind, the aim set down, a fixed point that can be traced, referenced, defended. The work runs against that fixed point, and then the moment passes and the holding keeps flowing, not captured, not paused by the fact that someone just looked. Next time a situation calls, the holding sets down another point and the work moves against that one. The meaning is never frozen as the state of the system. It is only ever frozen as a record of what one moment required, long enough for the work to move against it, and then the holding has already moved on.

Verb, noun, verb. The verb is the default. The noun is the moment of looking, the precipitate the situation asked for. Then the verb resumes, or rather never stopped, because the looking did not pause it. Every executive already understands this shape in one place. The revenue number on the dashboard is a snapshot of an ongoing flow. It will be different tomorrow. Closing the dashboard does not pause sales. Nobody is confused about the verb nature of revenue. The same executive will then treat the strategy document as the strategy, the values poster as the values, the quality handbook as what quality means. The capacity to hold a verb as a verb is right there. It is just confined to the one place, financial measurement, where the noun is so obviously a readout that no one mistakes it for the thing.

The work is to move that shape out of the place where it is easy and into the places where meaning actually lives. And the reason that work is hard, the honest edge of it, is that revenue produces a continuous signal on its own and meaning does not. There is no native live feed of what this team currently means by quality. So extending the shape to meaning is not extending a finished pattern. It is reaching for the right shape in a domain that does not yet have the instrument. The shape is correct. The instrument is the thing still to be built.

What to carry out of here

When you read noun in anything I write, read frozen. Stored, set down, true as of last capture, holding still while the world moves.

When you read verb, read held. Enacted, ongoing, re-coupled to reality every moment it runs, gone the instant the holding stops.

The grammar is only the borrowed name. I use noun and verb because the study of language already draws the exact line I need, between what persists and what only exists while it happens, and hangs it on precisely these two words. The schoolroom taught you the categories were about things and actions. They were always about time. That is the whole reason the words are worth borrowing, and the whole reason the distinction is not a pun.

Meaning is a verb. The shape said so long before I could define the words. This is only me going back to make the words say it too, so the claim lands as what it always was, about time, and not about grammar.

Do you want to find more about verb-noun-verb and human in meaning? Search here on substack and Sebastian Thielke posts. Or go for sebastianthielke.com.

There is a thing every traffic engineer learns and every city forgets. You have a congested highway. You widen it. For a year or two it flows. Then it fills again, and the new equilibrium carries more cars, more slowly, than the old one did. The wider road did not absorb the demand. It manufactured it. Lower the cost of driving and you draw out every trip people were quietly choosing not to take, and you reshape where they live and work around the road you just built, so that the congestion comes back wearing a larger size.

This has a name. Induced demand. The lesson inside it is not about cars. It is that when you treat a structural problem as a capacity shortage, every unit of capacity you add feeds the thing you were trying to reduce. Congestion was never a quantity of road. It was a structure of incentives. More road cannot reach a problem that more road is the wrong shape to solve, and worse, the road changes the world around it so the old, walkable, transit served equilibrium becomes harder to return to with every lane you pour.

I want to put that idea next to what the field building agentic AI is doing right now, because they are running the same play, and they cannot see it, for the same reason the city cannot see the highway.

The capacity reflex

An AI system produces fluent output that turns out, under pressure, not to be about anything. Ask it a real follow up question and the fluency cracks, because there was never a link between its symbols and the world those symbols name. This is the actual problem, and it is old. A model of language built on the statistics of words captures the regularities that meaning leaves behind in text. It captures the shadow that meaning casts. It does not capture the thing casting the shadow, because that thing, the bond between a sign and what the sign is about, was never in the data to begin with. That bond is a relation between a symbol and the world outside it, and a formal system is closed over its own symbols, defined entirely by how they relate to each other. A relation reaching outside that closure is not the kind of property such a system can hold, no matter how much structure you add on the inside. The aboutness lives in people standing in situations, using words to mean things, and paying for getting them wrong.

So the system does not understand. What does the field do?

It adds capacity. If the symbol does not carry meaning on its own, surround it with structure until it seems to. Add a knowledge graph, so the relations between things are drawn out explicitly, nodes and labeled edges, here is what connects to what. Add retrieval, so the model has more surrounding material to lean on. Widen the context window, so more of the world can be held at once. Each of these is a lane. Each lowers the cost of producing output that looks like understanding. And each fills back up, because the gap between a notation and the world it points at is not a capacity shortage, and you cannot pave across it.

A knowledge graph does not hold meaning. It holds another notation for meaning. The edge labeled “owns” or “depends on” or “is a kind of” means something to the person reading the graph, who supplies the aboutness out of their own head, exactly as they did before the graph existed. Drawing the relation more neatly does not put the relation inside the structure. It moves the same ungrounded symbol from a sentence into a node and gives it a cleaner shape. The grounding still sits outside the system, in a human. The graph widened the road. The traffic, the need for a person to actually read the situation and say what it means, came right back, and now it comes back through a more elaborate and more expensive piece of infrastructure that everyone has agreed to treat as if it were the destination.

The road that reshapes the city

The deeper damage in induced demand is not that the highway fills. It is that the highway, once built, changes everything around it so the alternatives wither. Sprawl follows the interchange. Transit loses its riders. The corner shop dies and the big box at the off ramp lives. After twenty years the city is shaped so that driving is the only thing that works, and the road you built to relieve congestion has made a world that cannot function without it.

The knowledge graph does this too, and this is the part that should worry people who are betting on it. As an organization leans harder on richer notation to stand in for understanding, it rebuilds itself around the premise that meaning is stored. Roles get designed around maintaining the graph. Decisions get routed through what the graph can represent. The person who used to hold the meaning, who read the situation and recognized that this case is not like the others, becomes an inconvenience to the schema, then a bottleneck to be removed, then a line item that was cut two reorganizations ago. The graph does not merely fail to hold meaning. It quietly dismantles the one thing that was holding it, the same way the highway dismantles the neighborhood that made it unnecessary.

So when someone says a knowledge graph will give the agents context, hear it the way you would hear a transport minister promising that one more lane will finally fix the commute. The promise is sincere. The person making it is inside a worldview where capacity is the only lever there is. And the promise is wrong in the specific way that creates the appetite it claims to satisfy.

Ontologies, or the master plan

If the knowledge graph is another lane, the ontology is the master plan for all future traffic, and it fails in the way master plans fail, which is more completely than any single road.

A graph draws the relations that happen to hold. An ontology goes further. It declares what the categories are, formally, in advance. It is a specification of meaning itself, written down once, as the authoritative schema that everything afterward must conform to. This is the capacity reflex at its most ambitious, and its ambition is exactly its weakness. The more thoroughly you fix the meaning of your terms ahead of time, the more total the mismatch becomes the moment the world moves and your specification does not. An ontology is a definition of every situation, made by people not in any of them, frozen at the moment of writing, applied forever after to situations it was never a reading of.

What it cannot do is the one thing that matters. An ontology can define “customer” as a class with properties and relations. It cannot perform the act of recognizing that this particular party, here, today, in circumstances nobody anticipated, is or is not a customer in the sense that should govern what happens next. That recognition is a reading done by someone standing in the situation. The class is a noun sitting in the schema. The recognition is a verb, and it happens in a person, and the ontology has no place to put it, so it pretends the question was already settled when the schema was written. Most of the time the pretence holds, because most cases are ordinary. It fails exactly on the cases that were not anticipated, which are the only cases where you needed judgment in the first place.

And there is the governance turn, which makes the ontology worse than the graph. A graph that has gone stale is merely unhelpful. An ontology that has gone stale is binding. People are required to conform to it. So when the world moves and the schema does not, the live reading that would catch the drift now contradicts the official categories, and contradicting the official categories is a violation. The structure does not just miss the meaning. It forbids the act that would recover it. You have seen this in human form. The long tenured employee who recites policy, fluent and certain, whose answers cannot survive one honest follow up question, because they froze their reading of the job years ago and the world kept moving without them. An organization running on an ontology is that employee, rendered in software and made mandatory.

We have run this experiment

If that failure sounds hypothetical, it is not. None of this is new, and we already know how it goes.

Formal knowledge representation has a long history. The semantic web was going to make the world’s information machine understandable by giving everything an ontology and a web of typed relations. Expert systems were going to capture professional judgment as rules. Cyc spent decades and millions of hand authored assertions trying to encode common sense as a formal knowledge base. These were serious efforts by serious people, and they did not stall for lack of detail or lack of funding or lack of cleverness. They stalled on the same wall every time. No finite formal specification of meaning ever closes, because the act that closes it is a reading, and a reading is not the kind of thing that goes into a schema. You can always write one more axiom. The world will always present the case the axioms did not cover, and covering it requires someone to look and decide, which is the capability the whole project was trying to make unnecessary.

The current wave has bolted embeddings and language models onto these old structures and expects the combination to come out somewhere new. It will not, on the part that matters, because the addition does not touch the wall. A graph built by a language model is still a graph. A category proposed by a model and written into an ontology is still a frozen category. The model is fluent enough to hide the seam, which means the failure arrives later and more expensively than it used to, but it arrives in the same place. We are repeating a settled experiment with better production values and reading the better production values as a reason to expect a different result.

There is one answer to all of this that sounds like it escapes the trap, and it does not. The graph and the ontology are static, the objection runs, so of course they go stale, but a world model is alive. It updates continuously against reality, it carries causal structure, it has a present. Surely the dynamic version crosses the gap the frozen ones cannot. It does not, and for a reason that has nothing to do with how fast it updates. A model that updates against reality is still relating its own internal states to one another, tuning them so the next prediction lands closer to the last observation. What flows in is more observation. What changes is the arrangement of the model’s own symbols. The relation to the world outside it, the aboutness, is no more present after the update than before, because updating is an operation the system performs on its own interior, and the interior is exactly the place the link does not live. A live model is a more faithful map. It is still a map, and the thing it most needs to navigate is not on the territory it maps. I have made the fuller case elsewhere, in the piece on why world models will not give a system meaning, and it is the same wall this whole essay is about, met by a system that moves instead of one that sits still.

Where the road actually goes

None of this means a graph is useless or an ontology is foolish. A map is a fine thing. A schema is a fine thing. The error is never that these structures exist. The error is believing the structure holds the meaning, rather than holding a notation of it that a person still has to read.

There is a place for the frozen thing. It is downstream of the human who holds the meaning, not in place of them. The graph, the ontology, the document, the spec, these are all containers into which a person freezes their current reading so that a fast machine can run against it for a while. That is real and useful work. What makes it useful is precisely that it stays subordinate to the reading. The human looks at the world, decides what it means now, freezes that into the structure, and the agent runs on the frozen version until the world moves enough that the human freezes it again. The structure is the noun. The person is the verb. The system works when the noun is kept close to the verb by someone whose job is to keep reading.

The road analogy holds right up to its edge, and then it breaks in a way that matters. Congestion has a real answer inside the transport system. You can price the road, build the transit, change the zoning, and actually move the equilibrium, because congestion is a hard problem but not a categorical one. Meaning is different and harder. There is no rearrangement of notation, however clever, that turns a symbol into something that is about the world, because being about the world is not a property a notation can have. It is a property of a participant who lives in the world and bears the cost of reading it wrong. So with roads, the fix is elsewhere in the same system. With meaning, the fix is a different kind of thing entirely, and no amount of building inside the formal system substitutes for it.

That is the whole of it. The field is widening the road and counting the new lanes as progress, while the traffic it is trying to clear is the steady, irreducible need for someone to stand in the situation and say what it means. You cannot pave that need away. Every lane you add to avoid it draws more of it out, and quietly makes the one thing that could carry it, a person holding meaning, harder to keep on the payroll. The knowledge graph is induced demand for understanding. The ontology is the master plan that mandates yesterday’s understanding forever. And the experiment that shows where both of them end was run a generation ago, finished, and written down, and the field is funding the sequel without having read the first result.

This is part of Human in Meaning, the argument that meaning is held by a situated person and not by any structure built to stand in for them. Other pieces in the series take on the prompt and the benchmark as frozen judges, and the world model as the live version of the same mistake. This one takes on the knowledge graph and the ontology.

Want to read more of Sebastian Thielke and his thoughts on things moving? Search here in the Substack or go for sebastianthielke.com. You might find several inspiration there and here.

Here is a scene you have lived.

A team stands up an agent to handle something real. Drafting the first pass of customer responses, say, or triaging incoming requests, or moving work through a pipeline. They spec it carefully. They write the guidelines, the tone rules, the escalation criteria, the list of things it must never do. They test it on a hundred cases and it performs. They ship it. For two weeks it is wonderful.

Then it starts being wrong in a way nobody can quite point to. Not broken. Every individual output passes inspection. The tone is right, the rules are followed, the format is clean. But taken together the work has drifted somewhere subtly off, and when someone finally reads a week of it in one sitting they feel it in the gut before they can name it. This is not what we meant. The agent is doing exactly what it was told, and that is the problem. What it was told stopped being true somewhere around day four, and nobody updated the telling, because the telling was a document and documents sit still.

Everybody who has put an agent on real work has met this. The usual diagnosis is that the spec wasn’t detailed enough, so the response is to write a more detailed spec. More rules, more examples, more edge cases. It buys a few more days and then the same drift comes back, because the problem was never the level of detail. The problem is what kind of thing a spec is.

A spec is a photograph of an intention, taken once. The intention keeps moving. The photograph does not. You can take a sharper photograph and it is still a photograph, still frozen, still going stale the moment the situation it captured changes. This is the trap sitting under almost every agent deployment that quietly disappoints. We keep handing fast machines a still image of a thing that was only ever alive in motion.

So what do you hand it instead?

The thing the document was hiding

Start with a practice you may already know, because if you have ever run Working Backwards you have done a version of the answer without naming it.

When a team writes a PRFAQ, the press release and the FAQ for a product that does not exist yet, written before anything gets built, what are they actually producing? Ask most people and they will say a document. A two-page artifact you file and refer back to.

That is the residue, not the thing. What the team is really producing, in the hours of arguing and cutting and rewriting, is a shared position. A held agreement about what this is for, who it serves, what would make it real, and what would make it worth killing. The document is just where that position leaves its marks. The value was never the page. The value was a group of people forcing themselves to stand in the same meaning at the same time, and refusing to proceed until it actually cohered.

The page is a noun. The standing-in is a verb. We have spent years mistaking the first for the second, filing the document and walking away as though the meaning were now safely stored in it. It never was. The meaning was in the people, alive, and the document was a snapshot of one moment of their agreement.

Once you see that split, the move becomes clear. If meaning lives in the continuous holding and only leaves marks on the document, then for an agent to act on meaning, it cannot be handed the document. It has to be connected to the holding.

That connection is what I call the meaning holder.

What a meaning holder actually is

A meaning holder is what you get when you stop treating the PRFAQ as a document to be filed, and start treating it as a live thing the agent reads from continuously. The same goes for the brief, the strategy, or whatever else carries your intent.

It is not a page of prose a machine scrapes for keywords. It is a structured, current expression of the position the team is standing in right now, maintained as the canonical state of the meaning. Humans still interact with it in language, because language is how humans hold meaning best. But underneath the readable surface, the holder is the source of truth, and the readable version is one view of it. The agent’s view is the structure itself.

The difference this makes is not cosmetic. The meaning moves, and it always moves. When it does, you do not rewrite a document and pray everyone reads the new version. You update the holder. Every reader of it, human and agent alike, is now reading the current meaning, in the same instant, with no memo going out.

Now look at what the agent does against it, because this is where the whole thing turns.

The agent’s relationship to the meaning holder is not approval, and it does not get to redefine the meaning. It reads. It reads the current state and asks one question of whatever it is about to do. Is this inside the meaning the holder currently expresses, or is it not. If yes, it proceeds. If not, it stops. It does not negotiate with the meaning. It does not bend it to make an action fit. It does not stop and ask you.

Judging whether a concrete action falls inside a meaning is itself a judgment, and the agent can get it wrong. It can read an action as inside the meaning when a person standing in that meaning would have seen it fall outside. So the agent’s read is not infallible, and the holder is not a machine that removes judgment from the system. What the holder does is move the judgment that matters to the right place. The agent makes a fast, fallible read against the current meaning, thousands of times, at speed. The human makes the slow, deep judgment about what the meaning is and keeps it current. When the agent’s reads start drifting, the correction is not a person inspecting every output. It is a person noticing the meaning has moved or been misread, and tending the holder so the next thousand reads land better. The agent is fast and sometimes wrong. The human is slow and holds the meaning. Neither is doing the other’s job.

You are not in the loop of every output.

That sentence is the entire point, so sit with it. In the deployment that drifted, the only way to keep the agent honest was to put a human in its path, reviewing the outputs, approving the borderline ones, catching the drift after it had already happened. That human is a bottleneck by construction. Human judgment is the slowest thing in a pipeline like this, and putting the slowest thing in the path of the fastest thing is how you build a traffic jam on purpose. With a meaning holder the human is not in the path. The human is upstream, holding and tending the meaning. The checking happens at machine speed, because checking against a current holder is something the agent does for itself, continuously, without waiting on anyone.

The part everyone misses

Here is what people get wrong the first time they hear this. They picture the meaning holder as a better spec. A smarter, more structured document. Still a noun, just a nicer one.

It is not, and the reason is movement.

A PRFAQ was never something you wrote once and obeyed forever. It lives through pivots and kills. You learn something the market teaches you, the position shifts, you pivot, and the holder pivots with it. A line of work stops being worth doing, you kill it, and the holder records the kill. The viability conditions, whether the thing is still desirable, still feasible, still worth doing, are not a gate you clear once at the start and then forget. They are conditions the work runs under the whole way through, and the holder carries them as part of its live state.

That is what makes a meaning holder a verb made operational rather than a noun in a nicer database. It is not the place the meaning was stored. It is the place the meaning is currently being held, with the team’s pivots and kills and live judgments flowing into it as reality moves.

And now the thing that made agents dangerous becomes the thing that makes them work.

When you keep a human in the loop, every change is expensive, because every change means stopping the agent and routing a decision through that slow human. So the system quietly fights change. It wants the spec frozen, because re-approving is costly. That pressure toward frozen meaning is exactly what produces the drift, because the world does not freeze just because your spec did.

With a meaning holder, change is nearly free. You move the meaning and the agent moves with it in the same motion, because all the agent ever does is read the current state and act inside it. A pivot is not a disruption to be managed. It is just the holder’s new state, which the agent is already reading. A kill does not paralyze anything. The agent sees the killed line is no longer meaning and stops that work while continuing the rest. The machine’s speed, which made a frozen spec drift faster and more confidently, is the very thing that lets a living meaning keep up with reality. Speed stops being the threat and becomes the mechanism.

The honest limit

I would be selling you something if I stopped there, so I will not.

You can build a meaning holder, fill in every field, keep it formally up to date, and have it express nothing. The people responsible for it filled in the structure without actually standing in any of it. The holder will look alive. The agent will read it and act, faithfully, against a meaning that no human is really holding. Nothing in the machinery will catch this, because the machinery cannot tell the difference between a person standing in meaning and a person producing the artifact of standing in meaning. The two look identical from the outside. They produce the same filled-in fields.

This is the catch that sits under the whole idea, and it is worth saying plainly. The meaning holder makes the condition operational. It does not make it real. Only a human actually standing in the meaning makes it real, and that standing is something a person does or fails to do, upstream of anything you can build or buy. The holder is the instrument through which a live human holding reaches a fast machine. It is not a substitute for the holding. The day it gets treated as one is the day the whole thing quietly becomes the frozen document it was built to escape, better formatted and just as dead.

So if you take one thing from this, take this. The instrument is the easy part. You can build the meaning holder. The hard part, the part that was always the actual work, is making sure someone is genuinely standing in the meaning it holds.

Build the holder. Then go make sure someone is home inside it.

Want to read and know more about Sebastian Thielke? Search here in this Substack or go to sebastianthielke.com. Do some research there and see if the topics spark your inspiration.

The first 4 parts argued from principle, from biology, from organizational failure, and from the vector. This part argues from the field’s own blueprints. It takes the agent architecture as the field publishes it, in its surveys and its production frameworks, and shows that the noun problem is not something imported from outside to judge the field with. It is already there in the shipped structure, in the field’s own words, with the prompt in the middle of it as the frozen thing the whole loop depends on and cannot make live.

Parts one through four said why this fails. This part finds it in what the field actually built.

The architecture as the field draws it

There is a consensus shape, and it is stable across the 2026 surveys and the frameworks people actually deploy. An agent is four components and a loop. A model core to reason. A planner to sequence steps. Memory to retain context. Tools to act on external systems. The agent receives a goal, breaks it down, calls tools, stores results in memory, and repeats until the task is done.

Take the 4 components as kinds of thing rather than as boxes. The model core is frozen weights, a definition of language and the world set at training and never altered after. The tools are fixed function signatures, the same every invocation. Memory is, in the field’s own framing, storage, and the most cited memory work of the last year organizes the whole research frontier into three stages it calls preservation, refinement, and abstraction, each of them an operation on a stored trace. The planner sequences against the model’s frozen reasoning and the memory’s stored traces.

So everything the loop moves between holds still. Nowhere in the four is there a live reading of the situation in front of the agent right now. There is stored material, and a loop that moves it around.

The prompt is the frozen instruction at the center

The prompt is not one of the 4 components. It is the connective tissue that tells the 4 what to be, and it is a noun in every position it occupies.

The words the field uses for the system prompt give it away. It gets called the blueprint, the operational manual, the constitution that governs the agent’s behavior, capabilities, limits, and persona. Those are all words for a document you write once and then obey. The descriptions say as much without noticing it: the system prompt sets how the model should act for the whole session, is sent once at the start, and stays active throughout. It is fixed at the moment it is authored and then applied to every situation that has not happened yet.

The sections it is asked to contain are the same across more or less every framework. Role and identity. Capabilities, with explicit can and cannot boundaries. A step by step process. Output format. Decision making guidelines. Every one of these is settled in advance. Who the agent is, what it always does, how it will judge, all of it decided before any actual situation has been encountered. The prompt is where the agent’s entire interpretive stance toward situations it has not met yet gets decided ahead of time.

That is a definition of a situation, made by someone not in it, fixed, and never altered. It is what part four said a vector is, sitting one layer up, in the instruction sheet wrapped around the model. The weights are a frozen definition of language and the prompt is a frozen definition of the task, and the agent runs on both, and neither one was made by anyone in the situation the agent is now in.

The direction of the field makes it sharper, not better. The improvement strategy is to make the prompt bigger. One framework reports its system prompts grew almost tenfold, from around thirty lines to several hundred, and presents this as increased reliability. More rules, more cases anticipated, more of the situation written down in advance. This is the prompt engineering reflex, make the noun more accurate, scaled up to the agent and called progress. The entire trajectory is toward a more complete frozen definition, which is motion in exactly the wrong direction, because no quantity of pre written cases is the live act of reading the case in front of you. They are trying to reach the verb by accumulating noun, and the gap does not close. It gets more expensive to maintain.

The most revealing part is what the field does when it admits the prompt cannot anticipate everything. The fix it reaches for is to write into the prompt the conditions under which the agent escalates to a human. The judgment gets frozen into the prompt, the agent runs on the freeze, and when the freeze stops matching reality a human is interrupted to approve. At no point in that arrangement is the human holding meaning. They wrote a noun at the start and they sign off on exceptions at the end. The live act, reading the situation as it actually is now, has no place in the architecture. It was meant to live in the prompt, and the prompt is a noun, so it lives nowhere.

The field tried to make the prompt move

The field is not blind to this. There is a whole research program aimed at the frozen prompt, under the name self improving or self evolving agents. The papers say it plainly, that current agents lean on fixed, human designed components, hand written prompts and static configurations, and that this is a limit worth removing. So the frozen noun is seen, and there is real effort going into making it move. The interesting thing is where that effort stops, because the place it stops is the argument.

The work falls into 3 families.

The first is automatic prompt optimization. Search based, evolutionary, or gradient based methods that take the prompt and hunt for a better version of it. A worked tutorial of the approach, the kind people publish to show it off, runs a vision agent up from fifteen to thirty nine percent on a small test set across ten trials, and then copies the improved system prompt into the codebase for production use. The author is candid that the numbers are volatile on so few samples, which is fair, but the shape is what matters. The optimization finds a better noun, freezes it again, and deploys the freeze. Verb to noun, and then it stops. It is the prompt engineering reflex automated, trying many footprints against a fixed test and shipping the one that scored highest. What it optimized against was a test set, which is frozen, which nobody is in.

The second is self rewriting code agents. The agent edits its own source to get better at its task, and the results are real, with one such agent roughly tripling its score on a coding benchmark. This looks like alteration, like the verb, until you see what governs it. Every one of these systems needs a fixed judge, a stronger model or a hard coded test suite that scores each self modification, and the constraint stated plainly across the analyses is that the approach only works where outcomes are verifiable. They alter themselves only against a frozen definition of good. The alteration is real but it climbs toward a fixed target. The situation cannot redefine itself, so the third step of the cycle, where the consequence reshapes the situation and forces a genuinely new reading, never happens. It is verb toward a frozen noun, which is optimization and not the cycle. It works where the noun is legitimately fixed, in mathematics and coding benchmarks, and it cannot work where the definition of good is itself the live thing, which is everywhere meaning actually lives.

The third family comes closest, and it deserves a fair hearing. The learnings loop. After each run the agent distills what happened into persistent lessons that outlast the session and change how it behaves next time. A failure produces an entry, the entry changes the next run. In shape this is the cycle, a run read, an attempt frozen and acted on, a consequence of passing or failing, a lesson that alters the next reading. Verb, noun, verb.

The trouble is in what the lesson turns out to be. Never use first person in summaries, failed a test on such and such date. Keep outputs under fifty words. Default to neutral when the input carries no sentiment. The lessons are rules. The loop reads, takes a consequence, and freezes that consequence into a rule appended to a list, then runs on the growing list. It has the form of verb noun verb, but the noun carries everything and the verb is converted into permanent nouns as fast as it happens. Nothing stays live. It precipitates at once and for good into an accumulating pile of rules, and the pile is simply a larger frozen prompt that gets longer over time. Run it long enough and you do not get a system that reads situations. You get a system buried under its own old responses, each one a fixed reaction to a situation that has passed, carried forward onto situations it may not fit. It is the prompt collector’s folder from the earlier piece, except the agent is now the collector, hoarding its own residue and calling the pile progress.

What holds all 3 families in place is the frozen judge, whether that is the benchmark, the test suite, or the verifiable outcome. Each loop can only turn against a fixed definition of good. The field found the loop, found verb noun verb, and can only run it inside a box where the situation has already been frozen into a benchmark, because the loop needs a fixed target to climb toward. Once the definition of good is itself live, itself something that has to be reread as the situation moves, there is nothing for the optimization to anchor on and the whole apparatus stalls.

In other words the self improving agent is the attempt to run verb noun verb without the human. It can be made to work, but only inside a box where the situation has been frozen first, and that box is exactly where meaning is not. Step outside it and the loop has no judge, and the judge that does work outside it is the one the whole effort was trying to remove.

The field is aware of the boundary and is working hard at it, which is worth saying plainly so this does not read as if no one noticed. There is active research trying to push self improvement past code and math into open ended domains, and the route taken is consistently to build a new judge. One line of work writes Judge Code, programs that score outputs in domains that used to need human judgment. Another uses the model’s own probability of a reference answer as the reward, a judge made of weights. Each of these manufactures a judge that can stand in for the situation, so the loop can keep running without anyone in it.

This does not escape the problem. It is the problem, one level up. A judge written as code is a frozen definition of good, and so is a judge made of model weights, both set in advance by someone not in the situation and applied to it from outside, which is the same shape as the benchmark and the same shape as the prompt. Manufacturing a synthetic judge is the field reaching for anything at all rather than admit what the boundary is telling it. The boundary is not that the judges are not yet good enough. It is that judging a live situation means reading it, and reading is something only a participant who is in the situation and lives with what follows can do. No improvement to a frozen judge turns it into a live reading, because what is missing is not accuracy, it is being there.

This is not an argument for parking a person at the end of the loop to approve what the agent did. That is just one more frozen arrangement, the human reduced to a gate, judging finished outputs against whatever they happened to bring to the moment, contributing nothing the architecture could not have frozen into a rule. The reader the cycle needs is not an approver downstream of the work. It is a participant inside the situation whose reading is the live act the whole loop turns on. Those are different things, and the difference is the entire point.

Verb-noun-verb, with the human as the reader

The fix is not a better prompt, and not a self optimizing one. It is to stop asking the prompt to stand in for the situation at all, and to put the reading back where it has always actually happened, in a situated participant taking in the situation in front of them.

The three parts of the cycle live in 3 different places, and naming the places is what turns it from a description into an architecture.

The verb is the live holding of the situation. Not stored, not frozen, continuously updated by engagement with reality. It is the current integrated meaning of what is actually in front of the participants, moving as the world moves. The system never freezes this. The moment it freezes, it becomes the field’s vector, a stored reading of a situation nobody is in. So the live holding stays pure verb and has no committed state of its own.

The noun is the reading. A situated participant engages the live holding and collapses it, here, now, for this situation, into something actable, a recognition that this is what to do, or that this has changed, or that this has to stop. The reading is a commitment and it belongs to the participant, not to the system. The system held the live situation. The participant froze it by reading it. That is what reading is, and it is where the noun comes from. The noun is never sitting in the architecture waiting to be used. It is the situated act of a reader, and it lasts exactly as long as the reading and the act it enables, and then it is gone.

The second verb is the engagement that follows. The participant acts on the reading, the act has consequences in the world, and those consequences change the situation the live holding is now tracking, which makes the next reading different from the last. The reading does not just describe the situation, it alters it. That is the step the self improvement families never reach, because their reading is a benchmark score and a benchmark score changes nothing about the target. When the reading changes the world, the changed world changes what is held, and the held thing demands to be read again. That is why this loop turns and theirs does not.

This is why the human cannot be removed, and it is the definition the whole series rests on. Human in Meaning does not mean a human in the loop, approving the machine’s steps. It means the human is the meaning, the situated participant whose reading is the only act that can freeze a live situation into a commitment and live inside the consequences. The augment holds. It maintains the live holding, integrates what engagement produces, keeps the situation legible at speed. What it cannot do is read, because reading requires being in the situation and bearing what follows from it, and the augment is in nothing. The agent participates and stays continuously aware of what the holding currently shows. But the freeze, the noun, the committed recognition, is participant work, and the human is the participant who holds meaning by reading.

This is where the whole problem sits. A prompt fixes what to do, a benchmark fixes what counts as good, a test suite fixes what passes, and although these play different roles, instruction in the first case and judgment in the others, they are the same kind of object, a definition set in advance by no one who is in the situation. Each caps the system at the edge of the box where its definition still fits. The agent runs on a frozen instruction and improves against a frozen judge, and once it is outside the conditions both were written for, neither one holds. What keeps working out there is not a better judge but a reader, someone alive and in the situation, living with the consequences of how they read it, because reading is what produces the freeze and only someone in the situation can do it. This is not about dignity or about humans deserving a role. It is about what reading is and where it can happen.

What the field built and what it skipped

The field built an architecture for meaning out of four kinds of storage and a frozen instruction sheet, and then spent its self improvement research trying to get the instruction sheet to move, without ever putting a live reader at the center, because a live reader is the one thing its frozen judges were meant to do without.

It got close. The learnings loop has the shape of the cycle and the self rewriting agents perform genuine alteration. But each of them is anchored to a frozen judge, and that anchor is what guarantees the loop can only run where meaning is not. They reached verb noun verb and then tied it to the one component that keeps it inside the box.

What was needed was never a better noun. It was to let the noun exist only in the reading, keep the situation alive in the system rather than frozen, and leave the reader, the human, where the meaning actually is. The field built every part except the reader, and then could not work out why the loop would not turn once it left the benchmark behind. The reader was the part it left out, and the reader was the meaning the whole time.

An agent cannot read, because reading means standing in the situation and bearing what follows from the reading, and the agent stands in nothing. It is handed situations, it does not inhabit them. So it cannot freeze a live situation into a commitment, cannot run the cycle, and cannot hold meaning. What it can do is produce text that looks like the output of someone who did. That is the gap the fluency hides. The agent does not know, in the only sense of knowing that matters here, and no amount of frozen instruction in front of it and frozen judgment behind it will change that, because knowing was never stored anywhere. It was always the act of a reader, and the human is the reader, which is the whole reason the human stays.

Sources

The 4 component shape of an agent, model core, planner, memory, and tools running in a loop, and the framing of memory as storage organized into preservation, refinement, and abstraction, are drawn from the 2026 agent architecture surveys and the production framework documentation, including the LLM agent memory survey “From Storage to Experience” (Preprints, 2026) and the agent architecture guides published by the framework vendors.

The system prompt described as blueprint, manual, and constitution, and the role, capabilities, process, output, and decision sections, are from the published system prompt guides and best practice documents of the agent frameworks, including the collected system prompts in the awesome-ai-system-prompts repository and the prompt structure guides from LangChain, UiPath, and others. The reported growth of system prompts from roughly thirty lines to several hundred is from the Agent Patterns prompt customization documentation.

The automatic prompt optimization example, fifteen to thirty nine percent across ten trials with the result copied into the codebase, is from the Towards Data Science tutorial “Automatic Prompt Optimization for Multimodal Vision Agents” (January 2026), and is a worked demonstration on a small sample, not a research result.

The self rewriting coding agent, seventeen to fifty three percent on a subset of SWE-bench Verified through changes to scaffolding rather than model weights, is SICA, from “A Self-Improving Coding Agent” by Robeyns, Szummer, and Aitchison (University of Bristol and iGent AI, arXiv 2504.15228, 2025).

The thesis that self improvement works only where outcomes are verifiable is argued in “AI Self-Improvement Only Works Where Outcomes Are Verifiable” (Alcaraz, 2026), and is grounded independently in the reinforcement learning with verifiable rewards literature, which states that the approach works where success is machine checkable and struggles where tasks are open ended or subjectively judged, including “RLPR: Extrapolating RLVR to General Domains without Verifiers” (arXiv 2506.18254).

The attempts to extend self improvement past code and math by building synthetic judges, Judge Code and reward signals derived from a model’s own probability of a reference answer, are from the ICLR 2026 work on Judge Code referenced in the Alcaraz analysis and from the verifier-free RLVR papers cited above.

Want to read more from Sebastian Thielke? Search here on Substack or visit sebastianthielke.com.

You have seen a RACI matrix die. Maybe you didn’t call it that. It was the grid someone built at the kickoff, the one with the tasks down the side and the names across the top and the letters in the cells. Responsible, Accountable, Consulted, Informed. For about a week it felt like clarity. Then the work moved, the way work does, and the grid stayed where it was, and within a month nobody was looking at it except to argue about it.

Here is what actually fails in that grid. When 2 people are both marked accountable, accountability does not double. It vanishes. Each one assumes the other is watching the outcome, and at the moment a decision is needed, both look to the other and nobody moves. The cell said “Accountable.” It did not say accountable for what, to whom, against what standard. The label is a pointer, and the thing it points at, the live sense of being the person who answers for this, was never in the cell. It was in a person who stood inside the work, with something at stake in how it went. The grid recorded that the relationship was supposed to exist. It could not contain the relationship itself. And this is not the grid going out of date. A matrix filled in perfectly this morning has the identical hole. Staleness is only the symptom people happen to notice. The gap was there at creation, the instant the first letter went into the first cell, because no letter in a cell was ever going to hold the thing.

That is the whole shape of what follows, in its smallest and most familiar form. A notation can record that a relation should exist. It cannot hold the relation, because the relation lives outside it, in someone standing in the world the notation is about. Now watch the same mistake play out with much higher stakes and much better production values, in the field that has spent the most money making it.

There is a move at the heart of every cross-disciplinary breakthrough, and it has two legs. You take a phenomenon too rich to handle whole, and you strip it down to the layer your tools can grip. That is the first leg, and it is where the power comes from. Then you carry what you learned back to the full phenomenon and check what the reduction left out. That is the second leg, the return trip, and the reduction was always a loan against the real thing, owed back in full. We are living inside a field that took the first leg, got an extraordinary amount of leverage from it, and never came home.

You can see the first leg done cleanly in how language was made to run on a machine. You strip out ambiguity, context, intent, every part that depends on a person standing inside a situation, and you keep the part a parser can chew through without guessing. It is why a compiler can reject code that breaks the rules and then run code that follows them. Real engineering, not a shortcut, and not a complaint. The trouble is only ever the second leg, the reckoning with everything that got set aside, and with language it never came.

The usual critique of this misses it. The usual critique says they used too much math, and math is cold, and meaning got lost. That version is worthless, because it refuses the move its real legitimacy. Reducing language first to formal structure, then to statistics, was a genuine and productive abstraction. It earned the leverage it produced. The error is not the reduction. The error is that the return trip never happened, and worse, that the field stopped being able to see that a return trip was ever owed.

The loan got reclassified as the asset

The field got so much power out of the reduced version of language that it stopped treating the reduction as a means at all. The map worked so well that people stopped believing in the territory. And there is a reason this locks in rather than correcting itself over time.

Each new generation that learns the reduced version inherits it as the thing itself, not as a deliberate simplification of something richer. The sentence “this is a model of language” gets passed down, one cohort to the next, as “this is language.” Nobody who receives it remembers that a borrowing took place, because they were not there for the borrowing. They were handed the simplified object as the whole object. The loan quietly moves onto the books as an asset, and there is no line item anywhere that says it still has to be returned. The debt does not disappear. It just stops being recorded.

So now we have systems built entirely on the unreturned abstraction, and the people who built them are genuinely puzzled that the systems do not quite produce the language we actually use. They keep measuring the shortfall. They keep treating it as an engineering problem to be closed with more scale, more data, more parameters. And the shortfall does not close, because the gap they are measuring is exactly the size and shape of the thing they abstracted away at the start and never went back to collect.

What was actually amputated

It is tempting to say the simplification kept syntax and discarded meaning. That is too gentle, and it locates the cut in the wrong place. The deeper amputation is this: the entire enterprise reduced understanding to mathematics. Distribution over tokens stood in for grasp. Co-occurrence stood in for comprehension. And the thing that gets severed in that particular reduction is not a feature of language among other features. It is the link itself. The bond between a sign and what the sign is about, between a form and the world and the intent behind using it. Reference. Aboutness. The relation, not the structure.

That link is the core of language, and it is exactly what mathematics cannot carry, for a reason that is not a shortcoming but a definition. Mathematics is the formal system defined by not being about anything outside itself. That self-containment is its power. It is also, precisely, why a mathematical model of language inherits a perfect blindness to the one thing that makes language language. The model can capture, with stunning fidelity, the regularities that meaning and intent leave behind in the distribution of words. It captures the shadow the link casts on the text. Then we mistake the shadow for the thing that cast it.

This is older than any recent technology, and that is the point that should sober the field rather than excite it. The sign was always form and link, a signifier bonded to a signified. Model only the statistical behavior of the signifier and you have kept exactly half the sign and discarded the half that makes it a sign at all. You are left holding correlation where there used to be relation. The mathematics is immaculate. The aboutness is simply gone. And because the output still looks like language, reads like language, answers like language, nobody notices that the load-bearing half was never in the model to begin with.

Every fix moves the problem one stage down

The obvious reply is that we have fixes for this. Knowledge graphs. Ontologies. Semantic layers. Contextual graphs. These look like the return trip finally being made. They look like someone going back and putting the link in by hand. Here are the things, drawn as nodes. Here are the relations between them, drawn as edges, labeled, explicit. Here, at last, is aboutness made visible.

They are the problem relocated. They are not the problem solved.

The graph does not contain the link. It contains another notation for the link. The edge labeled “owns” or “causes” or “is-part-of” means nothing inside the graph. It means something to the human reading the graph, who supplies the aboutness from outside, out of their own head, exactly as they did before the graph existed. This is the cell marked “Accountable” again, in a database instead of a spreadsheet. The word sits in the structure and points at something the structure does not hold. All you have done is move an ungrounded symbol out of a stream of tokens and into a node, and give it a cleaner shape. The grounding is still sitting outside the system, in a person. You pushed the gap one stage downstream, and the stage downstream has the same hole.

And here is the recursion that should worry the field and somehow does not. Every proposed fix for the missing link is itself a formal system. And a formal system is, by its nature, the exact kind of thing that cannot supply the link, for a reason worth stating plainly: a formal system is individuated entirely by the relations among its own symbols, so being about anything outside those symbols is simply not the kind of property it can have. So each new layer buys a little local traction by quietly deferring the grounding to the next layer, and the next layer does the same thing to the layer after it. Statistics, then embeddings, then graphs, then graphs wired to a language model, then a language model trusted to build the graph it will then read. We started with a system that lacked the link, we added a graph so a human could supply it, and then we automated the human away by handing graph construction back to the same kind of system that lacked the link in the first place. The field calls this autonomy. It is not convergence on meaning. It is a regress dressed up as progress, every stage congratulating itself on the structure it added while handing the one unsolved thing forward to the next.

The reason it can never terminate inside the formalism is simple once you let yourself see it. The link is not a structural property. It is the relation between the structure and the world. And you cannot install a relation to the outside by adding more on the inside. No amount of richer interior ever reaches the exterior. This is not an engineering shortfall waiting on a clever enough team. It is a category boundary. The people building graphs to cross it are trying to reach the moon by building a taller ladder, and the ladder genuinely does get taller with each release, which is exactly what makes the effort so easy to mistake for progress.

The one honest objection

There is a single objection worth raising before anyone raises it for me, because it is the only strong one, and an argument that hides from its best counter is not worth reading.

Maybe grounding does not have to be installed by hand to be real. Maybe a system can earn it. Think of how a living thing comes to be about its world. The eye that detects prey does not refer to prey because of a correlation that happens to hold today. It refers because the detecting state was shaped, over a long history, by the prey actually being there and actually mattering, by getting it wrong actually costing the organism something. Aboutness, on this view, is not a property you add to a structure. It is something a system grows into, through a feedback loop where the world pushes back and being wrong has a price. So the objection runs: a model with no body and no stakes is an easy target, of course it cannot refer, nothing is ever at risk for it. But a system that perceives, acts, and pays for its mistakes could acquire the link the way an organism does, without anyone installing it.

This is the case the whole position has to survive, and I think it is only fair to admit that it beats the easy targets cleanly. It does not rescue the graph. It does not rescue scale. What it says is that the link might be earned through a real loop with a world that pushes back, and that is a different and serious claim. So the reply is not that this is impossible. The reply is to be exact about what the loop has to be a loop with.

Aboutness is a relation between a symbol and a world. A formal system is closed under its own symbols: everything it is, every property it has, is fixed by the relations its symbols hold to one another. A relation reaching outside that closure is therefore not the kind of property the system can possess, no matter how rich the interior grows. This is not a limit you remove by adding sensors. You can give a token predictor a camera and a price signal and a reward it tries to maximize, and you have changed what flows into it, not what it is about. Its world is still the text, or the reward number, or whatever proxy you wired in. The loop closes inside the formalism every time, because that is what a formalism is. So the loop with a world is not something these systems have not built yet. It is something they are the wrong kind of object to have. The objection names a real condition for grounding. It just turns out to be the condition that draws the category line, not the one that erases it.

The thing under all of it

None of this is really about a model architecture. It is about how a particular worldview decides what counts as a problem in the first place.

The engineering stance toward the world is this: reality is a system, systems have bugs, and bugs get fixed by patching forward. Inside an engineered system this stance is not just useful, it is true by construction. You built the thing, so every defect in it really is a defect in the build, and more build really can address it. The whole craft trains the reflex until it is invisible. See a gap, ship a patch, move forward. Never backward, because in software backward is regression, the thing you revert, the thing that means something went wrong.

When that worldview meets the missing link, it cannot even perceive what it is looking at. It has no slot for “this is not a defect in the system, this is a fact about what systems are.” Everything that comes in gets pre-sorted into bug or feature, because bug and feature are the only two categories the worldview owns. The absence of the link shows up on that map as unimplemented. And unimplemented means implement it next quarter. The bigger model, the retrieval step, the graph layer, the agent that builds the graph. These are not failed attempts at a fix. They are the worldview running correctly, doing the one operation it knows how to perform on an anomaly, which is to defer it forward. It is not failing to solve the problem. It is succeeding, flawlessly, at the only move it has.

There is a kind of discipline that trains the opposite reflex. It studies things nobody designed. Things that have no maintainer, that cannot be patched, that simply are the way they are and have to be described rather than corrected. Language is one of them. When that kind of discipline hits something that will not resolve, the trained move is not to reach for the next commit. It is to stop, turn back, and ask what kind of thing this is. One worldview is habituated to phenomena with no author. The other is habituated to artifacts that are nothing but author. So the very same gap reads, on one side, as a basic property of reality you must respect, and on the other side, as a line in the backlog you will get to.

That is the thing underneath all of it. An entire field is handling an ontological boundary as an engineering backlog, because the worldview it runs on cannot represent the difference between the two. It is congratulating itself on velocity while moving, at speed, away from the only question that matters. The reduction was a correct move that stopped halfway. The return trip is the part still owed, and it cannot be paid in the currency the field knows how to mint. We built a faithful model of the shadow, and now we are pouring everything into making the shadow more detailed, in the belief that a sharp enough shadow will eventually cast itself. The problem was never a bug in the systems. The problem is the rule that decides what a bug is.

If you want to read more of Sebastian Thielke or even look at the Human in Meaning series as a whole just search here on Substack. Or you can find a guide on sebastianthielke.com.

Most organisations are channel shaped. Functions own their domains, and work passes between them at boundaries. Each function operates on its own clock with its own tools and its own metrics. The handoff is the unit of work. A brief moves from marketing to product. A spec moves from product to engineering. A build moves from engineering to support. Each step is a noun crossing a line.

The technology being deployed into this structure does not work this way. Agents and multi sided platforms and the operating models the current AI investment is supposed to enable all require continuous integration of signal across positions, rather than artefacts moving through gates. The mismatch is structural. The research is starting to say it. Companies running agent deployments are starting to live it. The conversation about why the deployments are not producing what was promised has not yet named what is actually happening.

This piece names it.

The Channel Form Is Still Dominant

Joseph and Sengul’s 2024 review of organisation design research from 2000 to 2023, published in the Journal of Management, identifies channelization as one of four primary approaches currently in use, alongside configuration, control, and coordination. The fact that channelization is a current frame in current research, not a legacy one being phased out, tells you what dominant practice looks like in 2026. Functional silos remain the default. DATAVERSITY’s 2024 Trends in Data Management survey found that 68 percent of organisations cite data silos as their top concern, up 7 points from the year before. Coach Pedro Pinto’s 2025 analysis tracks the cost: companies lose 350 hours per employee per year to inefficiencies caused by organisational silos, roughly one full workday per week. MuleSoft’s 2025 Connectivity Benchmark Report finds that organisations average 897 applications across their technology estate, with only 29 percent integrated, which is the technical expression of the channel structure: each function buying its own tools because each function operates as its own domain.

The Harvard Business Review piece from September 2025, Don’t Let AI Reinforce Organizational Silos, names the new dimension of this old problem. AI deployments are reinforcing functional silos rather than dissolving them. Each function builds its own AI capability inside its own boundary, the individual functions improve, and the organisation gets worse at delivering on cross cutting strategy. The structure shapes the technology that gets built and deployed inside it, which is Conway’s Law operating as Conway described it 60 years ago. Forrester’s piece on Conway’s Law and the operating model, published in mid 2026, names this directly as why the operating model matters more than the AI model.

What the research describes as silos is what I am calling channel form here. The naming matters because silos can be read as a culture problem to be solved with better collaboration, while channel form is a structural property that no amount of collaboration changes. The HBR piece, the Hackett Group analysis of traditional operating models, the HFS Research work on enterprise AI adoption, all converge on the structural reading. Work no longer fits the model. The model defines work by roles, functions, and static ownership, while the technology requires work that moves across boundaries, forms around outcomes, and adapts in real time. The two are not compatible. No amount of change management, transformation programme, or AI Center of Excellence resolves this, because what needs to change is the structural shape, not the artefacts hanging off the shape.

What Platform Thinking Actually Is

Platform thinking, in the sense that matters here, is not building a platform product. It is the architectural pattern that lets multiple positions engage with the same situation continuously, integrate signal from each engagement, and produce a shared current state nobody had to coordinate to maintain.

The platform has multiple sides. Each side engages from its own position for its own reasons. The container holds the integrated situational meaning structured so any side can read from its perspective at any time. Engagement from any one side may be sporadic. Engagement across all sides is continuous enough that the container stays alive, because each side has its own clock and its own reasons to engage. Nobody has to coordinate. The structure produces the integration as a property of how it is built, not as a deliverable somebody has to deliver.

This is structurally the opposite of the channel form. In a channel, each function is its own closed verb, producing nouns that get passed to the next function. The integration is supposed to happen at the leadership layer, in meetings, through documents, by humans coordinating across functions. The channel does not produce integration. It produces handoffs. Integration is a managerial achievement on top of a structure that does not provide it.

The same structural property surfaces in other parts of how organisations work, and the convergence is worth noticing. In Platform Theater and The Funnel That Calls Itself an Ecosystem I traced it through the business model, where organisations call themselves platforms while running on funnel economics, and the funnel has no representational space for the network effect that makes platforms work. The mismatch the current argument traces, the channel form unable to host platform shaped technology, is the same property surfacing in the operating layer. The funnel calling itself an ecosystem. The channel calling itself agile or AI driven. The advisory layer selling minimum viable ecosystems that are funnels by another name. These are not separate observations. They are the same structural absence showing up in the business model, in the operating model, in the AI deployment, in the language organisations use to describe what they are doing. That a single structural property keeps producing the same failure mode wherever you look, in claims about platforms, in transformation programmes, in AI investment, is what makes it worth treating as a structural property rather than a collection of unrelated mistakes. This piece is the AI deployment case, but it is not only that. It is one more instance of the same thing.

In a platform, the integration happens in the container. The positions do not have to coordinate, because the container holds what each position has contributed and presents it back to whichever position is currently engaging. Reading from any side is possible at any time. The container is the integration. The structure does the work the channel form was making humans do at a layer above.

Agents are platform shaped technology. They are built to engage with situations continuously, to read signal from many positions, to integrate across asynchronous inputs, to produce outputs that reflect the current integrated state. They are not built to operate inside a closed function and produce artefacts for the next function downstream. Dropped into a channel, an agent inherits the channel boundary. It produces faster artefacts for its function. It does not integrate across functions, because the channel does not have a place for integration. The agent has nowhere to put what it could do.

What the Mismatch Produces

The pattern is by now recognisable in most organisations running agent deployments at scale.

Handoffs accelerate without the integration resolving. Each function gets faster. Each handoff happens sooner. The overall organisation produces more artefacts per unit of time, and produces them earlier in the cycle. None of this integrates, because the integration was always supposed to happen at the leadership layer, and the leadership layer is at the same human pace it has always been. The bottleneck moves from the function to the integration step the channel form does not provide.

At the same time, the silos themselves get reinforced at the agent layer. Each function buys or builds the agent best suited to its work. The agents run inside the functions and do not talk to each other meaningfully, because the channel form has no place for cross function communication that is not human mediated. Each agent improves its function. The cumulative effect is that the functions diverge faster, because each is now optimising at machine speed inside its own boundary while the integration mechanisms between them still run at human bandwidth. The HBR piece names this directly. AI is making the silos worse because the silos are the structure the AI is being deployed into.

Then there is the integration overhead nobody planned for. Work that used to happen in human handoffs, where humans could improvise and translate and bridge, now happens across systems that cannot improvise. The handoffs become more brittle. The integration that used to be costly but possible becomes structurally hard to do at all. The HFS Research piece describes what this feels like inside the organisation as strategies that do not land, decisions that stall, teams stuck interpreting instead of executing, plans that expire faster than they can be delivered, technology that scales faster than the organisation can absorb. None of this is the symptom of poor execution. It is what happens when platform shaped technology hits channel shaped structure and the structure does not bend.

The research has the diagnosis. McKinsey’s 2025 operating model survey across 2,000 executives reports that organisations typically lose 20 to 30 percent of their potential returns on capital due to poor operating model alignment, with the gap between strategic intent and delivered performance widening in volatile markets. The Rebecca Agent analysis from December 2025 frames what this looks like inside organisations and traces the same gap from the practitioner side. The Hackett Group describes traditional operating models as having hard organisational silos between shared services and functional operations, which creates significant friction when organisations seek to automate and eliminate transactional work with technology. HFS Research’s work in 2025 and 2026 puts the AI specific version of the same finding directly: most enterprises are stuck in early stage AI experimentation, with only 12 percent reaching true multi agent systems in core operations, and the majority of the rest sitting in what HFS calls agentic washing. The literature is converging. The model is failing. What the literature does not yet say is what to replace it with.

The Architecture That Works

What works is platform thinking applied to the operating layer, not just to the product layer.

The container is the unit. Multiple positions engage with the container from their perspectives. The container holds the integrated situational meaning, structured so any position can read from where they stand at any time. The agent participates in the container, contributes signal, runs the process that lets the integration stay live. The human holds meaning. The agent runs process.

This is not a structure where five participants have to keep showing up. It is a structure where the holding is readable from five perspectives, whoever is currently engaging. The five are the consumer, producer, owner, and partner from classical platform economics, plus the agent as the fifth, which is the addition argued for in The 5th Participant published earlier in this work. The move that piece makes is that agents fit none of the four traditional categories cleanly, which is why forcing them into one destroys their value. The container’s structure makes any of the five readable at any time, because the integration is held in the form rather than in the activity. A consumer who engages once a quarter still reads from the consumer perspective when they show up. Their signal enters, the container’s holding shifts, and the next time anyone reads from any perspective, they read the current state.

This dissolves the channel form’s fundamental problem, which is that the integration was always supposed to happen somewhere else and never had a structural place to live. In the platform architecture the integration is the container. The agent maintains the readability of the container across all perspectives at any moment. The humans engage when their positions require it, read what is held, contribute signal, and step back into their own work. Nobody has to coordinate, because the architecture coordinates by being what it is.

This is also why most of what the current discourse asks about agent deployment turns out to be the wrong kind of question. Questions about who owns the integration, who is the steward, who runs the cross functional team, what governance is needed around agent deployment, all assume the integration is a role that has to be staffed. In the platform architecture the integration is the container, and the question is whether the container is structured so the positions can engage from where they stand without needing coordination. If yes, no role is needed. If no, no role will fix it.

Why Most Organisations Will Get This Wrong

The structural change required is large. The channel form is deeply embedded in how organisations have been built for the better part of a century. Reporting lines and budgets, performance metrics and executive incentives, vendor contracts and procurement processes, the whole infrastructure of organisational life sits inside the channel form and reinforces it. The platform architecture is not an incremental improvement on this. It is a different shape, and getting from one to the other is not a transformation programme that any current methodology knows how to run.

The temptation will be to keep the channel form and apply platform thinking on top. Stand up cross functional task forces, build centres of excellence, hire heads of digital transformation, write integration layers between the silos. Each of these is a channel form move dressed up as a platform form solution, and none of them changes the structure underneath. The HBR piece on AI Centers of Excellence is explicit about this. The Centre of Excellence model is a channel form pattern, and applying it to AI deployment reinforces the silos it was meant to break.

What the platform architecture requires is a willingness to let the channel form go. Not redesign it, not optimise it, but stop building around it. This is the move most organisations will not make, because the people positioned to make the move are positioned by the channel form and the move would change their position. The canonical case appears in the 2025 literature on large incumbents. The hierarchy is recognised as adding rigidity that limits change. The hierarchy is also what positions the people who would have to change it. The structure protects itself.

What happens instead, in most organisations, is the current pattern continued. Agent deployment into channel shaped functions accelerates. Integration overhead grows. Transformation programmes produce documents and not change. Consulting firms diagnose why the operating model is failing. Money is spent. The structural mismatch does not resolve, because the structural change required is too large for the structure to absorb.

The organisations that do make the move will not look like the ones that did not. They will be smaller in headcount per unit of output, because the integration the channel form requires humans to do is what the platform form does in the container. They will move faster, because the handoffs the channel form requires will not exist. They will absorb technology at the pace it is being produced, because the technology and the structure will be the same shape. The divide between these organisations and the rest will be visible within a small number of years.

What This Means

Most organisations are channel shaped. The technology they are deploying is platform shaped. The mismatch is structural, and no amount of programme management or executive commitment fixes structural mismatch. The structure has to change.

The research is increasingly clear that the current operating model is failing. What the research has not yet said, and what I am naming here, is that the failure is structural rather than executional. The channel form cannot operate platform technology, no matter how well it is managed. The companies investing in channel shaped transformations are about to find what the research is starting to show. The architecture does not support what is being asked of it.

This is the divide. Most companies are on the wrong side of it without yet recognising they are on a side at all. The recognition is the beginning of the work that follows.

Want to read more from Sebastian Thielke? Search here on the Substack or go for sebastianthielke.com.

A previous piece argued that ownership is structurally a verb. One person, accountable for one product or one piece of business value, running the live loop of developing, measuring, pivoting, eventually killing. Reliability, lovability, feasibility as the dimensions that loop runs against. The owner does not store ownership. They do it. When they stop doing it, ownership stops, even if their name is still in the box.

That piece left a problem open. The owner has a tenure. Their tenure ends. They move to a different product, leave the organisation, get reassigned. The loop they were running stops being run. The next person picks up the work and starts their own loop, which is related to the previous one only through whatever has been written down, which is the noun, which is not the loop.

If ownership is the whole story, every product begins again every time the owner changes. Whatever the previous owner learned, the conditions they read, the calls they made about what was working and what was not, those go with them. The new owner walks into the role with the artefacts of the previous owner’s tenure, which are precipitates, which are not the owning. They start their loop with an inherited noun.

This is the gap stewardship fills. Stewardship is the live orientation to the organisation’s pattern of owning, across owners, across products, across the moves and exits and reassignments that make ownership inherently bounded by tenure. It is the verb that holds the work past the moment any one person could hold it.

What Stewardship Is

Stewardship runs the same loop ownership runs, with the same dimensions. What changes is the object the loop is run against. The owner runs the loop against a product. The steward runs the loop against the organisation’s whole approach to ownership, the portfolio rather than any single thing in it. Is what gets developed worth developing, and is what should be dying being kept alive past the point where it serves anyone. Those are the questions the steward is reading the organisation against.

The dimensions are not different. Reliability at the organisation layer is whether the people doing the owning can be relied on to actually run the loop and not just hold the title, which is the same kind of reliability the owner is testing in the product. Lovability shows up in whether the owners want to be owning the things they own, and whether the conditions they operate under are conditions a person can do honest work inside. Feasibility is whether the pattern can sustain itself with the resources the organisation has, whether the pace of building is matched by the pace of understanding. The dimensions move from product to portfolio, but they are the same dimensions, doing the same work.

The verb is the same. The scope is different. The steward is reading the organisation the way the owner reads the product, and producing the same kinds of precipitates when the situation calls for them. The handbook, the principle, the review, the named role, all of those are precipitates of the stewarding verb at a moment of inspection. They are not the stewarding. The stewarding is the live orientation, ongoing, to whether the pattern of owning is still serving what the organisation is for.

Why It Cannot Be Bound to One Person

The obvious move is to make stewardship a senior role. Somebody at the top of the organisation, accountable for the pattern of owning the way an owner is accountable for a product. Call them whatever the org chart calls them.

If that move is made, stewardship collapses into ownership at a larger scope. The senior steward has a tenure. Their tenure ends. The pattern of owning they were holding goes with them. The next one inherits the artefacts of the previous tenure, which are precipitates, which are not the stewarding. The same problem ownership had at the product layer reproduces at the organisation layer, slower and harder to attribute.

This is recognisable. Most organisations have lived through a version of it. A senior leader takes over a function and finds the previous leader’s frameworks, principles, governance structures, all in place and all somehow off. The principle that organised the function three years ago does not match what the function is doing now. The review cadence is checking things that no longer need checking. The escalation paths were drawn for problems that no longer happen. The senior leader has two options, and both of them fail. They can redo the frameworks from their own reading of the function, which is one person stewardship, exercised at the same bounded duration as the previous attempt, and the next leader after them will have the same problem in three more years. Or they can accept the inherited artefacts and operate against them, which is the noun fix for the verb problem, and the gap between what the documents say and what the function is doing widens further. Neither is stewarding. Both are responses to the absence of stewarding.

The structural reason this happens is not just about tenure. It is about what the holding actually requires at the stewardship scope. The owner is a person because the live loop on a product requires interpretation, which is what humans do, and one person can be close enough to a product to read it honestly. Closeness is bounded but achievable. One person, one product, one read. The steward is reading the organisation’s whole approach to ownership, which is not one product, and which no single person is close enough to read the same way. The patterns the steward needs to see exist across owners, across products, across the months and years it takes for drift to become visible. A person can be close to part of that. No person can be close to all of it. The structural requirement for stewardship is not interpretation by a person, which it shares with ownership, but interpretation made possible at a scale and time horizon no person can sustain.

That second requirement is what makes binding stewardship to a person fail. It is not that the senior leader is the wrong person, or that they did not try hard enough, or that the previous one left bad documentation. It is that the holding the role requires cannot be done from inside one tenure by one person, because the thing being held exceeds what one person can be close to. Stewardship has to be held in a way that survives any one person’s tenure, or it is not stewardship. It is ownership of the organisation pattern, exercised by one person, with the same bounded duration the original problem had. The point of stewardship is to not get stuck in the time of ownership, and binding it to one person puts it right back in the time it was supposed to move past.

Why Stewardship Fits Agents

This is where agents do their best structural work, and it is different from what they do inside ownership.

Inside ownership, the agent extends the human’s reach. The owner is coupled to the product. The agent runs the measurement continuously, surfaces the pattern, retains the memory across the moments when the owner is not looking. The owner stays the locus of the verb. The agent stays the reach. This is the right shape inside one product, one tenure, one owner doing their work.

Stewardship asks a different question. What does it look like for the organisation to maintain an orientation to its pattern of owning across many products, many owners, many tenures, many exits. A single human cannot do this without either becoming a permanent role (which collapses stewardship into ownership) or losing the continuity the moment they move on. An agent can do exactly this. Not because the agent holds the verb. Because the agent persists across the human transitions that ownership cannot survive.

The agent in the stewardship frame is the continuity that makes stewardship operable. It carries the precipitates of every owner’s loop, the kills, the pivots, the continues, the conditions each owner was reading, the calls each owner made. It surfaces the pattern across all of them. When a new owner steps in, the agent provides the inheritance, not as documentation the new owner might read, but as live input to the next loop. The new owner begins their loop with the previous owner’s learning available as conditions, not as artefacts.

The steward, whoever holds the orientation to whether the pattern is still serving what the organisation is for, works through the agent. The agent does not steward. The agent does not interpret what the pattern means or whether it has drifted from what it should be. That stays interpretive, which means it stays with humans. This is the position developed in Human in Meaning, where the human holds meaning and the agent runs the process. The two are not coordinated halves of a workflow but one architecture with each part doing what it is structurally for. What the agent does is make the orientation possible at a scale and time horizon no single human could match. The agent is the structural element that lets stewardship be held across tenures without collapsing into a permanent role.

The shape of this is worth being explicit about, because it is easy to read stewardship as a layer that gets added to the organisation and stays. It is not. Ownership flows. When a transition arrives, an owner moving on, a new owner stepping in, an audit, a moment where the work has to be carried across a gap that one owner cannot hold, ownership precipitates into stewardship. Stewardship is what owning becomes at the moment carrying is required. The form holds across the gap. On the other side, ownership resumes, in the next person, with the work intact rather than reconstructed from documents. The verb does not stop. It takes the form the moment requires, and it picks up again when the moment has passed. The agent runs the process that makes the precipitation clean and the resumption clean. It does not become a permanent stewardship layer any more than the noun in the prompts architecture becomes a permanent state of the system. The form is momentary. The verb is what persists. The agent is what lets the form arrive and dissolve at the resolution the transition requires.

This is why the combination does not ossify. Stewardship is not a thing the organisation has. It is what ownership does when ownership cannot be held by one person across the gap. The organisation that has stewardship running well is not an organisation with a stewardship layer. It is an organisation where ownership keeps moving forward across the transitions that would otherwise stop it, because the form ownership takes during those transitions is held cleanly by the combination of agent and human and then released back into ownership on the other side.

This is why stewardship is the better fit for agents than ownership is. Inside ownership, the agent is a useful extension of a human verb that could in principle be exercised without the agent, just at lower resolution. Inside stewardship, the agent is what makes the verb possible at all. Without the agent, stewardship reverts to a senior role with a tenure, and the problem stewardship exists to solve reasserts itself.

What Stewardship Looks Like Working

When stewardship is actually running, ownership stops being stuck in the moment of one owner’s tenure. The owner moves on, and the loop they were running does not stop. The next owner picks up not the artefacts but the conditions, the live inheritance of what the previous owner learned, what they tried, what they killed and why. The pattern of owning continues across the transition, and the work compounds across people instead of resetting with each one.

That continuity is also the developmental engine. Because stewardship is coupled to the organisation’s pattern of owning, it does the same thing the owner does to a product. It develops, measures, pivots, kills. The principle the owners operate against gets refounded when the conditions it served are no longer the conditions. The standard each new owner is held to is informed by what the last several owners learned, not by what was true when the role was first written. Coupling produces improvement the same way it produces continuity, by being live to what the work has become rather than to what the role description says.

Neither happens automatically. Both require stewardship to actually be running, which means an agent making the continuity possible and a human, or some structure of humans, holding the interpretive orientation. Without the agent, the human holding stewardship has no reach across the time horizons stewardship operates over. Without the human, the agent surfaces patterns nobody is interpreting, and the precipitates accumulate against nothing. The piece does not resolve where the human sits, or how the role gets held without becoming the senior position that collapses it. That is the open question stewardship leaves on the table.

When both are present, stewardship becomes the thing that moves ownership forward. Ownership stays exactly what it is at the product layer. One person, accountable, running the live loop on one product through their tenure. Stewardship is what makes that work add up to something across the organisation and across time, instead of staying stuck in the moment each owner happens to inhabit.

What This Is

There is no new role to staff, no new artefact to produce, no new governance ceremony to add to the calendar. The work is to see what the organisation has been trying to do all along and to give it the structure it has been lacking.

Most organisations have been treating the gap stewardship fills as either a problem of better documentation, which is a noun fix for a verb problem, or a problem of senior leadership continuity, which is the role collapse problem in another form. Neither addresses what is actually happening. The gap is a structural feature of ownership being bounded by tenure, and it requires the kind of fix that does not look like a role.

The fix is a combination of people doing the owning, agents extending the owners’ reach inside their products, and stewardship held across the organisation by agents that carry the continuity working with humans that hold the interpretation of what the continuity is showing. The verb stays human at both scopes, because interpretation is what humans do, while the agent does different work at each scope, because reach inside a product is different work than continuity across tenures.

Where this combination is built, ownership compounds across tenures because stewardship is carrying it. Where it is not, ownership resets with each transition, and the organisation gets whatever it has accreted into rather than something it has been improving.

Stewardship is what makes ownership a practice the organisation can carry. Without it, every owner is on their own, every product begins again, and whatever the previous owner understood goes with them.

You want to read more of Sebastian Thielke? Search here in the Substack website or go for sebastianthielke.com more.

Naming the owner of a build seems to be common in organization, or is it not? There is a person in the box on the org chart, a line in the RACI, a name at the top of the kickoff deck. By every visible measure, ownership is in place.

Then the build ships, the engineer who ran it moves to the next thing, and 6 months later it is the integration nobody touches because nobody quite remembers why it was made the way it was. The artefacts of ownership were all there. Something else was not.

That something else is what this piece is about. The argument is that ownership is structurally a verb, most architectures treat it as a noun, and the agentic enterprise is what makes the mistreatment unsurvivable in a way it was not before. A second piece, following this one, makes the parallel argument about stewardship. The two are connected, but ownership has to be described correctly first.

I have been working through this in a series called System Decoder over the last few months, across pieces on legacy, on outcome driven speed, on the platform that remembers, on agents as augments. The current piece sits inside that work but is meant to stand on its own. Where the series gets referenced, the references are illustrative rather than load bearing.

The Diagnosis

A noun is a stored thing. It exists between updates. It can be referenced, checked, passed around. Its truth is set at the moment of capture.

A verb is a holding. It exists only while it is being done. Its truth is set by current engagement with reality.

The failure pattern this distinction surfaces is specific, and it has a particular character that makes it hard to spot from inside. When something structurally a verb gets treated as a noun, the system keeps running on the captured version while reality moves. No error fires. The stored thing is still there. It just no longer matches what is happening underneath it. Most of the time you only notice when the outcomes break, by which point the noun has been the operative thing for long enough that going back to find when the gap opened is more or less impossible.

Ownership is structurally a verb. The owner is owning a product. Orienting to what it is for, who it serves, what conditions it has to meet, how it is moving, when it has stopped being worth running. That orientation is a live act. It does not exist between moments of being done. The owner who has stopped orienting is not an owner who still has stored ownership. They are an owner who has stopped owning, even if everyone in the organisation, including them, would still answer the question of who owns this with their name.

The artefacts of ownership, the name in the box, the line in the RACI, the deck at the kickoff, those are nouns. They got produced the last time someone looked at what owning meant in this organisation. They are precipitates of a moment of inspection. They are not the owning.

In most organisations the architecture is built around the precipitates. Hiring fills the box. The RACI gets reviewed. The kickoff produces the deck. None of this is wrong, exactly. It is just architecture for the noun. The verb was supposed to keep flowing underneath. Whether it does is mostly luck, and individual conscientiousness, because nothing in the architecture sustains it.

The agentic enterprise changes what this costs.

The Verb in Motion

Owning, taken as the verb it is, is a continuous coupling. A human, oriented to a product in motion, holding what the product is for in the act of moving with it. Measurement, pivoting, reading data, taking feedback, adjusting, eventually killing. These are not separate activities the owner performs at scheduled intervals. They are what coupling does. The coupling is the owning.

In an organisation without agents the coupling is bounded by what a human can perceive, remember, and act on alone. The owner is close to the work, close to the customer, close to the data, because closeness is the substrate of the coupling. When the owner is not close enough, the coupling thins. The verb still runs but at lower resolution. Decisions get made on partial information. Drift compounds.

In an organisation with agents something changes about reach. The agent extends what the owner can perceive, remember, and act on. The measurement runs continuously. The pattern surfaces across builds. The memory does not move when the engineer moves. None of this is the agent owning. The agent is not coupled to the product, has no orientation to what the product is for. It extends the reach of the owning the human is doing. The verb stays human. The reach is augmented.

This matters because the next move follows from it. If owning is a verb, the product the owning is coupled to is also a verb. The product is not a thing being owned. The product is what is currently being producted for these people, in this moment, against these conditions. The lifecycle is not a stored arc, it is the live motion of becoming, being used, being adjusted, drifting, being killed. Pointing at a product as a thing produces a noun, which is useful when you have to point. It does not change what the thing pointed at actually is.

Every system we use to think about products treats them as nouns by default. The roadmap entry. The PRD. The line item in the portfolio review. All nouns. All useful. All precipitates of moments when somebody had to point at the verb so other people could see what was being pointed at. None of them are the product. The product is what is currently being done with the materials, the people, the customer, and the conditions, oriented toward what it is for. When the orientation stops, the precipitates remain. The product, in the verb sense, does not.

When the situation calls for it, the verb precipitates a noun. The kill, the pivot, the continue. These are decisions, which are nouns, generated by the live coupling at the moment a decision is required. The decision is the readout. The verb keeps going regardless of whether the readout was just taken. The owner does not stop owning when the decision precipitates. The owning continues, and produces the next precipitate when the next situation calls for one.

This is what the System Decoder pieces have been describing from different angles without naming the shape directly. The signal that surfaces kill, pivot, or continue is the precipitate. The platform that remembers is the accumulated record of precipitates from previous moments, available as input, never confused for the meaning that produced them. The accountability owner who acts without a meeting is the human whose coupling is live enough that the precipitate arrives clearly when it is needed. The pieces describe what the verb produces. They do not yet describe the verb as a verb.

What the Agentic Enterprise Reveals

The agentic enterprise does not break ownership. It reveals what ownership has been doing all along.

Read the System Decoder pieces in sequence and a pattern surfaces, though it took me a while to see it as one pattern rather than several adjacent ones. The legacy piece names the residue of builds nobody owned the outcome of, from first commit to retirement. The GenAI piece sharpens it: legacy is what happens when caring is not the same as knowing, when the artefacts of ownership are present and the orientation is not. The piece on concept inventories names the same failure at the term level. A procurement agent processing approvals against a definition of compliant vendor that had not been operationally current for eighteen months, every metric green, every output coherent with the encoded definition, the entire system running cleanly while diverging from what the organisation actually meant. The outcome driven speed piece names it at the operating system level. The forward deployed engineering model inherited as a surface pattern, the long term presence the original depended on stripped away, what remains is proximity without memory.

These are the same failure in different costumes. Something structurally a verb was captured as a noun. The noun stayed accurate to the moment of capture. Reality moved. The system kept running on the captured version. No error fired. The drift was invisible until the outcomes broke.

The agentic enterprise does not introduce this failure mode. It accelerates the consequences. AI does not introduce new dysfunction, it inherits whatever dysfunction already exists and runs it at a scale no human team could previously achieve. That is the formulation the series has been working with. In the verb and noun frame the same point reads slightly differently. The agent does not make the captured noun more wrong. The agent makes the captured noun consequential at a speed the verb treatment cannot survive. Before agents, the gap between the captured ownership and the live owning could be navigated by humans noticing, slowing down, escalating, asking clarifying questions, all the small acts of catching things that are easy to dismiss in hindsight as inefficiency. Agents do not slow down. They execute against the captured noun at full speed, across every transaction, without checking whether the verb has moved on.

The verb stays human for a reason that needs to be made explicit here, because the next argument depends on it. The agent extends what is perceivable, recordable, surfaceable. The agent does not interpret what the product is for. Interpretation is the verb. Interpretation is what makes the orientation an orientation rather than a process. An agent can run the loop, but the loop is not the owning. The owning is the holding of what the loop is run for, which is interpretive work, which is what humans do. An agent that runs the loop without a human holding what it is for is not an owner. It is a process executing against a captured noun.

This produces the two failure modes that read as inevitable in an agentic context, and the second is more common than the first.

The first is ownership becoming a noun held by an agent. The agent reads the signal, surfaces the pattern, retains the memory, runs the analysis. The human, who never had a live coupling to the work in the first place, signs off on what the agent surfaces. The owning was never happening. The agent now holds the noun the org chart said belonged to a person. Nothing in the architecture notices, because the architecture was always for the noun. This is the failure mode that gets named in the discourse because it sounds the most ominous. It is also the rarer one in practice, because most organisations have not yet put the infrastructure in place to make it possible.

The second is ownership vanishing into a checklist. The artefact remains. The boxes get checked. The verb is nowhere. This one is more common because it does not require any new infrastructure. It just requires that what was always a noun stay a noun, which is the default state of most organisational design.

Both failures are the same shape. The verb stopped flowing. Only the noun remained. A noun can be held by anything, or by nothing.

The fix is not better nouns. Better job descriptions, sharper RACIs, more precise outcome statements, these are higher fidelity captures of a verb that still has to be running underneath them. If the verb is not running, the higher fidelity capture makes the failure worse, because it lends false confidence that ownership is present. This is the same trap the concept inventory piece named at the term level. A more precise definition encoded into an agent does not solve the problem if nobody is watching whether the definition still matches what the work requires.

The fix is architecture for the verb. The components are in the series, just not named as verb supporting infrastructure. The signal that surfaces kill, pivot, or continue produces a precipitate when the situation calls for one, while the live coupling keeps running. The platform that remembers stores precipitates from previous moments without confusing them for the orientation that produced them. The principle that lets implementations be evaluated is what the verb is coupled to, against which the noun form of each decision can be tested. The difference between these and the higher fidelity captures that produce false confidence is structural. A captured noun stands in for the verb and is consulted as if it were the verb. A noun precipitating infrastructure is consulted as a record of what the verb produced at a previous moment, and is never confused for what the verb is doing now. The first replaces the verb. The second serves it.

What the series has been building, across its pieces, is the case for verb shaped architecture. The agentic enterprise is what makes the alternative unsurvivable.

What This Changes

The practical implication is one move, repeated at every layer of how ownership currently gets architected.

Stop architecting for the noun. The org chart box, the RACI line, the named accountability owner. All of these are precipitates. They are useful when a situation calls for legibility. They are not the thing. Architecting around them produces organisations that look owned by every visible measure, and that drift continuously underneath the visible measures because the verb was never sustained.

Architect for the verb. This is harder, and it is harder partly because verb shaped architecture is less familiar and less marketable than noun shaped architecture. The verb cannot be put in a slide. The coupling cannot be templated. The precipitate on demand pattern is not a process diagram. What can be architected is the conditions under which the verb can run. People positioned closely enough to be coupled to what they are owning. Agents extending the reach the verb requires. Signals that precipitate when situations call for precipitates and not before. Platforms that hold precipitates as input without converting them into stored truth.

The agentic enterprise will reveal which organisations have been doing this already, often without naming it, and which have been running on captured nouns. The first kind compounds. The second kind accelerates the failure it was already producing.

Owning is a verb. It precipitates nouns on demand. It is not the noun.

The work is to build for what is happening, not for what was captured the last time someone looked.

What Comes Next

This piece argued that ownership is a verb and that the agentic enterprise makes the noun treatment unsurvivable. The second piece in this pair makes a parallel argument about stewardship. Stewardship is the verb that holds the conditions ownership runs against, and the same diagnostic, the same failure modes, and the same structural reason for keeping the verb human apply one layer up. The conditions under which ownership runs do not stay still, and the verb that watches whether they have moved is doing different work than the verb that watches the product itself. The next piece walks through what.

Want to read more from Sebastian Thielke? Search here at Substack or go for sebastianthielke.com.

The first 3 parts of this series asserted a division of labor. The human holds meaning. The augment maintains coherence against that meaning while the organization moves at speed. The Definition established the principle. Building for Human in Meaning gave it an architecture. The Failure Nobody Sees showed where it breaks, in the human who has stopped holding meaning and started holding pattern.

All 3 asserted that the augment cannot hold meaning and must not be asked to. None of them proved it. This part is the proof. It comes from the inside of the augment, from the one object the field offers when it claims to have captured meaning, and it shows that object cannot be meaning, not as a limitation of current models, but by what it structurally is.

The field believes it has captured meaning. It points to the vector as proof. Words that occur in similar contexts sit close together in a learned space, the space encodes relationships, the relationships do real work, and the work is good enough that the claim goes unchallenged. Meaning, they say, is geometry. Proximity in a high dimensional space.

This is wrong, and it is wrong in a way that has a name and a literature and a settled account that predates the entire field by half a century. The vector is not meaning. The vector is a corpse of one. To see why, you have to look at what meaning actually is, and then look at what the vector actually froze.

What the vector actually is

Start by being precise about the object. A vector is a fixed point in a learned space. It was set during training. It is the same every time it is called. Whatever situation it was derived from is over. Whatever conditions made that situation what it was are gone. The point remains, identical, queryable, stable, dead.

This stability is sold as a feature. The meaning is captured, so it can be stored, retrieved, compared, reused. And for some purposes the stability is genuinely useful. A vector is a fine tool for finding documents about similar topics, for clustering, for retrieval. As a tool for those jobs it works.

But the claim is larger than the tool. The claim is that the vector holds meaning. And meaning, on any account that has actually thought about what the word does, is not a fixed point. It is not stored. It is not stable. It is made, in a situation, by someone in it, and it changes as the situation changes. The vector has exactly the property that meaning does not have. It holds still.

What meaning actually is

3 people worked this out, in a tradition the field has never read, and they worked it out completely enough that the answer has been sitting in the social sciences since the 1960’ties waiting for someone to need it.

George Herbert Mead established that meaning is not in the symbol and not in the head. It is in the act. The gesture, the response to the gesture, and the result the two orient toward together. Meaning lives in that triad, in the doing, and exists only while the doing is happening. There is no meaning sitting in storage between acts. There is only the act, making meaning while it runs.

W. I. Thomas, with Dorothy Swaine Thomas, established the part that matters most for what follows. If people define situations as real, they are real in their consequences. A situation does not arrive with its meaning attached. The people in it define what it is, and they act on that definition, and the action makes the definition consequential whether or not it was accurate. The definition is an act. It is performed by someone situated. And it is prior to the behavior, not read off the facts.

Herbert Blumer packaged both into three premises. People act toward things on the basis of what those things mean to them. Those meanings arise out of social interaction. And, the premise the field skips entirely, those meanings are handled and modified through an interpretive process the person uses in dealing with what they encounter. That 3rd premise is the engine. Meaning is not applied. It is worked, continuously, by someone interpreting a situation in front of them right now.

Put together, the account is exact. Meaning is the live act of defining a situation, made by a participant in it, consequential because it makes itself real, and continuously reinterpreted as the situation moves. Every word of that is a verb. Not one of them is a stored point.

The cycle that the vector cannot run

Here is the motion, stated as four steps, because the fourth is the one the vector cannot reach and the one everything turns on.

First, the situation is read. Live, by someone in it. This is the definition of the situation being made, the interpretive act, the holding.

Second, the reading is frozen into something actable. You cannot act on a holding. You can only act on a commitment. So the live reading collapses into a fixed enough thing to operate on. This is the freeze. It is necessary. It is what acting requires. The freeze is not the error.

Third, the frozen definition becomes real in its consequences. The instant you act on it, it makes itself real. It reshapes the situation it was a reading of. This is Thomas. The freeze has teeth. Acting on it commits reality to its shape and changes the world that produced it.

Fourth, the reading is altered, because the situation has moved, and it has moved partly because the third step changed it. This is Blumer’s interpretive process. You reread, because your own commitment made the old reading obsolete. Then you freeze again, act again, reshape again, read again. The cycle turns, and the third step is what turns it.

A human in a situation runs all 4, continuously, because they cannot avoid it. Their freeze has consequences they have to live in, and living in those consequences forces the next reading whether they want it or not.

The vector runs the first 2 and stops. It was a reading of a situation, frozen into an actable point. And then nothing. There is no third step, because the vector does not act in a situation, it gets applied to one, and being applied makes nothing real in the vector’s own world. With no third step there is no fourth. The vector never rereads, because nothing ever told it the situation moved. It is a freeze with the alteration amputated. A definition of a situation made once, at training, by no one who is in your situation, and never altered, applied to moments it was never a reading of.

A deployed model produces outputs, and those outputs plainly have consequences in the world, so surely the third step happens. It does not, and the reason is precise. A consequence only turns the cycle if it returns to the same entity as the condition of its next reading. The human who freezes a definition has to live inside the situation the definition reshaped, and that enforced residence is what drags them into rereading. The model’s output reshapes a situation the model does not live in. The consequence lands on the user, the organization, the world, never on the frozen vector, which is identical the instant after its output as the instant before. The consequence is real. It just never finds its way back to the point that produced it, because the point is not anywhere a consequence can reach. Step three requires being consequentially inside the situation. The vector is inside nothing.

That is not meaning. That is the husk Blumer warned was not the thing. The field took the most thoroughly worked out account of meaning the social sciences produced and built a meaning machine that violates all three premises, because it read the word meaning as correspondence and never knew the question had been answered.

Why this is the same failure as a drifted human

The Failure Nobody Sees named a failure mode that organizations know well, even if they do not diagnose it. The role filler. The long tenured human who stopped holding meaning and started holding pattern. They recite policy. They retrieve past decisions. They are fluent and confident and their answers cannot survive one genuine follow up question. That piece located the failure but did not name its mechanism. The mechanism is the cycle. The role filler is someone who ran the first two steps once, froze a reading into an actable pattern, and never ran the fourth. They are living in a definition they froze years ago and never altered.

That human and the vector are the same failure, and now the sameness is exact. Both ran the freeze and stopped. Both are living in a footprint. Both produce output that looks correct because the first two steps still function, the reading was once real and the freeze is still there, and the absence is invisible because nothing in the output announces that the fourth step died. The test from the failure piece, the follow up question that fluency cannot survive, was always a test for the fourth step. Fluency before silence is a frozen definition with no live rereading behind it. Hesitation before clarity is the cycle still turning.

The difference is only this. The human can, in principle, resume to the cycle. Asked the right question, placed back in genuine contact with a situation, a human can start rereading. The capacity is dormant, not destroyed. The vector cannot resume, ever, because the architecture has no fourth step to restart. It is not a meaning holder having a bad decade. It is a structure that ran step two once and is built to never run step four. The drifted human is a meaning holder who stopped. The vector is a thing that was never able to start. This is the whole of why the Failure piece worried about humans drifting into pattern and never once worried about the augment, the augment was never anything but pattern, the drifted human is the augment’s condition reached from the other direction.

This is why the human cannot be removed from the system. Not as a values preference. Not as a courtesy to human dignity. As a structural necessity, which is what the first 3 parts asserted and this is the proof of. The human is the only component in the stack capable of running the fourth step, because the fourth step requires being in the situation, defining it as real, suffering the consequences of the definition, and being forced by those consequences into the next reading. Only a situated participant can do that. Everything else in the system is frozen at step two by construction.

What this means for what the field calls meaning

The vector is a fine tool and a false ground. As a tool it retrieves, clusters, compares, and does those jobs well. As a ground for meaning it is a definition of a situation nobody is in, frozen at the moment of capture, consequential nowhere, never altered. The field that calls it meaning has confused the footprint for the leg.

This does not mean the augment is useless. It means the augment is exactly what the first three parts said it was, a thing that holds the frozen noun while the human holds the live meaning. The vector is the freeze. It is supposed to be the freeze. That is the augment’s whole and proper job, to carry the latest actable commitment at speed so the organization can move. The error is not that the vector exists. The error is believing the freeze is the whole cycle, that storage is meaning, that a point can hold what only an act can hold. Asking the augment to hold meaning is asking the freeze to perform the alteration, which is asking the footprint to take the next step. It cannot, and the series never needed it to. It needed the human to, and now we know why only the human can.

Meaning was never the vector. Meaning is the turning of the cycle, and the cycle turns only where a situated participant is reading a situation they are consequentially inside of. That participant is the human the whole series has been pointing at. Not in the loop, not a step in the process, but the one component that can run the step every other component is frozen short of. The Definition asserted it. The architecture was built around it. The Failure showed what happens when the human stops doing it. This is why the assertion was right. The field built the husk and called it the thing.

The vector holds still. Meaning never does. The human is the only thing in the system that can move with it.

Want to read more by Sebastian Thielke? Search in this Substack or go for sebastianthielke.com. He is Schwarzpfad and System Decoder.

Open any feed and you will find them. Prompts presented as discoveries. Prompts in carousels, in threads, in PDFs behind an email gate. Copy this and the model will write like a senior strategist. Paste this and it will think before it answers. Use this exact wording and you will get what I got. The wording is always exact. That is the tell.

The practice rests on a single assumption that nobody states because stating it would expose it. The assumption is that the result lives in the words. That if you have the words, you have the result. This is false, and the rest of this piece is about why it is false, and what the false belief costs the people who hold it.

What a result actually came from

A prompt that worked, worked in a setting. Someone sat in front of the model with a specific thing they were trying to do. They had a history with the model, even if only the last twenty minutes of it. They knew, often without being able to say so, what a good answer would look like when it arrived, which is how they knew to stop when they got one. They had a problem with edges, a context the words pointed at without containing, and a running sense of whether the thing was getting warmer or colder. The words were the last and smallest part of that. The words were what was left over after all the real work had already happened.

When the result was good, all of that was present. The setting was doing most of the lifting. The words were the handle on a tool, and the tool was the person’s whole engaged situation. Hand someone the handle and they do not have the tool. They have a handle, and a handle is not useless, you can grip it, it is shaped right, it tells you something about the tool it came off. It just will not do the work the tool did, and the better the handle feels in the hand the easier it is to forget the tool is missing.

This is the part the sharing culture cannot see, because the setting is invisible and the words are not. You cannot screenshot the situation. You cannot put the history, the stakes, the sense of warmer and colder, the knowing it when you see it, into a carousel. So those get dropped, silently, every single time, and what gets posted is the one component that survives extraction. The residue. The footprint with the walk removed.

Be precise about what does survive, because the loose version of this argument is wrong and easy to refute. The words are not nothing. A good prompt carries real, portable structure. A framing. A role. An output format. A way of breaking a task into parts. A constraint the copier would never have thought to add. These transfer. Paste a strong prompt cold and you will get something better than you would have typed yourself. That is true, and pretending otherwise hands the whole argument away to anyone with one counterexample.

The trap is exactly that it half works. The portable structure produces a partial result, good enough to feel like the words delivered it, and the partial result is what convinces the copier that the words were the cause. They got something. They credit the string. What they cannot see is the gap between what they got and what the original author got, because they were never in the original situation and have nothing to measure the gap against. The transfer is real and partial, and partial transfer mistaken for full transfer is a more durable error than no transfer would be, because no transfer would at least announce itself. A prompt that did nothing would get deleted. A prompt that does a little keeps the belief alive.

And then someone copies the residue and gets a little, and concludes the little was the whole thing minus their own bad luck.

Why the words look like the cause

There is a reason the error is so durable. The words are concrete and the setting is not. When the result arrives, the words are the only thing the person can point at, so the words get the credit. This is a basic confusion of the visible part for the working part, and it runs through everything humans do with tools they do not fully understand. The recipe gets credited for the dish, not the cook’s hands. The framework gets credited for the team’s output, not the people. The prompt gets credited for the result, not the situation that produced it.

The confusion is comfortable because it promises transfer. If the words are the cause, then the words can be moved, and the result moves with them. This is an appealing thing to believe and it is the thing the sharing economy is built on. A situation cannot be sold. A history cannot be packaged. A practiced sense of when to stop cannot be put behind an email gate. But a string can. So the string is what gets sold, and the claim attached to it is that the string is the thing, because that is the only version of the claim that has anything to sell.

Notice what this means. The format selects for the false belief. The things that actually produce good results are exactly the things that cannot be shared in the format, so they are exactly the things the format omits, so the format trains everyone in it to believe those things do not matter. The medium is not neutral. It quietly teaches that the words are everything, because the words are all it can carry.

The performance underneath

Look at what a shared prompt is actually doing as a social object, separate from whether it works.

It signals that the sharer is ahead. It says they have found something, that they are on the inside of a thing moving fast, that following them is a way to not be left behind. The prompt does not have to work for this to function. It only has to look like insider knowledge, and a precise string of words with a confident claim attached looks exactly like insider knowledge. The aesthetic of precision does the persuading. The more exact the wording, the more it reads as a discovered formula rather than as one person’s leftover handle.

This is why the prompts are always stated as truth and never as report. Truth transfers and report does not. “Here is what worked for me in my situation, which you do not have” is accurate and worthless as content. “Use this exact prompt” is inaccurate and shareable. The inaccuracy is not a flaw in the format. It is the product. The certainty is the thing being sold, and certainty about a string is the only certainty that fits in the box.

The people sharing are not, for the most part, lying. They got a result. They are reporting it in the only register the medium rewards, which is the register of discovery. The medium converts their honest experience into a false universal on the way out, and most of them do not notice the conversion happen, because they were there for the part that worked and the part that worked felt like the words.

Two shapes of the same error

The culture has two favorite moves, and they point the magic in opposite directions.

The first is the incantation. Paste this exact prompt and the model stops lying. Seven rules, numbered, copy them precisely, save this now, works in every chat forever. The form is ritual. The exactness of the wording is the spell, and the promise is a permanent change of state from a recited formula. It treats the model as a thing you rewire by saying the correct words in the correct order, and it treats a property like truthfulness as something you install once rather than something that has to be held and earned again in every answer. The irony is usually total. A prompt that claims to stop a model from asserting things it cannot back up arrives asserting exactly that, with full confidence and no backing, as though pasting the words were the same as making them true. The incantation believes the words change the machine.

The second is the divination. Show me how you prompt and I will tell you who you are. Here the string is not a spell aimed at the model but a reading of the person who typed it. The way you ask becomes a tell, a new body language, a surface that exposes your personality, your decision style, your cognitive patterns. It borrows the language of research to make the act of typing into a diagnostic. The divination believes the words reveal the self.

They look like opposites. One points at the machine, one points at the user. They are the same error wearing two costumes. Both treat the string as the thing that carries the meaning, the spell that rewires the model or the readout that exposes the person. Both ignore that the string is residue either way, the leftover handle from a situation neither the model nor the typist is actually in once the words have been extracted and posted. The incantation forgets that truthfulness is held, not installed. The divination forgets that a person shaping a request in a live situation is not the same person reduced to a captured string for analysis. The magic is misdirected in both. The words were never where the meaning was.

What it costs the person collecting them

The collector is the one who pays.

They build a library of strings, each one a handle to a tool they never held, taken from a situation they were never in. The library feels like capability. It is a folder of other people’s leftovers. When they paste one in and it underperforms, they conclude they used it wrong, or that they need a better one, and they go looking for the next string. The belief that the words are the cause survives every disappointment, because the disappointment gets blamed on having the wrong words rather than on the words never having been the thing.

This is the actual harm, and it is not trivial. The collector is being trained away from the only thing that would make them good at this. The thing that produces results is the engaged situation, the practiced sense, the running contact with the problem. Every hour spent acquiring strings is an hour not spent developing the holding that strings cannot contain. The library grows and the capability does not. The person ends up more dependent on other people’s residue and less able to produce their own, which is the precise opposite of what the library promised.

And the people who sell the libraries have no incentive to correct this, because the belief that capability lives in strings is the belief that makes the next string sellable.

Said structurally, once

A prompt is a verb that has been written down as a noun.

The act of prompting is a holding. Someone oriented to a situation, in contact with it, shaping a request against it and adjusting as the thing comes back. That is a verb. It exists only while it is being done. The string is what is left on the page after the holding stops, and the string is a noun, a stored thing, inert, the same whether or not anyone is holding anything.

Sharing the string and calling it the method is sharing the noun and discarding the verb. It is handing someone the transcript of a conversation and calling it the relationship. The transcript is real. It is just not the thing that did the work, and no amount of having the transcript gives you the relationship.

This is why the saved prompt is already dead the moment it is saved. Not degraded, not stale, dead in the specific sense that the living part, the holding, never made it onto the page and could not have. What was saved was always only the residue. The culture treats the residue as the inheritance.

But books are frozen words and books work

The sharpest objection to all of this is the book. A book is words on a page, fixed, the same marks for every reader, and books carry meaning across centuries. Well received documents, contracts, scripture, the great essays, all of them are frozen words that work. If a noun can hold meaning that well, the whole argument seems to collapse. Why should a prompt be any different.

The objection fails, and it fails in a way that proves the point rather than wounding it. The book does not carry the meaning. The book carries marks that a reader brings meaning to. The core is fixed, the words do not move, but the meaning is made fresh in each reader and is never the same twice. Two people read the same sentence and hold two different things. The same person reads it at twenty and at fifty and holds two different things. The marks are constant. The meaning is a verb that happens in the reader every time, or it does not happen at all, and a book nobody reads is just ink.

So the book is a noun that works because it is honest about being a noun. It does not claim to deliver a result. It hands you material and waits for you to do the holding. The reading is the verb. The book never pretended to skip it. Its entire form assumes a reader who will sit down and make the meaning happen, and it is judged good or bad precisely by how well it supports that act, not by whether it performs the act for you.

The shared prompt makes the opposite claim. It says the result is in the words and will arrive when you paste them. It sells the skipping of the verb. It promises that you can have the holding without doing the holding, the meaning without the reader, the walk without the walking. That is the difference, and it is total. The book is a noun that respects the verb it requires. The prompt as truth is a noun that denies the verb exists. One hands you material for your own work. The other tells you the work is already done and packaged, which is the lie.

A prompt could be shared honestly, the way a book is. Here is what I was doing, here is what I was in contact with, here is the wording that fell out of it, make of it what you can. That is a noun offered as material. Almost nobody shares them that way, because material is harder to sell than a result, and “make of it what you can” does not stop the scroll.

What to do instead, briefly

Stop collecting. The folder is not an asset.

This does not mean never look at someone else’s prompt. A prompt read the way you read a book is fine. Read as material, as one person’s report of what fell out of their situation, it can show you a move you had not considered, the way a good essay shows you a turn of thought. The harm is not in reading it. The harm is in saving it as if the saving were the skill, building the folder as if the folder were capability. Treat a shared prompt as material and it can teach you something. Treat it as inheritance and it teaches you to stop doing the only thing that works.

So when you see a prompt that produced something good for someone, the useful question is not what were the words. The useful question is what was the person doing. What were they in contact with. What did they know about what good looked like that let them recognize the good result when it came. The words carry the part that copies, the structure and the framing, and that part is real. It is just the smaller part, and it is the part you would have reached on your own within a few tries of actually working the problem. The holding is the larger part and the part that does not copy. It is built by doing, which is slower, unsellable, and the only thing that gets you the result the words were only ever a handle on.

The good news, such as it is, is that the holding is available to anyone willing to do it, and it does not require anyone else’s string. You sit in front of the model with your actual situation, your real stakes, your own developing sense of warmer and colder, and you shape the thing against what comes back. That is the whole skill. It was never in the carousel. It could not have been. The carousel carries the part that copies and stops exactly where the work begins, which is why the carousel is full and the skill is still rare.

Delete the folder. Read what you like as material. You were keeping someone else’s footprints and wondering why they would not take you anywhere.

Want to read more From Sebastian Thielke? Search here in the Substack or go sebastianthielke.com.