Somewhere in your organization there is an agent in production that summarizes documents.

It is very good at it. It has an owner, a dashboard, a slide in the quarterly update, and a per-seat cost small enough that nobody in finance has noticed it yet. It has never touched a customer, moved a dollar, or promised anyone anything, and the plan for when it will is a bullet that says “Phase 2.”

I have sat in the meeting where Phase 2 dies. You probably have too. You may have chaired it.

Someone proposes letting the agent issue a service credit. Not a big one. The kind a supervisor approves forty times a day without looking up from their email. The room goes quiet. Nobody says no, because nobody wants to be the person who said “no” to AI in 2026. Nobody says yes either, because saying “yes, please” means stating what the agent may never do, and that document does not exist. So the item goes to legal review, from which few pilots return.

The agent could have issued the credit. The enterprise couldn’t because it had never decided what the agent may never do, so it had no way to decide this either.

The two bad options

An organization that has drawn no lines gets two choices, and both of them cost money.

Option one: forbid the agent from doing anything consequential. This is the crowd favorite, because the cost is invisible. Nobody has ever been fired for a summarization tool. The bill arrives later, as an eight-figure program that produced a productivity feature, and as the eighteen months your competitor spent learning what you are about to learn, slower.

Option two: let the agent loose and find out where the line was when somebody else draws it for you. Air Canada tried this one. The refund it fought over cost less than the paragraph of case law the fight produced, and the chatbot has been enjoying a long retirement ever since.

The third option is the unglamorous one: draw the lines before deployment. The deliberate enterprise does this work in advance precisely so it can grant everything on the near side of those lines without flinching, without a steering committee, and without a fourteen-week legal review.

Most governance conversations treat it as restriction, the department that says no, eventually, in writing. It works more like the load rating on a bridge. Nobody resents the sign that says twenty tons. It is the only reason the trucks are allowed across.

Boundaries are what let you say yes.

What a Boundary is

Over the past year I’ve written about three of these lines one at a time: the Routing Boundary, the Take-Back Boundary, and the Ground-Truth Boundary. Each was a standalone argument about a specific way things go wrong. Somewhere around the third one I noticed they kept rhyming. Same structure, same kind of failure, and, more usefully, a fixed order in which they have to run. This arc is that family, assembled, plus the three members it turned out to be missing. I will revisit the previous pieces through this arc.

A Boundary is a line the enterprise draws between two regions that look like one decision and behave like two. Every member of the family has four properties.

It separates two things that are easy to confuse, and the confusion is the failure. Nobody wakes up intending to mistake a metric for the thing it measures. They just do it by Thursday. That is why it takes a line and not a memo.

You draw it. Your vendor doesn’t. Your platform provider will sell you controls, and some of them are excellent. It cannot tell you which of your actions can be taken back, because it does not know your business, your regulators, or which of your customers screenshot everything.

It is an architecture decision dressed up as a policy decision. This is the expensive one. Air Canada presumably had a policy about refunds too. It did not help. Topology, credentials, gates, and audit trails enforce Boundaries. A PDF on the intranet does not, no matter how many people clicked “I acknowledge.”

It fails in a predictable way when you skip it. Not “introduces risk.” Not a yellow cell on a heat map. A specific outcome you can name in advance. That is why these lines get names of their own instead of one more slide titled Responsible AI.

Six lines pass all four tests. Where a request is allowed to go, and which model should handle it. Whose authority the agent is spending. What may never happen while nobody is watching. What the agent may assemble on its own at runtime. Whether your measurements still mean anything. And what the enterprise should deliberately forget.

Gates, classifiers, and watches

The six don’t sit in a list. They sit in three positions, and the position decides how the line is enforced, who owns it, and what it costs.

The easiest way to see the positions is in a courthouse, an institution that has had a few centuries to work out its order of operations.

Jurisdiction is a gate. It is binary, it is checked first, and no amount of brilliance fixes it. File in the wrong court and it does not matter that your argument would make a law professor weep. The gate does not care how good you are.

The merits are a classifier. Contextual, graded, case by case. This is where all the intelligence in the building lives, and it is worthless without the gate. A dazzling ruling from a court with no authority to rule is a very well-written opinion piece.

Appellate review is a watch. It runs across cases, not inside one, because no single case can reveal that a whole line of reasoning has wandered off. A trial judge cannot spot her own systematic error from the bench. That takes a different instrument, on a different clock, owned by somebody else.

The six Boundaries sort the same way. Identity and Take-Back are gates: binary, checked per request, and completely indifferent to how smart the agent is. Composition and the quality half of Routing are classifiers: contextual, graded, decided each time. Ground-Truth and Memory are watches: continuous checks that the machinery still means what it meant last quarter. A watch can’t run inside a single request, because nothing inside one request tells you the whole system has drifted.

Routing is the odd one out. It has a gate and a classifier in the same request path, owned by two different parties. That is why it goes next.

The order is not negotiable

If you keep one thing from this piece, keep this.

Gate, then classifier. Run them the other way around and you get Knight Capital.

The logic is mechanical. A classifier is a quality judgment. Run it first and the system does its best, cleverest, most context-aware work, and only then reaches the consequence check, by which point the capability has already been used. Knight Capital is the machine-speed version: forty-five minutes of flawless execution against instructions nobody had gated, and $440 million gone. The execution was excellent. That was the problem.

Here is the uncomfortable part. Most agent architectures I review do exactly this, and they do it in a way that looks like good engineering. The agent reasons about the task, makes a plan, picks its tools, and then, as a final courtesy, runs a guardrail to check its own work. That is classifier-then-gate. The guardrail is being asked to stop something the system has already committed to, by evaluating output the model wrote fluently and confidently. Fluency is the one thing these systems never fail at. It is a strange thing to stake your last line of defense on.

Watches sit outside the ordering entirely, and that is exactly why they get skipped. They have no seat in the request path and no latency budget, and nobody’s bonus depends on them. They also fail silently by design. A watch nobody built looks identical to a watch with nothing to report. Both give you a lovely green dashboard.

Every issue in this arc names its Boundary’s position and what breaks when it runs out of order. That rule is doing real work. It keeps a family of six named lines from turning into a taxonomy. Frameworks do that around issue four if nobody stops them.

The method, and the move everyone skips

Underneath all six there is one repeatable method, and it has five moves.

Inventory what’s in scope. Name the principal who owns it. Draw the Boundary. Instrument it so you can tell when something crosses. Write down what happens at the line.

Four of those are familiar, and any decent architecture review will ask for them. The fourth decides whether the other four were real, and its price changes depending on where you are. In one position it is free, because the request does the detecting for you. In another it is a separate build with its own owner and its own budget line, and it is skipped in nearly every deployment I have looked at. The other four moves produce artifacts a reviewer can see. This one produces an absence of surprises, and nobody has ever been promoted for that.

Which position is which, and why the difference is structural rather than a matter of trying harder, is the closing issue’s job. It is more interesting than it sounds. I’m aware everyone says that.

Try this on Monday

Pick the most consequential thing any agent in your enterprise did last week. Not a category. The actual action, with a timestamp.

Ask three questions. What ran before it executed, and was the answer yes or no? What assessed it, and could a sufficiently persuasive plan have talked its way past that assessment? And what is running right now that would tell you if every action like it has been quietly drifting for six weeks?

The first question usually gets an answer. The second gets an answer that turns out, on inspection, to be the first answer again in a different font. The third is where the room goes quiet, the same way it did over the service credit. Time the silence. It is a decent proxy for how much autonomy you can responsibly grant this year.

The slide version: for every action your agent can take, you should be able to name which of the three positions checks it, who owns the check, and what happens when it fires. The companies that can answer are not the ones with the strictest policies. They are the ones handing out the most authority, because they know exactly where it stops.

Next

The easiest place to watch all of this working is a decision most enterprises made this year without noticing they were drawing a line: which model handles which request.

That is really two questions, with two owners, two kinds of answer, and a fixed order. Whether a request may go somewhere at all, given residency, sensitivity, and budget, is a governance question with a yes-or-no answer, and it is yours. Which model will serve it best is a quality question with a contextual answer, and your hyperscaler’s router is very good at it. Let the router go first and it will cheerfully optimize for everything it can see. Your regulators are not on its screen.

Gate, then classifier, already running in production, federated across two owners who have mostly never met.

That is the Routing Boundary, and it is the easiest place to learn the shape.

Views are my own, which is a new and thrilling sentence for me to write. Products and solutions mentioned are illustrations, not endorsements. Your account rep will have to find another reason to call.

In 2003, my team was building one of the earliest large-scale personalization experiences using an engine called LikeMinds. At the time, collaborative filtering was genuinely state of the art. Feed it enough behavioral data and it would surface patterns invisible to any individual analyst. People who bought this also bought that. Customers who watched this went on to watch that. The system didn’t know why. It didn’t need to. The pattern was enough.

Except it wasn’t.

Collaborative filtering is, at its core, a sequencing engine. It answers one question with remarkable precision: given what happened before, what tends to happen next? That is a useful question. It is not, it turns out, the interesting one.

The interesting question is why did this person watch that film? Was it the director? The era it was set in? A particular quality of sustained visual dread that runs through every frame? A cinematography style they couldn’t name but would recognize instantly in the next thing they chose? Collaborative filtering has no answer for any of that. It sees the behavior. It is blind to the meaning behind it.

What we were missing wasn’t more data. We had behavioral signals by the millions. What we were missing was a way to represent what those signals meant: the preferences, the context, the semantic relationships between a viewer and a film that explained why the pattern existed in the first place. We needed the system to understand something like: this person doesn’t just like Kubrick films, they respond to a particular quality of sustained dread that Kubrick happened to execute better than almost anyone. How does that preference relate to their love of Cormac McCarthy novels? Their playlist on a Sunday morning? The last three products they bought without reading a single review?

Those connections live in a graph. The meaning behind them lives in an ontology. The ability to find what’s relevant to this person, in this moment, lives in a vector space. None of those things existed in our relational tables. And no amount of additional rows was going to put them there.

Twenty years later, every major enterprise is about to make the same architectural mistake at a scale that would have seemed implausible in 2003.

What queries assumed

Every database architecture built over the last three decades rests on a design assumption so obvious nobody ever wrote it down: a human will decide what to ask.

Think of it as a library card catalog. A card catalog is a beautiful piece of engineering if you already know the title, or at least the author, or at minimum the subject heading. It is useless if your question is “what should I read next about how cities decay.” That question requires a librarian who has read the books, understands the relationships between them, and can sense which one matches the shape of what you’re actually looking for. The card catalog assumes you already know enough to ask. The librarian doesn’t.

When humans write the queries, you can engineer for them. Schema-first design works because the questions are predictable. You index what you expect to retrieve. You normalize for consistency and shard for scale. The entire architecture is a bet on known query shapes. For thirty years, in application after application, the bet paid off.

Agents don’t query. They traverse, infer, and reason across context that accumulates over time. They generate their own questions dynamically. They need to understand what data means, not just where it lives.

Schema-first architecture has no answer for that. Neither does document storage, which gave us flexibility but still treats data as discrete retrievable objects. An agent handed a document store is like a new analyst handed a filing cabinet with no labels. The information is all there. Good luck thinking with it.

The question facing every enterprise isn’t whether their data is accurate. It’s whether their data is thinkable.

Three gaps that will stop your agents cold

When agent deployments underperform, and most of the early ones will, the diagnosis will usually trace back to one of three structural gaps in the underlying data estate.

The first is the relationship gap

Agents need to traverse: who owns this decision, what systems depend on that contract, what changed downstream when this record was updated. These are graph problems. But most enterprise data stores relationships implicitly, buried in application logic or inferred from foreign keys. When an agent needs to navigate that web, the architecture hands it a phone book instead of a map.

The second is the meaning gap

A column named “status” with values 0, 1, and 2 is perfectly queryable by a human who knows the codebook. Every enterprise has the person who’s been there twenty years and is the only one who actually knows what `status = 7` signifies in the legacy order system. The codebook lives in their head. They retire, and a quiet panic ripples through the team that depends on them. An agent inherits none of that. It needs to understand what those values mean in context, in relation to other domain concepts, under what conditions they change. That requires ontologies: explicit semantic models of what things are and how they relate. Most enterprises have never built one.

The third is the relevance gap

The capability that makes modern AI genuinely useful isn’t retrieval. It’s knowing what matters in a given situation. This is the same shift that defeated keyword search and made semantic search inevitable. A keyword system hands you the book whose title contains the words you typed. A semantic system understands that you’re really asking about urban decline and gives you three books, none of which contain your search term, all of which answer your actual question. Vector embeddings are the infrastructure that lets agents make that move. Without them, agents are reduced to exact lookups in a world that runs on context.

A new layer, not a replacement

None of this is an argument for ripping out your databases. Your systems of record are not broken. They remain the authoritative source of what happened, what was purchased, what was promised. That is not going away.

What’s missing isn’t better storage. It’s a semantic layer: infrastructure that sits above or alongside existing systems and makes the data in them thinkable by a reasoning agent.

Think of it as five different jobs your data has to do. The first is to record what happened. The second is to spot patterns across what happened. The third is to know what any of it actually means. The fourth is to surface what’s relevant to the situation in front of you right now. The fifth is to remember what the agent has already figured out. Most enterprises have built the first two and skipped the rest.

The bolded rows are where agents actually operate. They are also, with very few exceptions, the rows enterprises haven’t built.

This is the infrastructure gap hiding inside every agentic AI initiative. Not model performance. Not prompt design. Not integration complexity. The agents can’t reason well because the data underneath them was never organized for reasoning. It was organized for retrieval by humans who already understood what they were looking for.

The uncomfortable part

Building semantic infrastructure is not purely a data engineering problem. It requires the organization to make explicit something it has spent decades leaving implicit: what its concepts actually mean, how its decisions relate to one another, what knowledge is authoritative.

Ontologies are a forcing function for intellectual clarity that most organizations have never had to achieve. You cannot build a semantic model of your procurement domain without deciding, rigorously, what a vendor is, how it relates to a contract, and under what conditions a risk becomes a breach. That precision has always lived in the judgment of experienced people. It has never had to be written down in a form a machine can use.

Recently I was engaged in an ontology workshop with a Consumer Health team (think consumer products, retail, pharma and healthcare.) The agenda item was supposed to take twenty minutes. Define customer, consumer, and patient. It took most of the day.

The retail people went first. A customer is the person who buys. A consumer is the person you are trying to reach, who may never buy anything. Clean. Everyone nodded.

Then the CPG people said their customer is the retailer. The consumer is the person who buys from that retailer, and is someone the CPG company largely cannot see. Except in direct-to-consumer, where the customer is the purchaser, and the two words collapse onto the same person.

Then the payer people said that for an insured product, the customer is the insured member and also the employer who bought the plan. Two customers per policy, with interests that do not always point the same direction. And the moment that member uses the benefit, the same human being is a patient.

Nobody in that room was wrong. Every one of those definitions is correct and load-bearing inside its own business. What is worth noticing is what would have happened if we had run four separate workshops instead of one. Four teams produce four models, each internally coherent, each using the same word, and none of them relate to each other. They don’t disagree in a way anyone could detect. They quietly fail to join.

That is the actual work. Not picking one definition, which would have been wrong for three of the four businesses. Making the four relatable: stating the context each one holds inside, and building the bridges between them.

An agent will not ask you which one you meant and worse an agent with only acess to a vector store, may run semantic similarity against the above and confidently provide the wrong contextual information.

Agents cannot inherit tacit knowledge. It has to be made explicit. That is, at a minimum, a governance challenge dressed up as a data architecture problem. Which is why it keeps getting assigned to the wrong team and the wrong budget.

Closing thought

The organizations that will perform best in the agentic era are not necessarily the ones with the most data. They are the ones whose data is most thinkable: organized for traversal, enriched with semantic meaning, indexed for contextual relevance rather than transactional retrieval.

In 2003, we eventually got there by rebuilding the question we were trying to answer. We stopped asking whether we could retrieve the right product and started asking whether the system could understand why this customer and this product belonged together. The architecture followed the question, not the other way around.

That same reframe is available right now to every enterprise standing at the edge of an agentic deployment. The agents are arriving whether the infrastructure is ready or not. They are arriving like new hires on day one — confident, capable, and entirely unable to lean over and ask the person next to them what `status = 7` means. They will make the call anyway. The question is whether they’ll land on a data estate built for humans who already knew what to ask, or one designed for systems that have to figure it out on their own.

The views here are mine alone, not EY’s, my colleagues’, or my dog’s. Any technology or patent I reference is for illustration, not endorsement, investment advice, or a subtle hint to upgrade your stack. A granted patent describes what a company reserved the right to do, not what it shipped. Treat it accordingly.

I’ve seen a lot and I share a lot. Just don’t buy servers, software, or recommendation engines because I mentioned them.

At Shoptalk in March, the alerts lighting up everyone’s phone were about OpenAI and Disney. The more interesting conversation happened at lunch, and it did not look like disruption. It looked like relief.

The retailers who were supposed to be excited about OpenAI moving into checkout were quietly exhaling over the news that it was being pulled back. Not because they doubted the direction. Because they had no idea how they would engage with it, much less measure it. Attribution in the agentic era was already keeping them up at night. A new transaction layer with aggregate-only performance data and no connection to their retail media infrastructure was one more reporting problem nobody had headcount to solve.

I have thought about that lunch a lot since, because the relief was aimed at the wrong thing. The checkout was never where the loss was happening.

What I said, and how it has scored

In October 2025 I argued that AI agents were entering the customer journey as a co-pilot, that awareness would stop depending on your campaign and start depending on whether your data was structured enough to surface in a reasoning chain, and that loyalty would become encoded preference rather than felt attachment. The loop still closes, I wrote. It just closes in the system prompt now.

I also wrote that the transaction itself might become invisible.

I have graded that forecast twice in public since, which is either intellectual honesty or a reliable way to remind people I made a prediction. Here is the scorecard, because a scorecard is more useful than another round of updating.

The transaction call was half wrong, and I was harder on myself than the text warranted. I hedged it correctly the first time and then took the full hit in March anyway. What actually happened is narrower than either version. One implementation of one feature failed, on operational grounds. OpenAI had not built sales tax collection across US jurisdictions. Real-time inventory sync across millions of merchant SKUs proved brutal. Fraud detection was incomplete. Multi-item carts were not supported. Six months after launch, roughly thirty of Shopify’s millions of merchants had integrated Instant Checkout before it was pulled. Thirty. The toll booth failed. Consumers were never the problem.

The allegiance call landed, and I undersold it. In April I asked whose loop it actually is, and floated what I called the hardware margin hypothesis: the agent most worthy of a consumer’s trust is the hardest one to fund, because it has no merchant fee to collect and no attention to resell. The only player who could carry that cost is a device maker with fat hardware margin and a privacy brand already on the shelf. I noted that nobody had moved.

In June I said Apple had started pouring the footing, and I was careful to call it plumbing rather than a product. That was too cautious.

iOS 26 ships Apple’s foundation model on the device itself, and any developer can reach it in a few lines of Swift. No API bill. No inference metered to anyone. Nothing leaving the phone. At the June developer conference the framework opened further, to any conforming provider, alongside retrieval against the on-device Spotlight index and new primitives for agentic app experiences.

Read the economics rather than the feature list. The inference is already paid for, by the consumer, at the moment they bought the hardware. That is the hypothesis itself, shipping at scale on hundreds of millions of devices: intelligence funded by margin already collected, with no merchant on the other end of the sale and no context to resell because the context never leaves the pocket.

Apple has not announced a fiduciary shopping agent and may never call consumer allegiance a weapon. That is a strategic question nobody in Cupertino has answered out loud. The capability is no longer the thing standing in the way.

One miss, one hit. What interests me now is neither of them individually. It is what shows up only when you line the checkpoints up in order.

Three layers, nine months

Every time I looked, the loop had closed one step further out than the last time.

Discovery went first. By early 2026 this was settled. The agent does not browse. It queries structured data and draws conclusions, and a brand absent from the reasoning chain is not losing the comparison. It is not in the comparison. OpenAI’s own pivot confirmed the shape: after the checkout retreat, they prioritized product search and discovery, the two areas showing genuine traction. The intelligence layer was already working. The transaction layer was the hard part.

The transaction went next, though not the way I predicted. It did not become invisible. It became conditional. By April the agent was deciding whether you reached checkout at all, and a second voice had started whispering alongside the organic recommendation, a sponsored one.

The comfortable objection is that those ads run on the free and Go tiers, so the paying customer still gets a clean answer. Check the denominator. Roughly fifty million people pay OpenAI across every tier combined, against something near nine hundred million weekly users. Nineteen in twenty sit on the side of the line where the sponsored voice speaks. And OpenAI is steering its subscriber growth toward Go, the cheap tier that carries ads, so the ad-free experience is not a shrinking majority. It is a rounding error that nobody is working to grow.

The co-pilot did not take the wheel. It started deciding which cars to recommend, and someone installed a billboard in the cockpit.

Then the page went, and this is the one nobody was braced for.

On January 27, Google was granted US12536233B1, “AI-generated content page tailored to a specific user.” Read the mechanism slowly. You search for something. Google assembles the normal results page. For an organization’s landing page in those results, the system computes what the patent calls a landing page score, built from conversion rate, bounce rate, click-through rate, and a qualitative read on design and content quality. When that score crosses Google’s threshold, the results page can carry a link not to your page but to a page Google builds on the spot, assembled from your product data and tuned to that individual searcher.

The generated page is not a stripped placeholder. The patent describes product feeds, call-to-action buttons, chatbot functionality, personalized headlines, filters, suggested products. A working storefront. Yours, in that it sells your inventory. Not yours, in that you did not design it, did not approve it, and may never learn it ran.

Picture a landlord who decides your shop window is underperforming, so overnight he reglazes it, rewrites your signage, restocks the display from your back room to his taste, and never mentions it. The merchandise is yours. The window is his now.

Keep two caveats honest. A granted patent is a reserved right, not a shipped feature, and companies patent far more than they launch. The current framing points mostly at paid search. But the patent’s own logic does not care about that distinction. Scoring a page and rebuilding it works on any page. The open question is when it widens, not whether the technique works.

Discovery, then the transaction, then the rendering surface. Nine months. The SEO crowd, reading the same patent, landed on a phrase I keep borrowing because nothing I have written beats it: your site is turning into less of a storefront and more of a warehouse that stocks someone else’s customer experience.

Who writes your copy now

Here is the part that stopped me, because it collided with something I had written months earlier about a completely different problem.

In March I wrote about Louis Cheskin, who in the 1950s added fifteen percent more yellow to the green on a 7-Up can and had consumers report significantly more lemon-lime flavor from a drink nobody had touched. He called it sensation transference. I argued the listing is the modern packaging, and that every product has a perceptual elasticity, a range of thematic territory it can credibly occupy before the frame breaks. Push past it and you hit what I called the betrayal threshold, the point where the gap between the frame you set and the experience you deliver becomes a story the customer can tell, at length, in the review section, with photos.

That was a piece about merchandising discipline. It has quietly become a piece about platform mechanics.

When Google generates your page per searcher, Google makes the perceptual-elasticity calls. It decides which occasion this customer is shopping for, which version of your product leads, what promise the headline makes. The betrayal threshold does not vanish in that world. It relocates. The gap that turns into a one-star review is now the gap between a promise Google wrote and a product you shipped. You eat the return and the rating for copy you never saw.

A concept I coined in March for human shoppers turned out in June to describe a machine doing your merchandising without asking. That is when I stopped thinking of these as separate posts.

The price of being explainable

Which brings me back to something from the first piece that I have never properly developed, and should have.

In October I named a shift I called Cost per Explanation. The traditional advertising model optimizes for attention: impressions, clicks, conversions. Agents do not click. They decide. CPX is the value a brand has to supply an agent to be considered worth recommending. Not a media buy. A credibility investment.

I have referenced it exactly once since, and there is a reason. CPX resists calculation, and I want to be precise about why, because the obvious explanation is not the real one.

The obvious explanation is that you do not own most of the inputs. Your reviews live on marketplaces you do not control. Editorial coverage, social conversation, competitor listings, and the model’s entire training corpus all shape whether you get recommended. You directly control your SEO and your SEM. With CPX you own a slice and influence the rest at best.

True, and not enough. Distributed ownership describes half the metrics in marketing. Brand equity already feeds your SEM quality score and nobody calls that uncomputable.

What makes CPX different in kind is that there is no auction and no meter.

Search advertising, for all its complexity, gives you a unit of exchange. There is a bid, a clearing price, an impression log, and a published set of rules. Cost per anything needs a denominator, and the denominator here is the moment an agent considered you. That moment is unobservable. Nobody sends you a log of the conversations where you did not come up. You are being evaluated continuously, at scale, in a market with no ticker.

Then the arbiter moves under you. Your 2023 reviews are still in the corpus. The weighting shifts with every model update, and shifts differently across ChatGPT, Gemini, and whatever renders the screen next quarter. The function converting your inputs into a recommendation is opaque and non-stationary at the same time.

So CPX is not a number you will compute. It is still worth having, because it is auditable in the breach. You cannot price the explanation, but you can absolutely observe when it fails. Ask an assistant about the job your product does and watch whether it recommends you, hedges, omits you, or describes you as something you are not. The operational form of the question is one I posed in March and would put on a wall now: does your product data give an agent enough confidence to recommend you without hedging?

That demotes CPX from a metric to a diagnostic. It costs precision and buys usefulness, which is a trade I will take, and it is answerable this quarter without a formula or a vendor.

The thing I have now written three times

Set the arc down and something else surfaces, which is that I have been circling one structural claim in three different vocabularies and never put them next to each other.

In March I wrote about the Occasion Gap between retailers and CPG companies. The retailer knows what sold, when, in what basket, at what price, in which store. What the retailer cannot know from a transaction record is the job the product was hired to do. That lives with the brand, built up over years of DTC feedback, reviews, support transcripts, and loyalty patterns. Both sides are navigating with half the map.

In July I wrote about the retailer against the assistant. The assistant captures stated intent, and stated intent is a real asset. A shopper asking for the best gluten-free pasta for marathon training has volunteered the why that marketers chased for a century. Then the assistant loses her at the handoff. It never learns whether the pasta became a Sunday habit. The store holds the opposite half: the basket, the reorder cadence, the substitution when the usual brand was out of stock. Behavior, which does not perform for the camera. Each one is missing precisely the half the other has.

And for the last six weeks I have been writing a series about enterprise knowledge whose entire first move is the distinction between what a company says it does and what it actually does, and whose argument is that an outcome is only interpretable next to the things that produced it.

Same shape. Three domains. Seventeen months.

Two parties, each holding half of one instrument reading, neither trading, both optimizing on half the map. A purchase is half the instrument reading. Whether the promise held is the other half. Whatever the domain, the value sits in the join, and almost nobody builds the join.

What is actually left

Add up what the platform has taken and what remains is short, and better than it sounds.

The platform can regenerate your page. It can relocate your checkout. It can decide which occasion your product is shopping for this afternoon. It cannot regenerate earned trust, and it cannot fake the substrate underneath the surface: what your product is for, who it is for, and whether it did what the rendered headline promised.

That substrate is the one asset on the list that compounds. The assistant’s loop is wide and shallow, touching every category, knowing what everyone said. The retailer’s loop is narrow and deep, touching one relationship and knowing what one household actually does over years. Wide compounds by adding categories and ends when the map is full. Deep compounds by adding resolution and has no ceiling, because there is always more to learn about why a real customer does what they do.

CPX is what you pay to make that substrate legible to a machine that decides without telling you. The confirmed why is what you get back. Those are the two halves of the same transaction, and I did not see that until I put nine months of posts in one place.

Which is the honest reason for this piece. Since October I have been writing what I thought were separate commentaries on agentic commerce, and they have been one continuous argument about who the agent works for and what the brand still owns when the answer is not you. The loop closes in the system prompt. Then the question becomes whose loop it is. Then it becomes who renders the surface the loop closes on.

I have no idea what layer moves next. I have stopped assuming the answer is the obvious one, and I would encourage you to hold your own forecasts the same way, because the ones I got wrong were wrong in the mechanism rather than the direction, and the mechanism is where the money is.

Regular readers will see where that lands. Judgment at Scale has spent two arcs on where judgment belongs in an architecture and what a company has to encode before any of it works. I filed the commerce writing separately, as the thing I did when the market moved. It has been the same investigation approached from the other end. Those arcs ask what you need to know to act well. This one asks what is left of you when the agent doing the acting is not yours.

For now, one question worth taking into your next planning meeting. You know what your customers bought. Do you know what they hired the product to do, and could you prove it to a machine that has already decided whether to mention you?

The views here are mine alone, not EY’s, my colleagues’, or my dog’s. Any technology or patent I reference is for illustration, not endorsement, investment advice, or a subtle hint to upgrade your stack. A granted patent describes what a company reserved the right to do, not what it shipped. Treat it accordingly.

I’ve seen a lot and I share a lot. Just don’t buy servers, software, or shopping agents because I mentioned them.

Sources: USPTO, US12536233B1, “AI-generated content page tailored to a specific user,” granted Jan 27, 2026. Apple Foundation Models framework and the on-device model shipping in iOS 26; WWDC 2026 developer sessions (framework opened to third-party providers, on-device Spotlight retrieval, agentic app APIs). Shopify merchant integration figures via Forrester. ChatGPT weekly active users and paid subscriber counts per published 2026 usage statistics; ad eligibility covers the free and Go tiers. Prior installments in this series for the Loyalty Loop, anchor tenant, perceptual elasticity, Occasion Intelligence, and Ground-Truth Flywheel framing.

Well-Informed Agents (WIA), Issue 6 — AI Strategy for the Deliberate Enterprise

Talbott Grocery, last time. I promise.

New fiscal year, same question. Growth options for the coming year, and the request lands on the same agent that embarrassed itself last quarter by proposing automated micro-fulfillment to the one executive who had personally killed it in 2021.

This time the answer comes back shorter than anyone expected.

Micro-fulfillment was evaluated in 2021 over six weeks and declined on order density. The break-even required roughly triple the store-level e-commerce volume, and the Southeast was not going to supply it inside the lease term. That condition was written down with a date on it. Two of the three candidate stores crossed the volume line in Q2. The reasoning has a second component, recorded as held by the COO and never documented, which the agent flags and does not try to reconstruct. The recommendation is not a proposal. It is a request to reopen a closed question, with the original model attached, addressed to the person who closed it, delivered to her before it goes anywhere else.

Nothing about that output required a better model. It is the same model that failed the same question three months earlier. What changed is that five different things the company knew showed up in the same second.

What the five lines actually say

Five categories over five issues is a lot to hold, and the version that survives a board meeting is short.

Declarative knowledge is what you say you do. Your methods, policies, frameworks, the codified record of your own intentions. Quality management has been repeating a version of this for forty years: say what you do, do what you say. Issue 2 established that most enterprises finished the first half in prose and never converted it into anything an agent can query, which is why the agent invents a refund window that sounds right.

Experiential knowledge is what you actually do. The lived record. What was tried, in what context, and how it went. Issue 3 found this evaporating on the afternoon projects close, which is why the agent walks you back into 2023.

Judgment knowledge is why the two diverge. Every gap between the stated policy and the actual practice is a place where a senior person decided something, usually for a reason, usually without writing it down. That category got a full arc of its own.

Relational knowledge is who decides, who was involved, and how they are all connected. Issue 4’s power map, and the map is larger than the decision rights. It holds who carries the real authority, who merely needs to be informed, who was in the room on the way to the answer and in what capacity, and where the lines run between all of them. A good share of it sits outside your walls: the vendor who has outlasted three of your reorganizations, the regulator’s staff who reviewed the last filing, the client sponsor whose quiet nod is the actual gate. Veterans hold the whole graph, deny holding it on the record, and consult it before any document moves.

Outcome knowledge is what all of it produces. Issue 5 renamed the negative category and then argued the rename was the truer name. Outcomes are the residue the whole system throws off. Chosen and declined together, reasons attached, conditions dated.

One caution on the schema. It is a leadership device, not a formal definition. Declarative knowledge is inventory as much as claim, and the first line stretches to cover a prior deliverable. Use the five lines to orient a room in thirty seconds, then do the real work underneath them.

Five categories do not share a shelf

Your kitchen already knows this. Flour does not live in the freezer, knives do not live in the drawer with the dish towels, and the oldest yogurt migrates to the front of the fridge because you will otherwise find it in November. Nobody designed a kitchen by choosing one container and buying forty of them. Yet that is close to what most enterprises did this year when they standardized on a vector database and called it a knowledge strategy.

Each category wants a different place to live, and the differences are not preferences. They are consequences of what the knowledge is.

Declarative knowledge wants structure. Named entities, effective dates, supersession logic, the machinery that answers which of three contradicting numbers is currently true. That is an ontology question with a correct answer, and similarity search is the wrong instrument for it.

Experiential knowledge wants resemblance. The useful query is has this company been somewhere like here before, which nobody can express as a filter. Vector retrieval and case-based reasoning are built for exactly that, and they are why Issue 3 was the easiest of the five to fix.

Relational knowledge wants a graph with a clock in it, and the graph is the substance here, not the packaging. Parties as nodes, internal and external alike. Edges carrying what matters about each connection: who decided, who was consulted on the way, who was informed afterward, who has standing to reopen it, who owns the relationship now. Written as constraints and roles instead of characterizations of people, which is the translation Issue 4 turned on, and dated throughout, because the map rots with every reorganization and every account team change.

Outcome knowledge wants a structured register, and the container under it is deliberately unglamorous. Decisions as the unit, both columns, reasoning preserved, revisit conditions dated. A relational table holds that perfectly well. So does a node type on the ontology, and the second wins for a reason unrelated to the record itself: an outcome is only interpretable next to the things that produced it. The decision needs canonical links to the policy version that governed it, the cases that informed it, the parties involved, and the reasoning scribed at the time. Store the outcome loose and you have a list of verdicts. Store it linked and you have the join across the whole taxonomy.

Judgment wants a store too, and here I need to correct an impression the previous arc may have left. Placement is real. Judgment lives in the behavior layer, the harness, or the environment, and where you put it decides whether it survives the next model release. That argument was about where the faculty operates. It was never a claim that the exercises of the faculty are unrecordable, and treating them that way is how the most valuable category in the taxonomy ends up sitting entirely inside people who eventually retire. What the store holds is a corpus of observed decisions, and the next section is about why observed is the load-bearing word.

The diagnostic here takes one meeting. Ask what your knowledge strategy is. If the answer is one technology, you have one-fifth of a strategy. Most enterprises this year will answer with a retrieval architecture, which is a genuinely good answer for the second category and a category error applied to the other three. A company can be entirely ready for experiential knowledge and completely blank on outcomes. Semantic readiness is a per-category assessment. The categories fail independently.

Where judgment fits now

The two arcs have been circling each other, so let me put judgment in its place.

MYCIN already told us which capture method fails, fifty years ago, and Issue 1 opened on the wreckage. Stanford’s engineers sat across a table and asked physicians to state their rules. They got six hundred facts and never got the knowing-when, because how do you decide is a question experts cannot answer in the abstract. Ask a good buyer how she prices a distressed lot and you will get a shrug and the word “feel.” Watch her do it eleven times and you will have most of it.

So stop asking. Judgment is observed, not interviewed. Sit in the room, record what was weighed, what was set aside, and what tipped it, and do that across enough instances that the pattern shows up in the aggregate. The synthesis comes later, out of the corpus, and it is a different artifact than any participant could have produced on request. What a person cannot articulate about their own reasoning, thirty scribed instances of that reasoning will show you.

Which makes the review forums, the pricing committees, and the deal desks the richest unexploited asset in the building. Judgment gets exercised in those rooms on a published schedule, in front of witnesses, with a calendar invite. What survives is a decision line in the minutes with the reasoning stripped out.

Now the distinction that matters. Judgment is the faculty, and the other four categories are what it consumes and what it leaves behind. The COO’s veto in 2021 was judgment operating on a case library she carried in her head. What survives of that afternoon depends entirely on whether anyone was writing while it happened. The register catches the fossil: a verdict, reconstructed later, reasoning approximated from memory by people who have told the story a few times and smoothed it. A scribe catches the thing itself: the options actually on the table, the CFO’s model as it was challenged in the moment and not as it was summarized in the deck, the point in the conversation where the produce question came up and closed the discussion. Same decision, two very different records, and the difference sits upstream of every technology choice in this arc. It comes down to whether somebody was assigned.

The faculty stays with her either way, which is the part the previous arc addressed and the reason placement, ownership, and escalation design remain load-bearing. Thirty scribed decisions do not add up to a judgment engine. They add up to a corpus about how this company weighs things, which an agent can reason from and a successor can learn from in something short of the fifteen years it took to build. Any program claiming more is selling you a repository and calling it a mind.

The thread back is the revisit condition. A dated rejection is a tripwire that returns a settled question to the person who settled it, at the moment the ground moves. Encode why not, and the agent can tell you when yes. Notice what that does: it uses encoded knowledge to summon human judgment instead of replacing it.

The moment nobody owns

Everything above describes five workstreams. The agent does not experience five workstreams. It experiences one second.

At the instant it acts, an agent pulls whatever it can reach into a single context and reasons over that. The Talbott output needed the register to surface the 2021 decision, the temporal data to test the revisit condition against Q2 volume, the ontology to confirm which policy version governs a capital request this size, the case library to supply the 2023 lesson about what not to call a rollout, and the relationship graph to establish both that the COO reads it first and alone, and that the outside firm which built the 2021 order-density model is still under contract and can be asked to re-run it. Five substrates, one query, no human in the sequence.

Notice that the agent did not run five searches and staple the results together. It followed one decision to everything attached to it.

Anyone who has bought a used car has seen the mechanism. Seventeen characters stamped on the dashboard, and the recalls, the service history, the title transfers, and the accident in Ohio all attach to those seventeen characters. Carfax is not clever. It is canonical. Without the VIN you would be matching records by “silver Honda, roughly 2019,” which is precisely what a similarity score does, and precisely why it returns the wrong car with great confidence. Your decisions need a VIN. The ontology carries the identity of the thing being decided, and the case, the constraint, the policy version, the scribed reasoning, and the outcome hang off that identity instead of floating in separate systems waiting to be correlated by resemblance. Assembly stops being a retrieval trick and becomes a modeling decision, which is good news, because modeling decisions can be reviewed by people who understand the business.

That still leaves the design problem nobody in your building owns. Declarative knowledge belongs to whoever runs policy. Experiential knowledge belongs to delivery. Relational knowledge belongs, informally, to your most senior operators. Outcome knowledge belongs to whichever governance forum agrees to file it. Five subcontractors, all competent, and no general contractor. Anyone who has run a renovation knows how that ends: the drywall goes up before the wiring is inspected, every trade is technically correct, and the homeowner learns that sequencing was the entire job. The moment where all five kinds of knowledge have to arrive together gets resolved by whoever wrote the retrieval logic, usually a contractor, usually in a sprint, usually without knowing that four of these categories exist.

Three signs your knowledge is not assembling, none of which needs an audit:

Nobody can tell you what the agent knew. Pick one output your agent produced last month and ask what was in its context when it produced that. If the answer is a shrug or the name of a vector database, you cannot debug the agent’s knowledge, because you have no record of the agent’s knowledge.

Your knowledge program has five owners and no integration point. Each category has a sponsor, each sponsor has a roadmap, and nobody’s name is on the retrieval path. Five successful projects will produce five successful projects.

Your agent has no way to say what it does not know. The Talbott output flagged the undocumented second reason and stopped. An agent that cannot mark the edge of its own map will paper over it fluently, and the fluency is what stops you from noticing.

That third one is the honest limit of the whole arc, and it is worth naming what kind of limit it is. The produce supply chain reasoning is missing because nobody was scribing that offsite in 2021. It was capturable. It was capturable by one person with a notebook and a mandate, and the company chose otherwise without ever framing it as a choice. Some of what your veterans hold is genuinely unwritable, and considerably less of it than the comfortable assumption suggests. A well-informed agent is not one that knows everything. It is one that knows where its knowledge ends and routes across that boundary to a person, which is exactly the placement discipline the previous arc argued for.

The move this quarter

The obvious plan is a category at a time across the enterprise. Declarative this year, experiential next. That is how the work gets budgeted and why these programs die, because nothing is usable until the last category lands, and by then the sponsor has moved on.

Do the opposite. Pick one recurring decision that matters and encode all five categories against that decision only.

The pricing exception, the vendor renewal, the capital request under a threshold. Then, for that decision and nothing else: get the governing policy into structured form with its version history. Buy an hour each from three people who have made this call, which is Issue 3’s move. Map the parties, inside the company and outside it, in the form Issue 4 argued for. Backfill the last ten instances into a register, approved and declined together, with revisit conditions. Put a scribe in the room the next four times the decision gets made, briefed to record what was weighed and what was set aside, which is the part the minutes always drop. Give every one of those artifacts a canonical link to the decision it belongs to. And name one person who owns the moment where all five reach the agent.

That is a quarter of work on a slice narrow enough to finish, and at the end you have what the category-at-a-time plan cannot produce for years: one decision an agent can genuinely act on, and a working template for the next one. Depth first, then breadth. The register you build along the way is also how you learn whether any of it worked, which is the property Issue 5 was pointing at. Outcomes are what the other four categories produce, so the outcome register is the one place the whole system gets graded.

What the deliberate enterprise commits to

In Issue 1 I said the model shows up knowing everything in general and nothing about how your firm decides, and that closing the gap was always going to be your job. That still holds. Here is what I would add now that the categories are on the table.

The encoding is the easier half.

Thirty years of knowledge management learned this, and most of it learned too late. Somewhere in your company there is a Lotus Notes database, a SharePoint site, and a Confluence space called Lessons Learned, each launched with a memo and each abandoned within eighteen months. Standing up a repository is a project. It has a budget, an end date, and a launch. Keeping it true is an operating discipline with none of those, and that is where those programs actually died. The graveyard is not full of enterprises that failed to write things down. It is full of enterprises that wrote things down once.

Every substrate in this arc decays, at its own rate. Relational knowledge rots fastest, which is why Issue 4 dated it. Rejections rot slower, and the revisit condition catches them. Policies do not rot so much as accumulate, superseding each other quietly until three contradicting numbers coexist and one person knows which is live. Case libraries stay accurate about a company that no longer operates that way. A scribed judgment corpus has the gentlest decay and the most treacherous, because the record of how the company weighed things in 2024 stays permanently true as history while quietly ceasing to be guidance.

Your phone has the same problem. Every contact in it was correct when you saved it. A third of those numbers now reach someone who changed jobs, and nothing in the entry tells you which third. You find out by calling.

Agents change the stakes on all of it. A stale wiki is harmless because nobody reads it. Stale encoded knowledge gets read constantly, at machine speed, in the model’s confident voice, and acted on before anyone calls to check. The half-life of your knowledge used to be a documentation problem. It is now an operational one.

So what the deliberate enterprise commits to is an admission. Institutional knowledge is a live system with maintenance costs. Those costs run lower than an agent fleet reasoning fluently from things that stopped being true. And somebody’s name has to be on it.

The rest is the ordinary work of running a company that knows what it knows.

The views here are mine alone, not EY’s, my colleagues’, or my dog’s. Any technology I reference is for illustration, not endorsement, investment advice, or a subtle hint to upgrade your stack. If I’m actually recommending something, I’ll make it obvious (possibly in ALL CAPS).

I’ve seen a lot and I share a lot. Just don’t buy servers, software, or knowledge solutions because I mentioned them.

Your Agent Gets One Second to Know Everything You Know was originally published in Messy Founder on Medium, where people are continuing the conversation by highlighting and responding to this story.

Well-Informed Agents (WIA), Issue 5 — AI Strategy for the Deliberate Enterprise

Talbott Grocery, one more time, because the agent has earned it.

Since Issue 3, the agent has a case library. It knows about the 2023 forecasting pilot, knows the data starved, knows why. Since Issue 4, it has the constraint graph. Pre-reads route in the right order, the sensitive pairings never share a page, and the regional VP gets his private first look before anything circulates. The agent is better informed than most of the consultants Talbott has ever hired.

Asked for growth options for the coming fiscal year, it proposes automated micro-fulfillment: robotic picking installed behind the three highest-volume stores. The vendor scan is current. The labor math is careful. The risk section cites the case library and recommends against calling the rollout a pilot, which is the kind of detail that makes you proud of your substrate. The routing graph delivers it, correctly and privately, to the chief operating officer first.

Who spent six weeks of 2021 evaluating exactly this, and killed it.

She remembers the offsite. The CFO had built the model himself: at Talbott’s order density, the robotics never amortize. Break-even wanted roughly triple the e-commerce volume per store, and the Southeast was not going to supply it on any horizon the lease could survive. There was a second reason too, involving the produce supply chain, that never left the room. It was a good decision, made carefully by the most senior people in the company, and it produced nothing at all. No pilot. No failure. No case. A calendar entry, and a slide deck archived under a project name nobody would ever think to search.

The case library cannot help here. It records what the company lived through, and this decision was engineered precisely so that the company would not live through it. The routing graph did its job: the document arrived at the one desk in the building that would recognize it. That is landmine avoidance, and it is worth something. It is not the same as the agent knowing. The best-informed agent in the arc so far just spent its credibility re-opening a question its own executive team spent six weeks closing, and it will do it again next quarter, because nothing it can reach says the question was ever asked.

The knowledge that leaves no event

Issue 1 called this category negative knowledge: what failed, and why. Standing at the end of the arc, I can be more precise. It has two halves, and they are invisible for different reasons.

The first half is the autopsy. Something was tried, it failed, and the reasons were understood by the people closest to it. Issue 3 met this half at Talbott: the 2023 pilot died and left no artifact, because post-mortems are for launches. The failure at least happened. There was an event, witnesses, a season of consequences. In principle there was something to record.

The second half is the veto, and it is stranger. Something was evaluated, seriously, by people whose time is the most expensive in the building, and the conclusion was no. A veto that holds produces no event at all. Its entire signature is that nothing happened. The reasoning that killed the micro-fulfillment proposal was some of the best reasoning Talbott ever paid for, and it evaporated by the end of the meeting, because the deliverable of a good rejection is the absence of a project.

Uncaptured, this knowledge decays along a predictable curve. For the first year or two it lives in the room: someone says “we looked at that,” the proposal dies, and the system appears to work. Then the reason detaches from the conclusion. The enterprise remembers that it does not do micro-fulfillment without remembering the order-density math that made it true, at which point knowledge has become superstition. There is an old story about a family recipe: the daughter trims two inches off the roast before it goes in the oven because her mother always did, and her mother did because her mother’s pan was too small. The reason expired a generation ago. The trimming survives. Enterprises run the same kitchen, at nine figures. Then the people leave, and the enterprise forgets even the conclusion. It re-runs the full evaluation at full price, on average every few years, forever.

Agents change the interest rate on all of this. A veteran consultant re-proposes the dead idea once a year, at a billing rate that at least imposes a natural limit. A fleet of agents can re-propose it weekly, fluently, to different audiences in parallel, each proposal polished enough to demand a real response. The category was always expensive. Autonomy makes it compounding.

Why nobody files the autopsy

So capture it. Write the vetoes down, mandate the post-mortems, build the repository. Every enterprise has had this idea, most have attempted it, and the shelf of abandoned “lessons learned” systems is deep enough to prove the failure is structural, not a run of bad implementations.

The structure is political, and it operates on both halves of the category.

An autopsy with real causes has names in it. Issue 3 established this: the honest account of the 2023 pilot would have to say which head-office decision poisoned the well. A veto record has a subtler cost. To document that micro-fulfillment was seriously evaluated and rejected, a leader has to put on the record that the company spent six weeks and an offsite on an idea that did not survive contact with its own CFO. The knowledge is valuable in direct proportion to how seriously the bad idea was entertained, and the seriousness is exactly what nobody wants attributed.

I said it in Issue 1 and it is load-bearing here: nobody gets promoted for filing the autopsy. Now add the sponsor’s version of the problem. Stand up something called a failure database and you have volunteered to curate a museum of the company’s mistakes, with attribution, and your name is on the building. Asking colleagues to contribute is asking them to write the exhibit labels for their own worst quarters. The system can be perfectly engineered and it will starve, for the same reason the Talbott pilot starved: people have learned what happens to data that can be used against them.

The renaming that got it built

Here is where I stop describing the problem from altitude, because I have spent the past four months inside it, and the thing that finally worked was not an architecture. It was a word.

Since March I have been socializing these five kinds of knowledge in rooms full of the people who would have to fund the encoding. Four of the categories start dialogue. People interrupt, argue, volunteer their own examples.

Negative knowledge got none of that. Head nodding. No questions, no comments, just polite agreement that it is important. In an executive room, that particular silence is a verdict. Nobody was disputing the logic, and I have learned to get nervous when nobody disputes the logic, because it means the objection is arriving on a channel I cannot hear.

It reached the point where I would qualify the category before anyone could react. I know most organizations do not want to write down their failures, I would say, but we have a real need to learn when we try something and it does not work out, or when we move in a direction and then decide to pull the plug. Notice what I was doing. I was apologizing for the category in advance, and the apologies changed nothing, because the name was doing its damage before I finished the sentence. A system that captures only failure asks every contributor to confess and every sponsor to preside over the confessions. I was asking rooms full of leaders for candor and offering nothing but exposure in return.

One day, preparing the same talk again, I removed the friction instead of qualifying it. I renamed the category: Outcomes. The ask stopped being document your failures and became document every outcome, and learn from any of them. It felt more honest the moment I said it, and most of the angst left the room with the old name. The unit of capture moved from the failure to the decision and what it produced: what was chosen, what was declined, what the reasoning was, and what happened next. Positive and negative in the same ledger, filed by the same act. Filing a win and filing a loss became the same gesture, which means filing a loss stopped being a gesture at all.

Part of what makes the mechanism work is that half the appetite already exists. Nobody has to be persuaded to document a win. The win gets the case study, the QBR slide, the award submission, volunteers lining up for the byline. What the win rarely gets is the rigor the register demands: which options were declined on the way, why it worked, and under what conditions it would stop working. That gap matters, because a success without its reasons hardens into doctrine just as surely as a rejection without its reasons hardens into superstition. Both columns need the same treatment. The wins simply do not resist it.

So the design move is deliberate on both sides. Channel the enthusiasm that already exists through one mechanism, ask the same questions of every consequential decision, and let the losses enter through a door the wins have already propped open. Aviation settled this decades ago. The flight recorder earns its reputation on the crash, but it records every flight, the ten thousand ordinary landings along with the emergency, and that is why pilots fly with it willingly. A recorder that switched on only when something went wrong would spend its career being disabled. One template applied to everything reads as discipline. A special form that only appears when something dies reads as an inquest, and people behave accordingly.

The taxonomy does not change. Negative knowledge is still the analytical category, and still the hardest one to capture. But the honesty I felt in the room has an argument underneath it. The renaming is more than friction removal. It is the truer name. Everything the enterprise says it does, everything it actually does, every judgment call in the gap between the two, every decision about who decides: all of it eventually discharges into a result. Outcomes are the residue the whole system throws off, and a register of them is the one record that touches every other category in this series. The taxonomy called this knowledge negative because it was cataloguing what enterprises are missing. The enterprise should call it outcomes because that is what it is.

And taxonomies are for architects. Adoption has different physics, and the category’s own name is a landmine of the kind Issue 4 taught the agent to route around. Encode the constraint, not the gossip, said Issue 4. This issue’s version: capture the outcome, not the blame.

Three signs your rejections live nowhere an agent can reach

The diagnostics, as always, are observations you can make this quarter without an audit.

One: someone says “we looked at that already,” and the look cannot be produced. This is the cousin of Issue 3’s “we tried that.” It is worse, because with a failed project there was at least an event someone could reconstruct. Here, if the person who ran the evaluation leaves, the enterprise does not just lose the answer. It loses the fact that the question was ever asked, which means it will pay to ask it again.

Two: your decision archive only records yes. Pull the last twelve months of any investment committee or product council. Count the artifacts attached to approvals, then count the artifacts attached to declines. Approvals travel with a business case, minutes, a funding trail, and named owners. Declines travel as an agenda line. An agent reasoning from that archive will faithfully learn half of your judgment. The confident half.

Three: your rejections have no reopening conditions. Ask a senior person why the company does not do something it once considered. If the answer is “we don’t do that,” you are hearing the roast get trimmed. The reason has already detached from the conclusion. Underneath that sentence there was once a model with numbers in it, and the numbers had dates. If nobody can say what would have to change for the question to reopen, the rejection has finished rotting from knowledge into reflex, and a reflex fails in both directions: it blocks the idea in the year the math finally works, and it stops nobody who never heard the reflex, including every agent you deploy.

A ledger with reasons and a clock

Software engineering quietly solved a version of this problem years ago. An architecture decision record is a short, structured artifact: the context, the options considered, the choice, the consequences, and the options rejected and why. It lives in the repository next to the code it governs, and its whole purpose is to stop the team of 2026 from relitigating what the team of 2023 already settled, while making it possible to relitigate deliberately when the context changes.

The enterprise version is a decision register, and the outcome-knowledge framing tells you what goes in it: the decisions that matter, chosen and declined options together, the reasoning for both, and what happened next as results arrive. Two properties matter more than any tooling choice.

It needs structure, because the question an agent must ask is not a similarity search. “Has this been evaluated, what was declined, and does the reasoning still bind” is a structured query with a correct answer, the same species of question Issue 2 taught us to stop asking of a vector index.

And it needs a clock. Every rejection should carry the condition that would reopen it. Declined at 2021 order density; revisit if store-level e-commerce volume triples. Declined on the interchange economics; revisit if the regulation moves. Issue 4 put expiration dates on the power map because relational knowledge rots. Rejections rot too, on a slower schedule, and a rejection with a revisit condition is the difference between doctrine and knowledge. Doctrine says never. Knowledge says not while this holds, and an agent can test whether it still holds.

That test is the payoff of putting both halves of outcome knowledge in one place. An agent that can reach the 2021 veto stands down instead of spending its credibility, which is the defensive win. The offensive win is better: the agent that checks the revisit condition against current data and finds that order density finally crossed the line is doing something no amount of human memory does reliably. The people who killed the idea remember that they killed it. Nobody is assigned to notice that the reason expired. Encode why not, and the agent can tell you when yes.

The move this quarter

Pick one governance forum that decides regularly. Add one artifact to its output: for every consequential decision, approved or declined, the same five lines. What was decided. Why, in numbers where the reasoning had numbers. What was set aside on the way. What would reopen the question, or stop the answer being true. Who evaluated it. The approvals will get written without any encouragement, which is the point: they establish the template as the normal cost of deciding, and the declines ride in under it. Then backfill the ten biggest kills of the last three years, while the people who did the killing still have badges, and put the register somewhere your agents’ retrieval actually reaches.

Call it the outcome register. The heading is load-bearing, and by now you know why: the same five lines filed under the wrong one will not get written.

Where this leaves the arc

Five categories were named in Issue 1. Declarative knowledge wanted structure, and got it. Experiential wanted a case library findable by resemblance. Relational wanted constraints on a graph with a clock in it. Negative wanted a ledger of decisions, both columns, reasons attached, conditions dated, under a name people will actually file to. Judgment spent a whole arc getting placed, and has been waiting patiently for the rest.

Notice the position the last category holds. Outcomes are what the other four produce when they operate, which makes the register the one place the performance of the whole system lands as a record. That is going to matter next week.

Which leaves the question the series has been walking toward since the MYCIN story: assembly. Five kinds of knowledge, five substrates, one agent, one moment of action. Next issue closes the arc: the well-informed agent, and what it looks like when everything your enterprise knows finally shows up at the same instant.

The views here are mine alone, not EY’s, my colleagues’, or my dog’s. Any technology I reference is for illustration, not endorsement, investment advice, or a subtle hint to upgrade your stack. If I’m actually recommending something, I’ll make it obvious (possibly in ALL CAPS).

I’ve seen a lot and I share a lot. Just don’t buy servers, software, or knowledge solutions because I mentioned them.

While the assistant learns what customers say, your footprint records what they do. The Ground-Truth Flywheel turns that into the one advantage a pure-play can’t copy.

A customer who used to open your app now opens an assistant instead. She types “best gluten-free pasta for someone training for a marathon,” reads three sentences, taps a link, and buys. She never saw your homepage. She never touched your search bar. The first moment you learn she exists is when the order lands in fulfillment.

That entry point is moving, and it is moving fast. AI-driven traffic to U.S. retail sites grew 393% year over year in Q1 2026, and those shoppers convert better, spend more, and stay longer than visitors arriving through any other digital channel.(1) The number that matters more than the growth rate is the base: for most retailers, AI still accounts for less than one percent of total traffic.(2) The rails are being laid. The track is not finished.

This is the window. Not the moment of loss, the moment before it, when the entry point is migrating but the outcome is not yet decided. What retailers do in this window depends entirely on which flywheel they decide to build.

The loop everyone can see

There is a flywheel inside the assistant, and it is a good one.

More conversations produce more signals. More signals sharpen the model. A sharper model gives more relevant recommendations. Relevant recommendations pull the shopper back into the conversation next time. Each pass tightens the loop.

More journeys → more signals → smarter models → better recommendations → more journeys

This is real, and it compounds across every category at once. The same assistant that helped with running shoes on Tuesday helps with a coffee grinder on Thursday and a birthday gift on Saturday. It sees breadth no single retailer can match. When ten thousand shoppers start asking about the same product in the same week, it adjusts without a meeting.

Most of the strategy advice aimed at retailers right now amounts to one instruction: build this loop yourself. Stand up an on-site agent, feed it your catalog, optimize your product data so the outside assistants surface you accurately. All of that is worth doing. None of it is a moat. You would be building a narrower version of a loop the platforms already run at planetary scale, on the one input they own better than you ever will: what the customer says.

What the conversation captures, and what it loses

Give the conversation its due. When a shopper types “best gluten-free pasta for someone training for a marathon,” she has handed the assistant something valuable and specific: the why. Not just what she wants, but the reason she wants it. Marketers have chased that motive for a century, and here a customer volunteers it in a sentence. The assistant’s loop runs on stated intent, and stated intent is a real asset.

Then the assistant loses her at the handoff. It made the recommendation, took the click, and now it is gone. It never learns whether the pasta became a Sunday habit or a one-time experiment, whether the marathon training was real or a New Year’s aspiration that faded by March, whether the thing it recommended actually held up. The why it captured is a claim it never gets to verify.

Your store runs on something else. It runs on what people actually did.

In your data, “gluten-free pasta” is not a query. It is a Sunday-evening purchase that repeats every two weeks, sits in a basket next to electrolyte tablets and a foam roller, and shifts to a different brand the one week the usual one was out of stock. The conversation heard the request. You see the pattern, the cadence, the substitution, and the basket around it. One of those is a sentence a customer chose to say. The other is behavior, and behavior does not perform for the camera.

Consider what generates a signal inside a business with a store footprint that never generates one inside a chat window.

The basket. Not the item, the combination, and what it reveals about a life the shopper never described.

Reorder cadence. The rhythm of replenishment tells you when someone will run out before they know it themselves. Consumables and rapid-reorder categories are where AI-referred shopping showed its weakest relative lift through 2026, precisely because that loyalty is already locked into the retailer’s own signal.(3)

Substitution. What a shopper accepts when the first choice is gone is one of the most honest preference signals in commerce, and it exists only on the retailer’s side of the transaction.

The store as a sensor. Pickup versus delivery, dwell, local demand shocks, returns behavior, the seam between online and in-aisle. When SPF lip balm sells out across Chicago during a heat wave, that is a store signal, read in real time, that no open-web assistant has any way to see.

Closed-loop attribution. The retail media network watches the whole path through to purchase and reorder. The assistant watches a conversation and loses the customer at the handoff.

These are ground truth, the record of what happened rather than what was asked. And they sit on the far side of a boundary the language layer cannot cross, because the language layer only ever receives language.

The loop nobody has closed

Here is the strange part. Both loops are open, and they are open in exactly the same place.

The assistant holds the stated why and never sees the outcome. The store holds the outcome and never hears the why. Each one is missing precisely the half the other has. The prize in retail was never what a customer bought, and it was never even why they said they bought it. The prize is why they actually did and whether the experience matched the intent, and that answer lives in neither loop alone. It lives only where stated intent and revealed behavior can be laid over each other and checked, one against the other.

There is a mechanism that closes the distance, and it is almost embarrassingly simple. You circle back and ask. You told me you wanted this for marathon training. Did it hold up over your long runs? The stated intent from the front of the loop meets the lived outcome at the back, and for the first time you have a confirmed why: this product, bought for this reason, delivered or it did not, in the customer’s own words, tied to what they actually did afterward.

I raised this as a possibility months ago, as a light aside about the chat interface eventually asking how a purchase worked out. It belongs at the center of the strategy, not the margin. A closed loop measures the one thing no rating captures. A purchase is half the instrument reading. Whether the promise held is the other half. Retailers already collect a passive, lopsided version of this through product reviews, but reviews are self-selected and slow: you hear from the delighted and the furious, on their timeline, in prose you have to mine. The active version is solicited, timed, and anchored to the intent you already captured. It reaches the silent middle the review page never hears from.

And the answer sorts itself, because a closed loop produces two axes of signal, not one.

The first axis is sentiment: does the customer feel good or bad about the thing, the attribute, the occasion the product was bought for. The second axis is volume: how much that thing is being discussed, by customers and by your own merchants. Plot them together and the four corners tell you what to do.

Loud and negative is the fire. A product that failed the job people actually hired it for, discussed widely enough that the signal is unmistakable. If the product broke a promise it made, that goes to R&D. If the product is fine but the listing sold it for a job it does not do, that goes to merchandising, because the fix is the copy, not the product. You can only tell those two apart because you captured the intent up front. A star rating collapses them into one number.

Quiet and negative is the watchlist. Real dissatisfaction, low volume. This is where a coined idea earns its keep: test for the perceptual-elasticity threshold before you spend. Is this a defect customers will not tolerate, or a minor gap with room to stretch? R&D stays lower priority until the volume says otherwise.

Loud and positive is the goldmine already paying out. Loved and widely discussed. This is the confirmed why at scale, the raw material for the campaign and the next recommendation. Lead with it.

Quiet and positive is the seam almost nobody mines. Customers love the thing and barely mention it, so you get no credit for a strength you already have. The move is to make that strength legible, to feed the confirmed why into the listing, the search-facing copy, and the marketing. Two payoffs follow. Human shoppers finally see the thing you do well. And the recommendation engines that now mediate discovery start citing you for it, because generative engines build their answers from exactly this kind of authentic shopper language.(4) You get credit, from customers and from the models, for something you were already doing and getting no signal for.

Across all four corners, the loop does something for the customer, not only for the business. The follow-up reaches an unhappy shopper before the one-star review and before the quiet churn, learns where the gap was, and gives you the chance to make it right in the same touch. You find out and they get recovered, in one move.

Why deep compounds differently than wide

Call the retailer’s version the Ground-Truth Flywheel. It runs on the same shape as the assistant’s loop, with one difference at the center. It does not merely capture signal. It checks every stated why against a revealed outcome, and it gets more resolution on the why with each pass.

More journeys produce more behavioral signals and more confirmed motives. Those feed models no competitor can rebuild, because no competitor has the data. Better models produce decisions that reach across the whole business, into R&D, merchandising, marketing, and assortment, not just the next recommendation. Better decisions pull the shopper back. And each pass sharpens a picture of why real customers do what they do that is already unique and gets more specific every week.

The assistant’s loop is wide and shallow. It touches every category and knows what everyone said. The retailer’s loop is narrow and deep. It touches one relationship and knows what one household actually does, whether the doing matched the saying, over years.

Wide compounds by adding categories. Deep compounds by adding resolution. The first is a land grab that ends when the map is full. The second has no natural ceiling, because there is always more to learn about why a real customer actually does what they do. A retailer trying to win on width is playing the platform’s game with the platform’s ball. A retailer compounding on depth is playing a game the platform cannot enter, because the platform sits on the wrong side of the boundary from the outcome.

The trap, and the seam

The trap is that copying the assistant’s loop feels like progress. It is measurable, it is fundable, and every vendor in the market will sell you a piece of it. Meanwhile the store footprint gets treated as legacy cost, the basket gets treated as exhaust, and the two halves of every customer’s motive sit in separate systems that never speak.

The consumables pattern is the tell worth reading twice. The assistant’s loop posted its biggest gains in discovery-heavy categories, where a shopper genuinely benefits from someone narrowing the field. Its lift was thinnest in the things people simply restock, because that decision was made long ago, on the retailer’s side of the transaction. That is the deep loop already working on its home ground, using signals the retailer already holds and mostly does not connect.

The footprint is the sensor. The basket is the signal. The follow-up is the instrument that turns a purchase into a confirmed why. A business sitting on all three and racing to build a chatbot to match the chatbot is optimizing the input it will always lose while ignoring the one it can never be beaten on.

Why this matters now

The entry point is migrating while its ownership is still open, and the deeper advantage is sitting almost entirely unbuilt on the other side. Bain’s read of the same moment lands in the same place: winning retailers will capture the referral while retaining ownership of data, fulfillment, and checkout, and lean on in-store and off-site media that pure-play assistants cannot touch.2

Win the referral where you can. Structure the catalog, stand up the on-site agent, be present where shoppers now start. Do all of it. But do not mistake that work for the moat. The moat is the loop that closes, the one that lays what a customer said over what they did, confirms the why, and routes it to the part of the building that can act on it. You already generate both halves. Almost nobody connects them.

The future of commercial excellence will not belong to whoever copies the assistant’s flywheel fastest. It will belong to whoever builds the one the assistant cannot, and then feeds what it learns back into everything they sell next.

The views here are mine alone, not EY’s, my colleagues’, or my dog’s. Any technology I reference is for illustration, not endorsement, investment advice, or a subtle hint to upgrade your stack. If I’m actually recommending something, I’ll make it obvious (possibly in ALL CAPS).

I’ve seen a lot and I share a lot. Just don’t buy servers, software, or AI shoppers because I mentioned them.

Sources

1. Adobe Analytics, Q1 2026 retail traffic data, reported in “AI Traffic to US Retailers Jumps 393% in Q1 as Agentic Shoppers Outspend Humans,” Yahoo Finance, April 2026. Adobe tracks over one trillion visits to U.S. retail sites; AI-referred visitors showed higher conversion, revenue per visit, and time on site than other channels.
2. Bain & Company, “Agentic AI in Retail: How Autonomous Shopping Is Redefining the Customer Journey,” May 2026. Bain notes AI accounts for up to a quarter of referral traffic for some retailers while remaining under 1% of total traffic, and argues winning retailers will capture the referral while retaining ownership of data, fulfillment, and checkout.
3. Adobe Analytics, 2026 Prime Day Insights (business.adobe.com), and Adobe Digital Insights GenAI Traffic webinar, April 2026, in which Adobe identifies grocery and pet products among the weakest-boost categories for AI-referred traffic. On the reorder dynamic specifically, see Robert Hu, “Prime Day 2026 Set a Record and Shrank the Cart at the Same Time” (theroberthu.com), July 2026: the event’s gains concentrated in restock categories where brands were already positioned as the default, while discovery-dependent brands spent into a thinner basket. ↩
4. On generative engine optimization and how LLM answer engines assemble product recommendations from authentic shopper language, see industry GEO coverage, 2026 (e.g., Yotpo, “Best Generative Engine Optimization Tools,” June 2026), and the retrieve-then-generate framing in Guo et al., “Generative Engine Optimization Creates Underexamined Risks,” ICML 2026. ↩

It was a Tuesday morning. We lost our biggest customer.

Gone. No renegotiation, no wind-down period, no face-saving pilot. By Tuesday night six of us were sitting in the office eating day-old pizza and staring at a whiteboard that had not changed in three days. The pizza was a budget decision. The whiteboard was a warning sign.

My team was looking at me the way teams do in those moments. They were not waiting for a plan. They wanted to know whether I still believed we were going to be okay.

I did, and I told them so. I had no plan. What I had was a conviction that we would find one, and I said it out loud.

That sentence kept us in the room. Out of that week came the product pivot that became the foundation of our growth. Losing the client forced us to stop chasing logos and start solving problems. We stopped selling the dream version of our product and started building the version people actually needed.

That Tuesday turned out to be one of the best things that ever happened to us. You could not have told me that at the time. Nobody tried, which was wise.

The question every leader gets

“How do you know it will work out?”

I have been asked this in boardrooms, hallway conversations, over beers, coffee shops, and at family dinners by people who wanted reassurance more than a forecast. The question always carries the same undercurrent. Nobody is really asking for a prediction. They are asking whether you believe in what you are doing.

My answer has stayed the same for three decades: “I don’t know. I believe I’ll find a way.”

That is the most accurate thing I can say. Certainty is a luxury the moment rarely offers. Belief is the operating system.

The Belief Multiplier

Here is the pattern I have watched play out across four startups and thirty-one years: a leader’s expressed belief produces returns wildly out of proportion to the certainty behind it. I call this the Belief Multiplier.

The mechanics are observable. When a founder walks into the room steady, people relax. The problem has not changed, but their leader’s posture just told them it is still solvable. That relaxation creates space for creativity, for problem-solving, for the lateral thinking that never happens when everyone is braced for impact.

The multiplier runs in both directions. A leader who telegraphs panic, even subtly, collapses that space. People stop generating options and start managing risk. They get smaller exactly when you need them large.

One qualifier carries all the weight: the belief has to be real, rooted in an honest read of the team’s capacity to figure things out. People detect the difference faster than most leaders assume. Projected confidence without belief underneath it is theater, and teams review theater harshly.

What “act as if” actually means

Ever hear a talk that hits differently? Simon Sinek has a talk called Act As If Everything Always Works Out for You. It is worth a half hour of your time. His argument is that belief is functional. It changes how you show up, and how you show up changes what is possible.

The phrase gets misread, though. “Act as if” sounds like an instruction to pretend, to walk into the room performing a calm you do not feel while the problems pile up behind the smile. Every leader who has tried that version eventually ends up alone in the room.

The real instruction is more precise: lead from belief rather than from certainty. Model the conclusion you are working toward while the path is still forming. The pretender acts as if the problem does not exist. The believer acts as if the team will solve it. Those look similar from a distance and could not be further apart in the room.

Where I learned it

I grew up watching my father navigate his own ventures. He started and struggled and started again. I watched him absorb losses that would have finished most people, dust himself off, and keep going. Each setback became material. Over decades, his final company became what I think of as his Mona Lisa, the thing that only became possible because of everything that came before it.

He never talked about it in those terms. He just kept showing up.

That image stayed with me as a reference point rather than an inspiration; it was too close and too real to be inspirational. When I questioned whether my own confidence was well-disguised naivety, I thought about him. He was not naive. He was relentless. There is a difference, and it took me years to learn to tell them apart.

Belief is not blindness

The Demo Disaster taught me where the line is.

We were excited to show a major prospect functionality we had been building for months. What they saw was the duct-taped, work-in-progress version that behaved only if you knew exactly which buttons to avoid. They found the buttons. Their enthusiasm faded in real time, and we lost the deal.

Painful, but clarifying. Customers rarely buy potential. They buy proof. After that we refused to demo anything we were not ready to stand behind. Acting as if never meant pretending the demo was ready. It meant believing we were capable of building something that eventually would be.

The distinction is worth sitting with. Belief in the team and the mission is separate from belief in the current state of the product. Confusing the two is how “acting as if” curdles into delusion. The Belief Multiplier compounds belief in people. It does nothing for belief in a demo that only works when nobody touches it.

Why this matters beyond startups

Every leader carries this question, not just founders. A business unit head navigating a missed quarter. A project lead absorbing a scope change nobody saw coming. A manager whose team lost two of its best people in the same month.

In each case the team looks up for the same signal. Belief.

Certainty is almost never available at the moments it would be most useful. The future is not a spreadsheet. KPIs tell you where you have been; they go quiet on what to do next when the model changes.

What carries people through is the sense that their leader still believes the problem is solvable, that the situation has not exceeded the team’s capacity to respond. That belief requires no pretending. It requires choosing, deliberately, to lead from forward motion rather than defensive calculation.

The only metric that matters in these moments

Are people still generating options, or are they only managing risk?

If your team is still generating options, the Belief Multiplier is working. If they have shifted entirely into defensive mode, the belief has drained out of the room, and it is probably your job to put it back.

Not with a speech. Not with a town hall. With how you walk in on Wednesday morning.

A closing thought

My father never called it acting as if. He would have found the framing a little abstract, and he would have said so. He just kept showing up. Each time it got hard, he decided it was still worth it, and that decision, repeated enough times, became his Mona Lisa.

You do not need to know how the story ends. You need to decide it is still worth writing.

The rest tends to follow.

The views here are mine alone, not EY’s, my colleagues’, or my dog’s. Any technology I reference is for illustration, not endorsement, investment advice, or a subtle hint to upgrade your stack. If I’m actually recommending something, I’ll make it obvious (possibly in ALL CAPS).

I’ve seen a lot and I share a lot. Just don’t buy servers, software, or self-help books because I mentioned them.

Series: Well-Informed Agents (WIA), Issue 4 — AI Strategy for the Deliberate Enterprise

You can capture every situation your enterprise ever lived through and the agent will still walk into a room it doesn’t know is on fire. The map it was handed was the org chart, and the org chart is a tourist brochure. WIA, Issue 4.

Back to Talbott Grocery, the ninety-one-store chain that doesn’t exist.

Say Talbott did the work from Issue 3. They found the people who remembered the 2023 pilot, captured the situations they carried, built the case library, put retrieval in front of it. The agent planning this year’s rollout now knows what the last agent didn’t: the pilot starved when the regional managers stopped feeding it clean numbers, because the previous head-office system that asked for their data had been used to close four stores.

The agent uses that knowledge. This is the part that should make you sit forward.

It drafts the new rollout plan with a risk section, and the risk section is accurate. “Regional data withholding, as observed in the 2023 pilot, driven by manager concern that store-level metrics inform closure decisions. Mitigation: executive communication reaffirming that pilot data will not be used for store rationalization.” Clear-eyed. Correct. Then the agent does what agents do with finished documents: it circulates the pre-read to the stakeholder list it derived from the org chart. Which includes the regional VP for Alabama and Georgia. The one who goes still at the word “pilot.” The one who has just been handed a document, with his region named, stating in writing that head office knows his managers withheld data and has a plan for managing him.

The knowledge was right. The handling detonated it. A ten-year veteran carries the same fact and would never let it near a distribution list. She would raise it with the VP alone, first, framed as his idea, two weeks before any document existed. Not because the fact is wrong. Because facts about people travel differently than facts about freight.

The map is not the chart

Issue 1 called this category relational knowledge, and it is the one your leadership is most certain cannot be encoded, which is convenient, because it is also the one nobody wants to write down.

It is the real power map. Which executive is nervous about what, and since when. Which two functions cannot appear in the same recommendation without the recommendation dying in the crossfire. Who must hear a proposal privately before they will support it publicly, and who will oppose anything they learn about second. What the political weather is this quarter, which is a different thing from what it was last quarter.

Your experienced operators carry this map and consult it constantly. Watch a senior person prepare a document for circulation. The content was finished on Tuesday. What happens between Tuesday and Friday is not editing. It is routing: who sees it first, who gets the courtesy call, whose name comes off the risk section, which meeting it surfaces in and which it conspicuously does not. None of that work touches what is true. All of it determines what happens next.

The agent arrived with the org chart. The org chart says who reports to whom. It does not say who decides, who blocks, who sponsors, who is wounded, or who is waiting. Handing it to an agent as a stakeholder model is like handing a tourist a subway map and telling them it also shows which neighborhoods to avoid at night.

Why last week’s fix stops here

Issue 3’s answer was resemblance: encode the situations you lived through, let the agent find the past that rhymes with the present. Two things break when you point that machinery at relational knowledge.

The first is the corpus. Vector retrieval over situations requires that someone recorded the situations, and Issue 3 already met the reason they don’t: an honest account of the 2023 failure would have to name which VP resisted and whose decision poisoned the well. People will document a supply chain failure all day. They will not document a person. The candor problem isn’t a compliance gap you can close with a mandate; writing down power has consequences that carrying it in your head does not. So the corpus you would embed does not exist, and the fraction that does exist is the sanitized fraction, which is precisely the fraction with the landmines removed from the map.

The second is time. A case library works because past situations stay instructive; the 2023 pilot teaches the same lesson in 2026 that it taught in 2024. Relational knowledge rots. The power map from six quarters ago describes a company that no longer exists: the CFO changed, the wounded VP got promoted, the two feuding functions report to the same person now. Retrieval has no concept of current. It will hand your agent a perfectly preserved map of last year’s minefield, and the agent will walk confidently through this year’s.

The knowledge changed shape, and the substrate stopped fitting. This keeps happening for a reason.

Encode the constraint, not the gossip

Here is where most leadership teams stop. Relational knowledge is about people, it is political, it is volatile, therefore it is unencodable, therefore the humans will handle it. Half of that conclusion is right. The interesting half is wrong.

You are never going to store “the regional VP distrusts head office because of the 2019 closures.” That sentence is radioactive in any system, discoverable in any lawsuit, and unfair to a man who is mostly right to feel the way he does. But you do not need the sentence. You need what the sentence implies operationally, and what it implies is a rule: any document referencing store-level performance data in the Southeast routes to the regional VP before wider circulation.That rule is boring. It names no feelings and blames no one. It is also the exact behavior the ten-year veteran performs from memory, extracted from the reason she performs it.

This is the move: translate political intelligence into routing and review constraints. Consult-before edges. Must-not-co-appear rules for the two functions that fight. Sequencing requirements: this role hears it before that one. Sensitivity flags on topics, not people. The constraint carries the operational content of the relational knowledge while leaving the impolitic explanation where it lives, in the heads of the people who need to carry it. You get past the candor problem by not requiring candor. The rule does not have to say why.

The substrate follows the shape of the knowledge, the way it has all arc: structure for policy, resemblance for experience. Relationships want a graph: people, roles, and functions as nodes, the consult-before and decided-by and sensitive-to rules as edges between them. And because this map rots, the edges need dates. An edge without an expiry is a landmine of its own, a constraint your agent still honors two quarters after the VP retired. Graph plus time. Relational knowledge is the first category that needs both, and it will not be the last time currency matters in this arc.

Three signs your power map lives in people

One: documents in your company are finished days before they circulate, and the gap is spent deciding who sees them in what order. That gap is relational knowledge operating in real time. If a pre-read only goes out after a senior person has adjusted the audience and the sequence, you have watched the map get consulted, and you have confirmed it exists nowhere an agent can reach.

Two: ask three people who has to say yes for a specific recurring decision, then compare their answer to the org chart. Where the answers agree with each other and disagree with the chart, you have found the real map, drawn from memory, held nowhere. That territory is exactly what your agent will navigate by brochure.

Three: your senior hires get a briefing that never appears in writing. Every experienced leader knows the conversation: watch out for this dynamic, never put those two in a room, she says yes and means later. If the only way your enterprise can transmit this knowledge is verbally, in settings with no record, then your people have already concluded it is unsafe to encode as stated. They are right. Encoding it as constraints is the version that is safe, and nobody has been asked to do that.

The move this quarter

Take the same recurring decisions you picked in Issue 3, the ones your agents will touch first. Sit down with the two or three people who do the Tuesday-to-Friday routing work on those decisions today. Do not ask them about politics; you will get a polite nothing. Ask them what they actually do: who they call first, what they take out of drafts, which pairings they never allow on one page. Then encode what they do as explicit rules: routing requirements, review gates, sequencing constraints. Give every rule an owner and an expiration date, and put the review on a quarterly cadence, because the map you build in January is fiction by June.

And for everything the rules cannot hold, the texture too fine or too fresh to encode, the design answer is an agent that knows where its map ends. Anything crossing a flagged edge drafts instead of sends. Anything touching a sensitive topic proposes a sequence and hands it to a human rather than executing one. Where that judgment sits and who owns it is the architecture the previous arc built; this is one more thing that lives there.

Where this leaves the arc

Four categories in, the pattern should be visible. Each category has refused the substrate that solved the one before it, which is the arc’s quiet argument: semantic readiness is not a technology purchase, it is a matching discipline.

But there is a silence even the power map does not fill. The routing rules can tell an agent who must hear a proposal first. Nothing yet tells it which proposals should never be made at all, because your best people already weighed them, already killed them, and filed nothing, since nobody files an autopsy for an idea that never lived. The agent cannot see a decision that left no trace, so it will make the proposal again, in perfect earnest, with excellent formatting.

That is the hardest category, and the most valuable one. Next week: negative knowledge, and why your agents propose what your best people already rejected.

The views here are mine alone, not EY’s, my colleagues’, or my dog’s. Any technology I reference is for illustration, not endorsement, investment advice, or a subtle hint to upgrade your stack. If I’m actually recommending something, I’ll make it obvious (possibly in ALL CAPS).

I’ve seen a lot and I share a lot. Just don’t buy servers, software, or knowledge solutions because I mentioned them.

Start with a product listing.

A retailer used to write one by hand. Someone looked at the running shoe, decided which three features mattered, chose the photo, argued about the headline, and shipped it. Then shoppers arrived. Some bought, most didn’t, and of the ones who bought, some kept the shoe and some sent it back. Both halves were a verdict. The purchase said the listing made a promise worth acting on. The shoe staying out of the return box said the promise was true. That signal traveled back into the system: this listing earned a sale and kept it, that one talked someone into a sale they regretted. Write more like the first. The doorstep was the teacher.

Now generate the listing with a model. Fine so far. Models write competent listings, and a human still decides whether to buy. The teacher is still in the room.

Then put a shopping agent on the other side. You tell it your size and your budget, it reads ten thousand listings, it picks one, it checks out. You get a box on the porch. The retailer gets a sale, and if the shoe fits, you keep it. The dashboard lights up exactly as it did before.

Look at what just happened to the teacher.

The purchase signal still arrives. But it no longer means a person looked at the listing, wanted the thing, and kept it once it showed up. It means one model wrote copy that another model ranked highly, and what agents prefer may drift, quietly, away from what people prefer. For now something still catches that drift: a person or system watching the sales line, reverting the listing when returns climb or the numbers sag. The loop holds because something is still tying the measurement to a real behavior at the doorstep. It breaks when the agent writes the listing, an agent buys it, and nothing is left watching the consequence. The needle still moves. The engine came off the car somewhere back down the road, and the only question is how long until someone looks up from the dashboard.

The story everyone tells about AI’s next few years is a story about supply. The models drank the internet, the well is running dry, and the race is on for more data, cleaner data, synthetic data to fill the gap. That is a real problem. It is not the one that will quietly break your system. The constraint that matters is not how much text is left to train on. It is whether the model, once it is doing a job, is still being graded by something real. A model is inert until it is used, and it is only in use, in an application, that reality gets a chance to tell it whether it was right.

This is the failure that matters in the next few years of AI, and it has almost nothing to do with running out of data.

The thing we keep calling ground truth is two things

There is a real-world event, and there is the measurement of it, and for thirty years they came as a pair. The listing made a promise. A person decided the promise was worth their money, and then the product kept it or broke it, and the shoe stayed or came back. The purchase is half the instrument reading and the return is the other half. Together they were the only access anyone had to what happened in that person’s head and then in their living room, and they were a faithful instrument for one reason: the only way to produce a kept sale was for a human to choose and a product to deliver.

The agent breaks the pairing. It produces the reading without the event underneath it. You still get the number. You no longer get the choice the number used to stand for.

A disconnected instrument and a connected one produce the same reading. Move from the shoe to the thing an agent is far likelier to buy on its own: the weekly snack order, the protein bar reordered without a second thought. A box bought by a human who reads the label and a box bought by an agent clearing a budget both show up as one unit sold. There have always been two lines here. One is hard: an allergen the label hid, a bar that arrives crushed or expired, the kind of failure that comes back regardless of who placed the order, because a person still eats it and reacts. The other is soft: the bar promised healthy with no aftertaste, and there is an aftertaste, faint enough to finish the box and grimace. A human crossing that soft line quietly stops buying the brand. An agent never crosses it, because it never tastes anything. It enforces the hard line and is blind to the soft one, so a listing can sit in the gap between them, overselling every person who actually eats the bar while never tripping the one signal the system still reads. That soft verdict used to feed the system through a thousand small behaviors: the non-rebuy, the switch to a rival, the word to a friend. An agent feels none of it. It holds no grudge and reorders the same disappointing bar next month because it still clears the budget. Hard failures bounce back; the fine-grained dissatisfaction that used to shape what got bought goes quiet, and the label that oversold looks identical to the one that told the truth. You can route in a replacement — a review, a complaint — but each is weaker than the return it stands in for, and each sits one shortcut away from the agent writing the review it predicts the human would have written, closing the loop right back up. You can preserve the measurement perfectly while destroying the truth it measured, and the dashboard will not so much as flicker.

The line you have to defend is not the data and not even the measurement. It is the link between the measurement and the event it claims to represent. Call it the Ground-Truth Boundary: the line past which a measurement is no longer anchored to the event it represents. Cross it and the system is grading its own homework. The grade still comes back. The grade stopped meaning anything, because the grader is now the student.

You would assume the enterprise is safe. That assumption is the trap.

The public web ran on human writing and is now being repopulated by machine writing, and everyone has read that story. The reflex is to reach for proprietary data behind the firewall as the clean reserve: healthcare records, claims data, demand histories, the stuff competitors can’t scrape. The enterprise is not immune. It feels safe only because it has generated synthetic data for a decade without trouble, and that track record reads as proof the ground is solid.

The adoption is not speculative. In a March 2025 SAS study, roughly half of healthcare organizations and a slim majority of life-sciences firms reported already using synthetic data or seriously weighing it, and seventy-one percent of U.S. hospitals reported running predictive AI inside their electronic health records in 2024. Synthetic patient data has moved out of the sandbox and into production, generated to satisfy privacy law and to manufacture examples of the rare events — the unusual disease, the fraud pattern, the supply shock — you most need to model and least have on hand.

For ten years this has been safe, and the reason is the whole argument. The synthetic cohort gets checked against a real outcome: you train on generated data, then ask whether the model predicts actual readmissions in actual people. The body does what the body does. The demand shows up or it doesn’t. Generation was synthetic; the verdict came from the world. The strongest result in the literature is that synthetic and real data together beat real data alone: synthetic to fill the gaps, reality to grade the work. It is the same structure as the doorstep. A prediction is a promise, and the readmission is the world keeping or breaking it. The kept sale and the validated prediction are the same load-bearing part, the place where reality holds the red pen.

The gate is harder to keep clean than it looks, and it rarely fails by anyone deciding to grade a model against another model. It fails by a quieter route, where the forecast bends the outcome that was supposed to grade it. Take demand forecasting. The model predicts next quarter, so you buy inventory to match. Now you can only sell what you stocked, so next quarter’s sales are shaped by the forecast that set the shelves. When the numbers come in they agree with the prediction, and the model looks accurate because it helped cause the result it called. The verdict still arrives. It is no longer independent of the thing it is judging. The grader started copying from the student.

There is a second, more ordinary route. The team that builds the model often generates the synthetic validation set and is judged on how the model scores against it — holding the exam and the answer key at once. Nobody cheats. They tune toward a number that has stopped pointing at anything outside the room. And the enterprises most fluent in synthetic data are the ones most likely to cross the line without looking down, because fluency reads as safety. Competence becomes the liability. The team that has done this safely a hundred times is the team that will not notice the hundred-and-first, when the outcome quietly stopped grading the model and started agreeing with it. The field can see the seam: researchers are pushing for validation that tests whether synthetic data supports real diagnosis and prediction rather than whether it merely resembles the real distribution, and they have documented synthetic pipelines that amplify the biases already sitting in the source. The dashboard does not change while any of it happens.

What carried the value in that healthcare loop was never the records. It was the outcome: the real readmission that eventually arrives to tell you whether the model read the patient right. That changes what the firewall is actually for.

One law, several rooms

Product listings, demand forecasting, clinical prediction, model validation. They look like four problems. They are one.

A generative system stays honest only as long as a real-world event stays in the loop to grade it. The grade can come from a shoe that did not come back, a body that healed or didn’t, a quarter of sales that held, but it has to come from outside the model. Hand the verdict to another model and the loop closes on itself, and a loop closed on itself has no way to learn it is wrong. It keeps producing confident scores while every standard benchmark says fine, because benchmarks measure the middle of the distribution and the damage starts at the edges — the unusual case, the genuinely new problem, exactly where you were counting on the AI to earn its keep.

This is why the Ground-Truth Boundary belongs beside the other lines a deliberate enterprise draws: the Routing Boundary for which calls a system makes on its own, the Take-Back Boundary for the actions it cannot undo. Each marks a place where you do not let the machine close the loop on its own authority.

What this asks of you

Not “stop using synthetic data.” Synthetic data plus a real gate is the most powerful combination available, and the evidence backs it. The discipline is narrower and harder: keep a real-world event at the closure point of every loop you care about.

Three questions draw the line in practice.

Where does the verdict come from? For every model you depend on, find the point where it gets told it was right or wrong, and follow that signal back. Does it terminate in something that happened in the world, a purchase, an outcome, a measured consequence — or in another model’s output? If you can’t trace it to the world in two steps, you are already across the boundary.

Are you protecting the instrument or the event? Guard the link, not the data. A sale that no longer traces to a person who wanted the thing and kept it, a readmission that no longer traces to a patient, is a measurement come loose from its event, and it is more dangerous than missing data because it looks exactly like the real thing.

What grades the agent when the human steps out? People reach for “keep a human in the loop,” but the human was never the point. The human was a pair of eyes reading a real signal, and a machine can read that signal faster and at three in the morning. Put an agent in charge of watching sales and reverting weak listings and you have lost nothing, as long as it reads real purchases that stick. An agent buying for a person, even an unfamiliar brand they’d never have found alone, still leaves a real verdict behind, because the person keeps the thing or sends it back. Automate the eyes. The verdict is the part you cannot hand over. The loop breaks the moment the agent is graded against a predicted sale instead of a real one, or its choices start answering to whoever pays it rather than the person it serves.

The scarce resource was never the data. The web took thirty years to write and the models drank it in a few training runs, and that is the story everyone tells. The resource that actually runs the machine is the steady arrival of real consequences — people choosing, bodies responding, quarters closing — entering the loop and rendering a verdict the system could not have written for itself. Automation is very good at removing exactly that. Every task we hand to an agent is a stream of real verdicts we stop collecting. The tank everyone watches holds data. The Ground-Truth Boundary guards what the gauge doesn’t show: whether anything real is still grading the work.

This is where the enterprise data story has been told backward. The advice is to treat your proprietary records as a novel training set: license it, ingest it, get it into the weights first. But records are not where the value was. Go back to the readmission. The prize was never the patient data. It was the outcome that arrived afterward and graded the work, the verdict only your loop produces, on your patients, on your operations. Data poured into a model is a one-time asset that ages the moment it lands. The same data kept live as a grader is the thing that compounds, because reality keeps issuing fresh verdicts and you are the only party positioned to read them. The value of your data was never what it taught the model. It was what it tells you about whether the application worked.

That is the signal an identically-trained rival cannot copy: not more facts, which everyone will have, but the verdicts from your own loop, on your own problem, arriving faster than anyone outside it can see. The grader in the room is the moat.

You can run for a long time after that grader leaves. The numbers hold. The dashboards stay green. While they do, the system that kept something real in the loop is still learning from the world, and the one that closed the loop on itself is learning only from its own reflection. They look identical on every benchmark. One is pulling away. The other is about to find out, slowly and then all at once, that green was never the same as right.

The views here are mine alone, not EY’s, my colleagues’, or my dog’s. Any technology I reference is for illustration, not endorsement, investment advice, or a subtle hint to upgrade your stack. If I’m actually recommending something, I’ll make it obvious (possibly in ALL CAPS).

I’ve seen a lot and I share a lot. Just don’t buy servers, software, or protein bars because I mentioned them.

Call the company Talbott Grocery. It doesn’t exist, which is the only way I get to tell you what happened at the one that does.

It’s a regional chain, ninety-one stores across the Southeast, the kind of operator that runs on thin margins and long memories.

The agent proposes a phased rollout for the new demand-forecasting system: pilot in three regions, instrument heavily, expand on the metrics. It is a good plan. It is a clean plan. It is, almost word for word, the plan Talbott tried in the spring of 2023, the one that stalled in month four when the regional managers in Alabama and Georgia quietly stopped feeding it clean numbers, because the last head-office system that asked for their data had been used to close four underperforming stores. The pilot didn’t fail on the technology. It starved. The managers had learned exactly what “just a pilot” meant, and they were not going to teach the machine that lesson twice.

That failure produced no artifact. There was no post-mortem, because post-mortems are for launches, and this never launched. The two analysts who lived through it moved to other teams. The regional VP who watched it happen learned to go still whenever someone said the word “pilot.” The lesson stayed in the room and nowhere else.

So the agent, reading a knowledge base swept clean of everything that didn’t ship, proposes the one approach the people around the table already know will fail. And it proposes it with total confidence, because nothing it can see says otherwise. It doesn’t know that in this company, “pilot” means they’re measuring us to cut us. It doesn’t know which VP goes quiet at that word. It doesn’t know that clean data stopped arriving in April and never fully came back. None of that was ever written down. It couldn’t be. Half of it would be impolitic on paper, and the other half nobody thought to record.

This is a different failure than last week’s

Issue 2 was about declarative knowledge, the four-page policy that contradicts itself across revisions. The fix there was structural: stop storing the rule as prose for humans and start storing it as facts an agent can resolve. Give the policy a substrate that machines can read, and the hallucinated threshold goes away.

Talbott is the moment that fix stops working.

You could structure every policy Talbott owns. You could build the cleanest ontology in the Southeast, every rule versioned, every exception linked, every threshold current to the minute. The agent would still propose the 2023 plan. Because the knowledge it needed was never a rule and never a policy. It was an event. Something happened, people learned from it, and the learning stayed in the people.

Declarative knowledge is what the enterprise decided to state. Experiential knowledge is what the enterprise lived through. The first can be written cleanly, which is why enterprises believe they have it. The second mostly cannot, which is why enterprises pay for it again and again without ever noticing the invoice.

What the doorstep knew

Think about how a good buyer learns a supplier.

Not from the contract. The contract says a supplier will deliver in fourteen days, meet spec, hold price for the quarter. Every supplier’s contract says that. The buyer learns the supplier from the third order, the one that arrived two days late during a promotion, and the phone call where the account manager blamed the weather. That is where knowledge actually accumulates: in the gap between what the paperwork promised and what showed up on the loading dock.

A person who has placed four hundred orders carries a compressed history of every one of those gaps. They cannot recite it. Ask them why they route around a particular vendor and they will say “they burned us once,” which is not the reason, it is the receipt. The reason is a texture built from repetition, and the texture is the knowledge.

This is the knowledge an agent arrives without. It has read every contract. It has read no loading docks.

The three signs your experiential knowledge lives nowhere an agent can reach it

You do not need an audit to find the gap. You need to notice three things that are already happening in front of you.

One: your best people say “we tried that” and cannot immediately produce the document. When a senior person shuts down a proposal in a meeting and the reason lives in their memory rather than in a link they can paste, you have just watched experiential knowledge exist entirely outside your systems. The knowledge is real. It is also, from the agent’s perspective, invisible. If the only copy is in someone’s head, the agent is working from a corpus that person would consider dangerously incomplete.

Two: your retrospectives cover launches and skip everything that died before launch. Most enterprises document what shipped. The half that quietly stalled, got reorganized away, or was killed in a budget meeting leaves no trace. That is the exact half an agent most needs, because those are the approaches that look reasonable on paper and fail in practice. A knowledge base built only from what shipped is a knowledge base optimized to repeat what didn’t.

Three: onboarding a senior hire takes months, and nobody can say precisely why. If a genuinely capable person still needs a quarter to become effective, the missing time is experiential. They are not learning the policies, they read those in week one. They are learning which projects are radioactive, which clients escalate, which “sure, let’s explore that” means no. The length of your onboarding curve is a direct measurement of how much of your operating knowledge has never been encoded.

If all three are true, and at most enterprises they are, then deploying an agent against your current substrate means deploying it with the confidence of a new hire and none of the caution a new hire eventually earns.

Why retrieval alone doesn’t save you

The instinct, having read this far, is to reach for the fix that worked last week. Structure it. Write the failures down. Build the post-mortem the 2023 pilot never got.

Do that. It helps. But notice what it costs and what it misses.

It costs candor. The reason the 2023 failure was never documented is not laziness. It is that an honest account would have to name which VP resisted, which stores were on the closure list, and which head-office decision poisoned the well. People do not write that down, because writing it down has consequences that living with it does not. You can mandate post-mortems. You cannot mandate that they tell the truth about power, and the parts they omit are frequently the parts that matter. That gap is its own knowledge type, and it gets its own issue.

And it misses the shape of the problem. Experiential knowledge is not a set of rules waiting to be transcribed. It is a library of situations. The useful question an agent needs to ask is not “what is the policy” but “when have we seen something like this before, and how did it go.” That is a similarity question, not a lookup. It is the difference between a phone book and a doctor who has seen ten thousand patients and recognizes yours in the first sixty seconds.

Which points at the substrate.

The substrate for lived experience

Declarative knowledge wanted structure: ontologies, graphs, the clean schema that resolves a policy conflict deterministically. Experiential knowledge wants something else. It wants to be found by resemblance.

Two technologies live here, and they do different jobs.

The first is vector retrieval. You take the record of a past situation, the 2023 pilot and everything around it, and you encode it so that “situations like this one” become findable even when they share no keywords. The agent facing the new forecasting rollout can surface the old one not because someone tagged them both “pilot,” but because the shape of the two situations rhymes. Vector retrieval is how you let an agent ask when have we seen this before and get an answer that isn’t limited to exact matches.

The second is case-based reasoning, which is the older and more demanding discipline. A vector store finds the similar case. Case-based reasoning does something with it: it carries forward the outcome, the adaptation, the reason this situation is like that one and the reason it isn’t. It is the difference between an agent that can retrieve the 2023 pilot and an agent that can say “the last time we ran this play the regional managers starved it, and the condition that caused that, a recent closure tied to a data request, is present again now.”

Building this costs real effort, and the effort goes almost entirely into the input rather than the technology. The technology is available this quarter. The hard part is the input. Vector retrieval over an empty case library retrieves nothing. You have to start capturing the situations, including the ones that never shipped, which means building the retrospective habit for failures that produced no launch and no obvious owner. The enterprises that will have experiential knowledge in two years are the ones that start hoarding their near-misses now, while they still have the people who remember them.

The move this quarter

Pick one decision your agents are about to make repeatedly. Supplier selection. Rollout sequencing. Whatever recurs.

Then find the three people who have made that decision the most times, and get one hour of the situations they carry, the ones with no document. Not the policy. The pattern. The vendor they route around. The approach they wince at. The client who escalates. Record it, structure it as cases, and put it where retrieval can reach it before you point an agent at the decision.

You are not building the full library in an afternoon. You are proving the substrate exists, capturing the experiential knowledge that is currently one resignation away from leaving the building, and giving your agent the one thing a new hire spends a quarter acquiring: the memory of what already went wrong.

Where this leaves the arc

Structure the policy and the agent stops hallucinating the rule. Capture the situations and the agent stops repeating the failure. Two categories down.

But notice what the honest post-mortem kept refusing to say. Which VP resisted. Whose data request poisoned the well. Who would escalate if named. Every time experiential knowledge got too close to a person and their power, the record went quiet.

That silence is deliberate, and no amount of retrieval fills it. It is the next category. Next week: relational knowledge, and why your agents step on landmines you could have mapped.

The views here are mine alone, not EY’s, my colleagues’, or my dog’s. Any technology I reference is for illustration, not endorsement, investment advice, or a subtle hint to upgrade your stack. If I’m actually recommending something, I’ll make it obvious (possibly in ALL CAPS).

I’ve seen a lot and I share a lot. Just don’t buy servers, software, or knowledge solutions because I mentioned them.