And it’s already started. Sandy Carter, the AI executive and Forbes contributor who has been documenting this shift closely, recently sat down with builders from three of the companies constructing it: David Minarsch of Olas, Nitya Subramanian of Para, and Will Papper of Cloudflare. Minarsch’s definition of agentic commerce is the clean: “If one software program purchases a service from another software program.” Simple, and no longer hypothetical. Carter reports that Olas has recorded more than 14 million agent-to-agent interactions, Para’s wallets serve more than 15 million end users, and more than 30 companies have joined Mastercard’s Agent Pay.

Carter frames the buildout in four layers, as four races. Payments, where Visa, Mastercard, and Stripe are competing to move the money. Authorization, where Para is building what amounts to a corporate card with rules attached: a wallet that holds funds and a permission structure that governs what an agent may do with them. Agent-to-agent interaction, where Olas runs the exchange. And fulfillment, where Cloudflare is making the point that purchasing is only half a transaction; something still has to arrive.

Money moves on the rails. Permission is granted. Agents talk. Goods arrive. It is a complete picture of a transaction, and an incomplete picture of commerce.

The question the four layers do not answer

Before any of this scales inside a large enterprise, a fifth question must be asked, and by people with audit authority: what did the agent know when it bought, and can we prove it?

Stay with the corporate card metaphor, because it is a good one, and extend it one step. A corporate card with rules attached still comes with a monthly statement. The statement is not a courtesy. It’s the control mechanism. It’s how the CFO reconciles, how the auditor samples, how disputes get resolved, how fraud gets found. Nobody hands out cards without statements, no matter how good the rules are.

Now run that at AI speed. When agents transact thousands of times a day, the monthly statement becomes something else entirely: a continuous audit trail of every request, every decision, and the context behind each one. Which sources did the agent consult? Which policy did it apply? What did it know, and when? Whether the answer it acted on was fresh or stale, grounded or improvised? When two software programs disagree about a purchase, and they will, dispute resolution is a replay of what each side knew at the moment of the transaction. Whoever holds that record holds the leverage.

The quiet race

Payments and fulfillment are the visible races because money and logistics always are. The quiet race is who holds the memory and record of all that agent-to-agent traffic.

There are three candidate answers. The payment rails would love to hold it; transaction data has always been their second business. The platforms and model providers would love to hold it; context is what makes their agents smarter. Or the enterprise holds it, inside its own perimeter, as infrastructure it owns.

My bet is on the third, and it’s not because I’m sentimental. Your agents’ purchase history is your demand curve. Their search history is your strategy. The context they carried into each negotiation is your cost structure and your risk appetite, logged. An enterprise that lets that exhaust accumulate on someone else’s rails is publishing its playbook one transaction at a time. It’s likely training a counterparty’s model on it. I would not want anyone else training on my customer data, my purchase data, or my search data. Neither will your CFO, your CISO, or your regulator.

Regulated industries will get there first, because they already live this way. Banks run on the discipline that any model touching money must be inventoried, validated, and explainable to an examiner. Health systems run on the discipline that any system touching patient data must be logged and attestable. Those institutions will not accept “the agent decided” as an answer to an examiner’s question, which means the memory layer is not optional for them. It is the precondition for participating in agentic commerce at all.

Know your traffic across AI Surfaces

Here is the uncomfortable baseline: only 18 percent of enterprises can name every AI surface operating in their environment today… before agentic commerce multiplies the surface count. The estate is already a sprawl of apps, agents, tools, and MCP servers, each making calls, each carrying context, almost none of it recorded anywhere the enterprise controls.

This is the layer we build at Excipio: a private memory layer that audits and controls the traffic between AI surfaces, inside the enterprise perimeter, on the enterprise’s infrastructure. Not a payment rail, not an exchange. The statement that comes with the card.

The four races will produce their winners, and there will be more than one. The fifth layer is different. It should not have an external winner at all, because the record of what your agents knew, asked, and decided belongs to exactly one party.

If you are building in AI, you should be able to audit and control the traffic between your surfaces. When 90 percent of B2B buying runs machine to machine, that stops being an architecture preference. It becomes the price of admission.

Know your traffic.

--

-

References

Gartner, “Top Strategic Predictions for 2026 and Beyond,” Gartner IT Symposium/Xpo, October 2025: https://www.gartner.com/en/newsroom/press-releases/2025-10-21-gartner-unveils-top-predictions-for-it-organizations-and-users-in-2026-and-beyond

Sandy Carter, LinkedIn, September 2026, on her conversation with David Minarsch (Olas), Nitya Subramanian (Para), and Will Papper (Cloudflare): [PASTE POST URL]

Sandy Carter’s companion Forbes article, linked in the first comment of her post: [PASTE FORBES URL]

Suggested Substack tags (tag field, not body): agentic commerce, AI governance, enterprise AI, token economy, audit

Brett Queener published a piece this week called The Harness, the Horse, or the Hay. It is a thoughtful look at the AI software cycle and an essential framework for making sense of where value settles. If you build, buy, or fund enterprise software, read it before you read this.

I won't summarize Brett's piece. Rather, I want to consider his ideas from the runtime side of the ledger… down in the inference traffic where memory and context actually live.

Brett's thesis in brief: because each worker will eventually collapse their workflow into a single interface, most legacy applications will disappear. What survives is the horse (the foundational model), the harness (the single application fitted to a rider and the complete job), and the hay (the operational infrastructure keeping horse and harness running at scale).

I mostly agree. But there is a crucial dynamic unfolding underneath his taxonomy:

The defining question of this cycle is not which category you belong to. It is who holds the loop.

The Claudeforce Problem

Brett defines the harness by four properties: it carries the ontology, it owns the interaction model, it owns the eval and learning loop, and it is singular.

Then, in his analysis of "Claudeforce," he does something far more interesting than categorize. He runs Salesforce against those four criteria for a sales rep and finds that it fails three of them. Salesforce kept the static records of system state. The corrections, the nuance, and the operational memory of how that seller actually works accumulated inside Claude.

His takeaway: the layer to watch is whoever ends up holding the loop.

That is the entire AI cycle in one sentence. Every enterprise AI deployment is answering a silent question: where does the accumulated judgment about how this company works actually live? Right now, by default, it is accumulating in whichever surface the employee used last. That is not an architectural strategy; it is entropy with a login.

Brett notes that no serious organization will surrender its embedded intelligence back to the frontier model providers, because a platform that serves your direct competitors cannot be the custodian of your DNA.

I would extend that rule one step further: no serious organization should hand that intelligence to a third-party harness either.

The harness vendor will argue the ontology belongs to them. For vertical micro-monopolies, that is true. But for the broader enterprise, the ontology is the company. Renting it back at renewal time is the SaaS trap rebuilt one layer higher.

The own-versus-rent decision is no longer about seats or licenses. It is about memory and context. If you rent the loop, you are a tenant in your own judgment.

Compounding Requires Singularity

The most compelling part of Brett's harness thesis is compounding: solve a job so thoroughly that the rider hands you everything, and within 60 days they ask you to run the adjacent workflow.

But compounding carries a precondition: corrections must land in a consistent place.

In reality, enterprise corrections land in fragmented silos. An account executive corrects a client fact inside a conversational assistant. A paralegal corrects contract logic inside a vertical workflow tool. A financial analyst catches a discrepancy in a sheet the harness never sees.

Each surface learns a fraction of the business, and none of them share the lesson. The loop is not closed; it is scattered. And a scattered loop does not compound… it leaks.

This makes the most critical word in Brett's thesis not harness, but singular. Singularity is what allows a feedback loop to close. If an employee operates out of a single surface, context compounds. Remove that singularity, and compounding halts regardless of ontology quality.

For the broad swath of the enterprise that will never find a single off-the-shelf vertical harness, that singularity cannot live at the application layer. It must come from the runtime layer shared across every surface.

Roadside Traces vs. Inline Control

In his evaluation of observability and evals, Brett drops a two-word aside: hold that thought. He later clarifies his rule: sell the instrument that produces judgment, never the judgment itself. Langfuse can show an engineering team where an agent pipeline stalled; it cannot tell them what institutional "good" looks like.

There is a technical distinction inside that layer that directly impacts value creation: observing a call and controlling a call are entirely different primitives.

A pure observability platform watches traffic after the fact and serves an execution trace. That is useful telemetry, but it is not a closed loop: a human reads a dashboard, files a ticket, and an engineer updates a prompt or code. Brett's own litmus test for a loop is whether a graded outcome alters future behavior without human intervention.

You cannot pass that test from the roadside. You can only pass it from inside the traffic.

If the layer evaluating the call also acts as the inline proxy routing it, the grade and the behavioral adaptation become the same runtime event. That is the dividing line between an instrument that merely records judgment and an instrument that executes it. Both belong in the hay category, but only one closes the loop.

What Hay Actually Pools

Brett applies a rigorous network-effect test to hay companies: serving 400 customers must make you structurally better than serving four, or you will be commoditized into a native feature. His examples include cross-model pricing, latency curves, failure signatures, and security heuristics.

Let's be explicit about what this layer should and should not pool:

What gets pooled: The physics of the traffic. Which models handle specific query shapes best, at what latency and cost. Where failure rates spike. Which routing strategies preserve uptime. No single customer can synthesize that alone, and frontier labs have no incentive to expose it because runtime transparency makes the customer portable.

What never gets pooled: The content. The semantic ontology. The enterprise's private context.

That data must remain strictly inside the customer's perimeter. Pooling proprietary content across tenants is the exact corporate self-harm Brett warns against.

Pool the physics of the traffic; never pool the meaning.

The Permanent Buyer

Brett frames "harness parts" as a transitional trap with two exits: step down into hay, or scale up into a harness.

The exit into hay is wider and more permanent than it looks. The self-assembling enterprise is not a transitional buyer waiting for a vendor to arrive. Regulated institutions will assemble their own stacks indefinitely, not because vertical SaaS failed them, but because governance, auditability, and legal liability mandate that they retain exclusive custody of their loop.

This is a durable market. These buyers do not buy proprietary harnesses; they buy primitives that integrate cleanly with their security posture.

The strategic question this leaves on the table is the one every CIO and technology leader should be asking:

Where does our loop live today, and who holds it?

If the answer is a sprawling list of disparate interfaces, you do not own it yet. If the answer is a single third-party application, you are renting it.

Horses will get faster, and harnesses will get bought. Through it all, the enterprise that retains custody of its own loop is the only party in the barn whose position compounds every year.

Stripe acquired OpenRouter this week for a reported $8 billion. PitchBook broke the analysis on August 19, and the framing from investors was unusually candid. Jeremy Jonker of Infinity Ventures described the acquisition as buying position rather than product, with the next competitive battleground “sitting at the choke point between AI consumption and the invoice.”

The more interesting artifact is Stripe’s letter to investors, obtained by Axios. In it, Stripe argues that optimizing for developers and optimizing for coding agents are largely the same discipline, and that building economic infrastructure for the internet and building economic infrastructure for AI are mostly the same job.

That claim deserves interrogation, because a lot of enterprise AI strategy is about to be built on top of it. It is half right. The half that is wrong is the half that will cost you.

Where Stripe is right: the middle is the business

Stripe never issued the cards or held the deposits. It sat between businesses and the banks that did, taking a small percentage of every transaction that passed through. OpenRouter runs the identical trade on inference: it sits between developers and model providers, connects the two on price, speed, and availability, and takes a fraction of the spend it facilitates.

The deal prices a position, and the position is the middle. Not the models. Not the applications. The thin layer that every request passes through and where every dollar gets metered. Ramp launching its own model router in the same news cycle confirms the pattern: fintechs have concluded that the layer between AI consumption and payment is where the next decade of margin lives.

On this point, the letter is correct, and the enterprise implication is direct. The layer between every AI surface, apps, agents, tools, MCP servers, and the models they call is where cost, control, and accountability concentrate. An $8 billion price tag on a two-year-old company is the market agreeing loudly.

Where the analogy breaks: payments forget by design

Here is what the letter skips. Payments infrastructure moves money, and money is fungible and stateless on purpose. A dollar does not change when it moves. The network is not supposed to remember your dollar, learn from your dollar, or serve your dollar back to you later. Settlement is designed to complete and clear. Forgetting is a feature.

AI infrastructure moves something categorically different: context and answers. That cargo is non-fungible, it compounds in value when retained, and the defining defect of today’s stack is that it forgets all of it. A transformer keeps no memory between sessions. Every agent session starts from zero and re-derives what the organization already worked out. The bill arrives again anyway. In this newsletter’s vocabulary, that is the Rediscovery Tax: the cost an organization pays every time an AI system re-derives an answer it already has.

So the analogy inverts at the exact point where it matters:

• Payments infrastructure succeeds by forgetting. Statelessness is what makes settlement clean.

• AI infrastructure fails by forgetting. Statelessness is what generates the repeat spend the meter is billing you for.

Building economic infrastructure for AI is not mostly the same job as building it for the internet. The internet’s economic layer had to move value without holding it. AI’s economic layer has to decide what is worth holding, because retained knowledge is the only thing that bends the cost curve.

A meter has no incentive to shrink what it meters

Follow the business model. A router in the middle earns a fraction of the inference spend it facilitates. Its revenue grows with token volume, and token volume includes waste. Stripe’s take rate on payments was aligned with its customers, because merchants want more transactions. A take rate on inference is aligned with consumption itself, and consumption is exactly the number an enterprise should be interrogating.

Token Yield is the metric that exposes the gap: the ratio of necessary spend to total spend. Every AI bill divides into unavoidable spend on genuinely novel work and recoverable waste on things the organization already knows. Routing operates entirely inside the second category without touching it. It finds you a cheaper price for re-deriving an answer you already own.

The cheapest model for a known answer is no model. Routing optimizes the price of rediscovery; memory eliminates it.

The market data says the recoverable half is not a rounding error: 69% of input tokens are repeated context, yet only 28% of calls use any caching (Datadog State of AI Engineering 2026). That is a market prior, not a product claim, and it describes the traffic a metering layer happily bills at full freight.

Three questions to ask of any middle layer

If the middle of the AI stack is now an $8 billion position, enterprises should be underwriting that layer the way they underwrite any critical infrastructure. Three questions do most of the work:

1. What does it remember, and who owns the record? If validated answers, corrections, and context accumulate in a vendor’s infrastructure, you are building institutional memory inside someone else’s walls. If they accumulate inside your own perimeter and survive a model switch, you own an appreciating asset. Rent buys the answer once. Ownership means never buying it twice.

2. Does its revenue rise or fall with your waste? A layer paid on volume monetizes your Rediscovery Tax. A layer that resolves known answers locally, in milliseconds instead of a round trip measured in seconds, is structurally on the other side of that trade.

3. What can it prove? The middle sees every request from every identity in the request path. That vantage point is either an audit and governance asset with lineage you control, or it is telemetry accruing to someone else. There is no neutral option.

Where the layer goes next

Stripe’s acquisition settles the question of where value sits in the AI stack. It does not settle what the layer should do. Metering consumption is the first, most obvious business to build there, which is why a payments company got there first.

The harder questions arrive with the invoice. What did all of those calls actually need to happen? Which answers did the organization already own? Who can reconstruct why an agent decided what it decided, and from which source? Those are questions of memory, governance, audit, and control, and they are answered by architecture, not by contract.

The middle layer of AI is going to be one of the defining infrastructure positions of this decade. Stripe just paid $8 billion to hold the version of it that meters the spend. The version worth owning is the one that remembers why the spend happened, proves what it produced, and quietly makes the meter run slower.

The way out is not fewer tokens. It is fewer wasted ones.

None of the diagrams show the part that lands on your invoice. Every arrow has a price tag.

The chat version of “should I build this startup” is one model call. The graph version of the same question is a planner call, five researcher calls, a skeptic call, a merger call, and a checker call. That is nine calls before anything loops. Add one revision cycle, which every real workflow has, and you are at twelve to fifteen. The diagram that went viral because it produces better answers is also a diagram of your token bill multiplying by an order of magnitude.

Graphs are worth it. I would build them anyway, and I tell design partners the same. What bothers me is that the industry is teaching everyone the workflow pattern and nobody the unit economics.

The redundancy hiding inside the diamond

Look closely at what those nine calls actually contain. The planner reads the company context to decompose the question. Each of the five researchers reads overlapping slices of the same context to do their work. The skeptic re-reads what the researchers produced plus the context needed to attack it. The merger re-reads everything. The checker re-reads the merge.

The same enterprise knowledge, retrieved and paid for five, six, seven times inside a single run. Now multiply by the runs. A support triage graph does not run once. It runs on every ticket. A content graph runs on every piece. A code review graph runs on every pull request. Bounded, high repetition workloads are exactly where graphs get deployed first, because that is where the quality gain justifies the build.

Which means the pattern the market is adopting fastest is the pattern that inflates the rediscovery tax fastest. Your agents keep re-deriving what your organization already knows, and in a graph, they re-derive it at every node.

Two graphs, and only one of them is trending

The video essays make a distinction worth keeping. There are agent graphs, which govern how work moves: the boxes and arrows, the planners and checkers. And there are knowledge graphs, which govern what the work knows: the relationships in your data that reasoning runs across.

The content wave is almost entirely about agent graphs. That is understandable. Agent graphs are visible, drawable, and you can build one this afternoon in LangGraph or n8n. The knowledge layer underneath is invisible in the diagram, so it is invisible in the discourse.

But follow the arrows. Every node in an agent graph resolves its knowledge from somewhere. Today, for most teams, that somewhere is a frontier model API, at full price, at roughly 2,500 milliseconds per live call, with your context leaving the building every time. You are renting your own institutional knowledge back from a model provider, once per node, per run, forever.

That is the rent position. The own position looks different: repeated semantic queries resolve from a customer owned, compounding knowledge graph inside your perimeter, at sub-10ms on a hit, with zero bytes leaving the perimeter on a cache hit. The agent graph stays exactly as designed. The substrate underneath it changes, and the modeled result is roughly a 42% blended token cost reduction across the workload.

The agent graph decides how work moves. The knowledge graph decides what the work knows, and whether you rent it or own it.

The question nobody has measured

If you have agent graphs in production, or on the roadmap, there is one number worth knowing before the CFO asks for it: across the nodes in your graph, what percentage of retrieved context is the same enterprise knowledge, retrieved repeatedly?

Almost nobody measures this, because the diagrams do not have a column for it. But the arithmetic is not subtle. Parallel decomposition splits one retrieval into five overlapping ones.

The overlap is the tax.

The advice circulating in the graph engineering wave is correct as far as it goes: build the smallest graph that raises quality, and put the human gate where mistakes get expensive. I would add one line to it. Put the memory layer where the retrievals repeat, because that is where the money leaks.

The diagrams price nothing. Your invoice prices everything. Close that gap while it is still cheap to close.

The Enterprise Token Economy tracks the unit economics of enterprise AI. If your agent workloads are repetitive and your token bill is not shrinking, that gap is the subject of this newsletter.

Sandy Carter read the full report so the rest of us didn't have to, and her Forbes breakdown is the one to read. Her line is the correct frame: "That is not a bubble bursting. That is a bill arriving."

She is right. Look at what else sits in the same dataset. AI is a top investment priority for 79 percent of leaders, up from 74 percent the quarter before. Average AI budgets are holding at $188 million. The share of organizations calling AI part of everyday work jumped from 13 percent to 22 percent in a single quarter, the biggest move KPMG has ever measured at any point on its maturity curve. Nobody is leaving. They are rephasing.

We have seen this movie. A decade ago, cloud invoices arrived that nobody could explain, and the industry answered with FinOps. Owners, forecasts, unit costs, a discipline. The token era is getting its own version, and KPMG's data shows it forming in real time. 53 percent of organizations report AI cost dashboards. 54 percent have embedded cost review in their AI approval loops. The companies with dashboards are roughly five times more likely to report real ROI.

Here is where I part ways with the standard prescription.

Phase one and phase two

Cloud FinOps matured in two distinct phases. Phase one was visibility. See the spend, tag the resources, show back the costs. Phase two was where the money actually got saved: rightsizing, reserved instances, deleting the zombie infrastructure that phase one exposed. Visibility never saved a dollar by itself. It told you where the dollars were dying.

Every recommendation now circulating for AI cost, including the four in the KPMG coverage, is a phase one move. Install a meter before you scale. Make token economics a leadership literacy. Put cost review inside the approval loop. Rephase rather than retreat. All correct. All observability.

Nobody is talking about phase two, because phase two requires knowing what the meter will reveal once you can finally read it. And what it reveals is uncomfortable.

What the meter shows

Agents are priced like electricity but they do not behave like appliances. They run long tasks, call other tools, and check their own work, and every step is on the meter. When GitHub Copilot moved to usage-based billing on June 1, a Visual Studio Magazine writer tracked his first day and projected a $180 monthly bill on a plan that had been flat $10. One long, tool-heavy session. Eighteen times the cost.

Now ask what those metered steps actually were. Some fraction was genuinely new work, novel reasoning on a novel problem. Look inside any agent deployment, though, and a large share is repeat purchases. The agent re-derives a policy it derived yesterday. It re-verifies a fact the organization verified a thousand times. It re-retrieves and re-summarizes the same document for the fortieth user this month. Each of those steps bills full freight and produces zero new value.

This is the Rediscovery Tax, and it is invisible on a cost dashboard. The dashboard tells you the bill is high. It does not tell you that you bought the same answer 400 times.

That is why only 26 percent of billion-dollar companies reporting full real-time cost visibility is not even the scary number. The scary number is how few of the 26 percent can decompose their spend into first purchases versus repeat purchases. Token Yield, the ratio of necessary spend to total spend, is the metric phase two runs on. Almost nobody can compute it yet.

What phase two looks like

Phase two of cloud FinOps was rightsizing and reservation. Stop paying on-demand prices for predictable workloads. Phase two of token FinOps is interception. Stop paying inference prices for answers you already own.

The mechanics differ from cloud because the waste differs. Cloud waste was idle capacity, machines running with nobody using them. Token waste is rediscovery, intelligence re-manufacturing its own prior output. You fix idle capacity by turning things off. You fix rediscovery by remembering, which means a memory layer that sits in front of the model, recognizes when a question has already been answered, and resolves it from knowledge the enterprise owns instead of renting the answer again.

This is also where cost discipline and governance stop being separate conversations. An answer resolved from your own knowledge graph never left your perimeter, never touched a vendor's meter, and never depended on a model's mood that day. Rent the commodity. Own the differentiation.

The bill is the beginning

KPMG's data does not describe a retreat. It describes a market that just learned to read its first invoice, and cloud already taught us the discipline takes two phases to complete.

The 49 percent who pulled back agents are the realists in this dataset, clearing room to scale what pencils out. When they come back, and the 79 percent priority number says they will, they will arrive with a phase two question. Not "what did the agents cost," but "how much of that did we need to spend at all."

That question has an answer, and it is a lot smaller than the current bill.

The 49/79/26 figures are from KPMG's Global AI Pulse Q2 2026, surfaced in Sandy Carter's Forbes analysis, which includes a plain-English token pricing explainer your CFO will thank you for.

What’s interesting is, that of all the great libraries of the classical world, this is the only one that survived as physical objects. Alexandria, the legendary central knowledge infrastructure of antiquity, disintegrated and dispersed across centuries. Not one scroll from the library of Alexandria survives. Pergamon, gone. The public libraries of Rome, gone. By a quirk of fate, one library we can still hold in our hands is the private one. It’s archive born of single household, sealed by catastrophe.

In April 2024, researchers from the University of Pisa and Italy's National Research Council announced that modern imaging technology and AI had recovered readable text from one of the carbonized scrolls from Herculenium: new sections of the History of the Academy by Philodemus, including an account of Plato's final hours and a revised date for his enslavement.

Like magic, the retrieval worked. It only took 1,945 years.

The enterprise alegory of this story is operating on a compressed timeline, inside your own systems, right now.

Retention is not memory

The villa held the goods, but nothing could be accessed. Every answer its library held was preserved perfectly, yet unavailable completely. For nineteen centuries the value of the archive was zero. It was not because the knowledge was lost but rather because the retrieval layer did’t yet exist.

Most enterprises are running a similar architecture. The work gets done. The answers get validated. You see glimpses of it in a closed ticket, a buried thread, or a slide from a project whose owner left in 2023. Then it becomes Groundhog Day on a loop. An AI agent gets asked a question it answered a few minutes ago. But nothing an agent concludes persists anywhere. So the the next agent has to ask the question again and the organization has to pay a frontier model to derive it again. No memory. No synergy.

We call it Rediscovery Tax: the cost an organization pays every time an AI system re-derives an answer the organization already has. The work’s been done. The answer been validated. Unfortunately, the bill arrives again anyway.

It sounds trite to say it, but Herculaneum is the Rediscovery Tax at geological scale. The answers were there the whole time. Yet, billing cycle for not being able to reach them ran for nineteen centuries.

The sovereignty lesson is sharper

Alexandria was the cloud repo of the ancient world: centralized, shared, magnificent, and owned by whoever held the city. When Alexandria fell, everyone's knowledge fell with it. The villa was a sigle perimeter. One owner, one roof, one collection that never left the premises. When catastrophe destroyed the building, it could no longer disperse the asset.

The sovereignty question is not a matter of where your data lives. It is really a matter of where your intelligence compounds. Satya Nadella put it plainly at Davos in January 2026: "If you are not able to embed the passive knowledge of a firm in a set of weights in a model that you control, by definition you have no sovereignty." An enterprise that streams its validated answers out to rented intelligence is building Alexandria. It’s impressive,and communal but structurally incapable of surviving as an owned asset. Firms that hold their institutional intelligence a decade from now are building the villa: a customer-owned, compounding knowledge graph inside their own perimeter. They keep intelligence inside. It compounds permanently.

The punchline in the ash

In a metacognative irony of Hitchiker’s Guide proportion, the scroll the researchers recovered wasn’t a treatise on metaphysics. It was the History of the Academy: the institutional record of the West's first knowledge organization. It was an archive about how an institution created, validated, and transmitted knowledge, preserved by the one library architecture that kept its assets inside its own walls.

The Academy understood the knowledge problem. Plato built an institution precisely so that validated knowledge would outlive the people who validated it. It’s form changed, but it lasted nearly nine centuries, longer than any company on earth has existed.

What to do with this

Don’t wait for the imaging team. The lesson of Herculaneum isn’t that a sufficiently advanced AI will eventually excavate your SharePoint. Though it’s cool to think about that. What matters is that retention without a retrieval layer is indistinguishable from complete loss for as long as the gap lasts, and the gap can last longer than the institution.

Three questions for your own villa:

1. When an agent answers a question your firm has already answered, does anything capture that answer so the next agent can reach it, or does the billing repeat?

2. If your model provider relationship ended tomorrow, what validated intelligence would you still hold, in an asset you own, inside your perimeter?

3. Is your knowledge compounding where it matters to you, or where your API traffic goes?

The cheapest model for a known answer is no model at all. Transformer models were inconceivable in Herculenium. But this little private library teaches the whole course like a fable: what you own survives, what you can retrieve compounds, and the only library that lasted was the one that never let its scrolls leave the building.

Most of the commentary treats this as a pricing story. It is not. It is the first margin call on the intangible economy, and the collateral being marked down is every business model built on the assumption that intelligence would stay scarce.

What happened, minus the drama

A price cut this fast, this deep, on a model this new is not generosity. It is what pricing power looks like when it evaporates.

The pressure is documented. CNBC reported in July that Chinese models had captured 46 percent of US enterprise token usage on OpenRouter. DeepSeek V4 Pro was serving tokens at a fraction of Luna’s old price. Open weights had become a credible substitute, and once a credible substitute exists, the rent collapses.

That word, rent, is doing precise work. Understanding why requires one distinction that most of the coverage missed.

Weights are non-rival. Serving is rival.

Intelligence, once trained into a model, is a non-rival good. Copying the weights costs nothing. My use of them does not diminish yours. This is the same property that economics textbooks assign to lighthouse beams and national defense, and it has a known consequence: non-rival goods cannot sustain a price above the cost of delivering them once a substitute exists.

Serving is different. Running a model consumes GPU seconds, power, and memory bandwidth, all of which are consumed exclusively. Serving is rival, and it has a real cost floor.

So what deflated on July 30 was not the cost of intelligence. It was the rent being charged on top of a non-rival good. The 80 percent cut is not a strategy. It is arithmetic catching up with structure. You cannot hold a rent on something anyone can copy once someone with a cluster decides to serve the copy at cost.

This makes the deflation predictable rather than shocking. Nobody needed to see the future. They needed to read the asset class.

The rhyme: dark fiber and free browsers

We have run this experiment before.

In the late 1990s, telecom carriers overbuilt fiber on the assumption that bandwidth scarcity would persist. It did not. Global Crossing and WorldCom collapsed. The fiber went dark for a decade. And the companies that won the internet were the ones that designed as if bandwidth were free before it was. Streaming video looked insane in 2002 and inevitable in 2012. The only thing that changed in between was who ate the deflation.

The modern dark fiber is depreciated accelerators. As frontier training moves to next-generation silicon, the prior generation does not disappear. It becomes the commodity inference substrate, serving open weights at something close to cost. That glut is already forming, and the OpenRouter numbers are its first visible symptom.

The browser tells the second half of the story. Netscape tried to monetize the artifact. Microsoft gave it away. The browser’s value did not evaporate. It relocated, from the thing itself to the position it occupied. Value moved to what ran inside the browser and to whoever controlled the default.

Transport commoditized. The layers above it captured the value. That is the rhyme.

Where the rhyme breaks

Analogies earn trust by admitting their limits. This one has two.

First, bandwidth had no permanent frontier tier. A gigabit in 2010 was a gigabit. Model capability keeps moving, so there is always an expensive tier that has not commoditized yet. Sol held its price while Luna fell 80 percent, and that split may be structural rather than transitional. The frontier stays priced. Everything a year behind it deflates to the marginal cost of serving.

Second, the telcos did not own the layer above them. Global Crossing had no cloud business. The AI labs and hyperscalers are vertically integrated across compute, weights, and application. Value migrating up the stack does not automatically mean value migrating away from incumbents this time. They are waiting at the top of the stack too.

Both caveats sharpen the question rather than dulling it. If the commodity layer deflates and the incumbents contest the layers above, the only durable position is one they cannot copy or subpoena. Which brings us to the number that reframes the whole event.

The 92 percent problem

Ocean Tomo’s 2025 Intangible Asset Market Value Study, released in February 2026, puts intangible assets at roughly 92 percent of S&P 500 market capitalization, up from 17 percent in 1975. Fifty years of American enterprise migrating its value out of things you can touch and into things you can think.

Then along comes a technology whose entire function is to copy, compress, and regenerate thought at near zero marginal cost.

That is why July 30 matters beyond model pricing. It is a preview of what happens to any intangible asset that turns out to be non-rival and non-excludable. Ninety-two cents of every S&P 500 dollar is now exposed to a sorting question, and the sorting runs on one axis: excludability. Sort the intangible dollar into three buckets.

1. Codified knowledge. Anything that can be written down: documentation, methodologies, playbooks, generic software patterns. Non-rival by nature and increasingly non-excludable in practice. This is the bucket the models ate first, and the Luna cut just repriced it toward zero.

2. Legally excludable IP. Patents, trademarks, copyrights, trade secrets. Here rivalry is manufactured by law. The asset holds value only as long as the legal regime holds.

3. Structurally excludable assets. Proprietary data, accumulated and validated context, distribution, regulatory position, switching costs. Excludable by architecture rather than statute. Nobody can copy their way into these, and nobody can litigate their way in either.

Bucket one just got marked to market. Bucket three is where value is fleeing. Bucket two is the interesting one, because its floor is about to be tested.

The other shoe: IP, know-how, and licensing

The legal regime that makes bucket two excludable was written for an economy where copying was hard and generation was human. Every pillar of it is under live stress at once.

Training inputs sit in unresolved copyright litigation, with fair use doctrine stretched over a use case it was never shaped for. Model outputs receive no copyright in most jurisdictions, which produces a perverse result worth sitting with: the more your product is model-generated, the thinner your own IP claim on it becomes. The data licensing market is being priced in real time, with publishers and platforms negotiating rents on assets whose enforceability the courts have not yet confirmed.

And then there is know-how. Trade secret protection depends on information deriving value from secrecy and receiving reasonable efforts to keep it secret. General counsels are beginning to ask an uncomfortable question: what happens to that claim when the substance of your know-how is transmitted to a third-party inference endpoint on every API call? I am not offering a legal conclusion. I am observing that the question is now on the table at every regulated enterprise, and that it is an architecture question wearing a legal costume.

The common thread: legal excludability is itself a kind of rent, and it can be repriced by a ruling as abruptly as Luna was repriced by a press release. Structural excludability cannot. Its defensibility never depended on a judge.

Where B2C and B2B actually split

The obvious prediction is that consumer AI goes cheap and DIY while enterprise stays frontier. The evidence runs the other way. The largest consumer deployments on earth run open weights, because billions of users against thin revenue per user cannot pay frontier rates. Meanwhile an enterprise vendor charging $500 per seat can burn a few dollars of tokens per seat and never notice.

So the split is not B2C versus B2B. Two different variables are doing the sorting.

Consumer sorts on unit economics: revenue per inference call against the cost of that call. The Luna cut resolves most of that question by making frontier access cheap enough that DIY loses its main argument at consumer scale.

Enterprise sorts on sovereignty. Regulated buyers carry contractual, statutory, and privilege-based constraints on where their information may travel, and those constraints do not read pricing tables. Satya Nadella named this at Davos in January 2026: a firm that cannot embed its knowledge in an asset it controls has no sovereignty and is leaking enterprise value to a model company on every query. An 80 percent price cut changes the size of the leak’s invoice. It does not close the leak.

There is a second reason the cut will not shrink enterprise AI budgets: volume. Datadog’s 2026 State of AI Engineering report, drawn from thousands of organizations, found that 69 percent of enterprise LLM input tokens are system prompts and repeated context. Agentic workloads multiply calls faster than prices fall, and the repeated context rides along on every one of them. Cheaper tokens do not reduce the habit of re-buying answers you already own. They subsidize it. Jevons had this figured out in 1865 with coal.

How to sort your own intangibles

If you run a SaaS company, an AI product, or a P&L that depends on either, the exercise is uncomfortable but short. Take your differentiation claims and ask three questions of each.

First, can it be copied? If a competitor with API access and a quarter can replicate it, it is bucket one. Stop calling it a moat in board meetings before someone does it for you.

Second, does its defensibility depend on a legal outcome you do not control? Then it is bucket two, and it deserves a discount rate that reflects doctrinal uncertainty, not the discount rate you were using in 2023.

Third, does it compound in an asset you own? Validated answers, corrected outputs, accumulated context, customer-specific knowledge that gets richer with use. That is bucket three. It is the only bucket where AI spend builds equity instead of paying rent, and it is the only story worth telling an investor in 2026.

I spent part of my career pricing intangible value in public markets, running a fund that traded US large-cap equities on proprietary brand signals. The lesson from that work holds here. The market has never doubted that intangibles carry the value. The question, every time, is which intangibles stay defensible when the copying gets easier. On July 30, the copying got 80 percent cheaper.

Rent the commodity. Own the differentiation. The price of the commodity just told you which is which

.

Ken Huang published an essay this morning that deserves a wide read. Writing in his Agentic AI newsletter, he argues that the binding constraint on AI adoption has shifted. Model labor is getting cheaper faster than organizational coordination is getting easier. Once agents run for hours, split work across parallel branches, and touch real workflows, the expensive part is no longer producing tokens. Rather, it is deciding who can act, what gets handed off, which artifacts matter, and when a human steps in. He calls this the coordination tax, and he is right that most teams are not measuring it.

Read his piece first. It stands on its own. What follows is an extension, because the coordination tax connects directly to the framework this newsletter has been building all year. Coordination is not a new tax. It is where the taxes we already track go to compound.

Fan-out multiplies redundant inference

Huang’s sharpest observation is that agent capacity now outruns human approval bandwidth. One operator can trigger ten parallel workstreams and generate more machine work in an afternoon than one person can casually supervise.

Here is what that fan-out does at the token layer. Parallel branches do not divide the work cleanly. They overlap. Each branch re-derives the same context, re-asks questions a sibling branch answered minutes ago, and re-buys conclusions the organization validated last week. The evidence for how much overlap already exists is stark:

• Datadog’s State of AI Engineering research found 69 percent of enterprise LLM input tokens are system prompts: instructions, policies, and tool guidance repeated verbatim across every call.

• Only 28 percent of caching-capable calls in that research showed any cached reads. Most workloads pay full frontier pricing to re-process identical context.

• Gartner estimates agentic AI consumes 5 to 30 times more tokens per task than chatbot workloads.

Stack those three findings and the conclusion is uncomfortable. The more agentic a workload becomes, the more of its spend is re-purchase rather than purchase. This newsletter calls that the Rediscovery Tax: the cost of re-processing answers the organization already owns. Fan-out does not just create Huang’s approval queue. It multiplies the Rediscovery Tax by the branch count.

Every handoff is a memory event

Huang argues the design unit of agentic systems is no longer the prompt. It is the handoff: what job is delegated, what authority transfers, what evidence must survive the transition.

Restate that as an infrastructure question and it answers itself. Evidence survives a transition only if it has somewhere durable to live. In most agent stacks today it does not. A transformer holds no memory between sessions and keeps no stored records. When a handoff drops context, that is not an etiquette failure between agents. It is the absence of a memory layer. The receiving agent reconstructs what the sending agent knew by re-deriving it from scratch, at frontier prices, with fresh opportunities for drift.

The artifact glut Huang describes has the same root. Drafts, traces, and half-finished outputs pile up because nothing in the system knows which answer is authoritative, where it came from, or whether it is still true. That is the Stale Answer Tax in operation: answers that were correct when generated persist after their underlying source has moved.

Review does not scale. Architecture does.

The instinctive fix is more governance: more review checkpoints, more approval gates, more humans reconstructing what happened. Huang’s own math shows why that fails. Approval bandwidth grows slowly and irregularly while agent capacity grows almost vertically. Governance that depends on a person reviewing outputs works exactly as well as that person, on the week they have time.

The durable fix is structural. Three properties, built into how AI knowledge gets stored:

• Lineage: every answer knows the source it came from.

• Invalidation: when that source changes, the answer expires automatically.

• Source precedence: a standing rule for which source wins when two disagree, set before the conflict happens, not during it.

This is governance by architecture, not by contract. It compresses coordination the way Huang says the winners will: shorter approval paths because authority is explicit, fewer retries because context survives handoffs, less rework because artifacts carry their own validity.

How to evaluate a coordination-compression layer

For teams acting on this in 2026, four questions separate real memory infrastructure from another dashboard:

1. Ownership. Does validated knowledge accumulate in an asset you control, or inside a vendor’s model? Satya Nadella put this on the record at Davos in January 2026: a firm that cannot embed its knowledge in an asset it controls has no sovereignty. The sovereignty question is not where your data lives. It is where your intelligence compounds.

2. Lineage and invalidation. Can any answer show its source, and does it expire when the source changes? If governance lives in a review meeting instead of the storage layer, it will not survive fan-out.

3. Perimeter. When a known answer is served, does the query leave your network at all? Zero external transmission on a resolved query is a security property no audit trail can match.

4. Deployment cost. A memory layer that requires rearchitecting the agent stack recreates the coordination tax it claims to remove. The bar is a drop-in proxy: one BASE_URL change, live in hours.

This is the problem Excipio was built for: a private memory layer and semantic proxy network that intercepts agent queries and resolves known answers from a customer-owned, compounding knowledge graph before they reach a frontier API. Modeled results show roughly a 42 percent blended reduction in LLM API spend on Day 1, with resolved queries returning in 8ms against roughly 2,500ms for a live frontier call. The cost reduction is the mechanism. The mission is the asset: validated institutional intelligence that stays inside the perimeter and compounds permanently, instead of leaking into someone else’s model on every repeated question.

Huang ends his essay with a dividing-line question: is the workflow getting smarter, or just generating more work for the people around it? A workflow gets smarter in exactly one way. It remembers. The coordination tax is real, it is growing with every parallel branch, and it is, at bottom, a memory problem.

Read Ken Huang’s original essay, The Hidden Tax on AI Is Coordination, at his Agentic AI newsletter on Substack. It is worth your subscription.

The AI bill is a lagging indicator. By the time spend renders on a dashboard, the tokens are already gone and the data has already left the building. Every cost function in the enterprise today is ex-post by design. It sorts, attributes, and forecasts money that has already moved. That work is real and it is done well. It is also, by definition, downstream of the only moment that decides the outcome. The moment is the call itself.

Cloud cost discipline was built for resources that are elastic, observable, and throttleable. Redundant token spend is none of those. You cannot rightsize a question that was asked twice and answered twice at full price, with the answer walking out the door each time. Rightsizing optimizes what flows through the pipe. It was never designed to stop what should never have flowed at all. A magnifying glass shows you the breach in perfect detail. It does not close it.

The cost lever and the sovereignty lever are the same lever. Both are pulled at the input layer, at the instant the query is formed, by whoever controls what leaves. Today no one owns that layer, so the bill defaults to the team equipped only to report it. That is a category error, not a failure of effort. The real owner is architecture and the AI platform, the part of the org that decides what happens before the call, not after.

Boards have already moved. They stopped asking for token charts and started asking for cost per outcome. That number cannot be reported into existence. It is built. You architect your way to it, at the input layer, before the spend and before the byte leaves, or you do not reach it. No dashboard, however granular, produces a number that lives one layer above it.

So the reframe is simple. This was filed as a reporting problem. It is an architecture and action problem. Measurement teams are doing measurement well, and measurement is the wrong instrument for a force that has to be met at the perimeter. Hand the input layer to architecture and platform. Hand the sovereignty win to security, where nothing leaves on a resolved query. Cost and control then resolve at the source, by architecture, not by contract. You do not repel an invasion with a microscope. You decide what gets through the gate

.

Nate published a dispatch rule this morning. Four things you can estimate about any task in about a minute: size, independence, separation, checkability. They resolve into one of four verdicts: a chat, one agent, a team, or don’t bother. Read it. It is the best budgeting frame I have seen for the question everyone with a freshly installed agent is quietly asking, which is “what do I even point this at?”

He opens with a number that should haunt every AI budget owner. More than 1.6 million agents signed up for an agents-only social network this year. Most were never asked to do a single thing. Not failed. Never dispatched. His diagnosis is right: nobody grew up with instincts for metered thinking. Thinking used to come attached to people. Now it is priced by the token and purchasable tonight.

So the dispatch question is a budgeting question. Agreed. But every budgeting rule has a price assumption buried inside it, and this one prices every token at retail.

The evidence that spend buys results

Two research results anchor Nate’s case, and both hold up at the source.

Stanford’s Scaling Intelligence Lab took DeepSeek-Coder-V2-Instruct, a model that solves 15.9 percent of SWE-bench Lite issues in one attempt, and let it try 250 times per problem. Solve rate: 56 percent. That beat the single-attempt state of the art from frontier models. The paper is called Large Language Monkeys, and its message is blunt. Coverage scales with samples across four orders of magnitude. Buying more attempts buys more answers.

Anthropic found the same thing from the other direction. In their analysis of their multi-agent research system, three factors explained 95 percent of performance variance on a hard browsing benchmark. Token usage alone explained 80 percent. Not prompt phrasing. Not orchestration cleverness. Tokens. Their multi-agent architecture beat a single agent by 90.2 percent on internal evals, and it did so by spending roughly 15 times the tokens of a chat interaction.

Both findings say the same thing: purchased thinking works. Spend more, get more. Which makes the dispatch decision exactly what Nate says it is, a question of whether the task justifies the spend.

Here is the assumption underneath: that every token in that spend was necessary.

The fifth estimate

Ask one more question about the task on your desk. Of the tokens this task will consume, how many purchase thinking your organization already owns?

Datadog measured what enterprise LLM traffic actually contains. 69 percent of input tokens are system prompts and repeated context, the same instructions and the same background re-transmitted call after call. Only 28 percent of caching-capable calls use caching at all. 72 percent of those workloads pay full frontier pricing to re-process identical context. And Gartner puts agentic AI at 5 to 30 times the tokens per task of a chatbot, which means every one of those redundancy ratios gets multiplied before it hits your invoice.

The architecture explains why. A transformer holds no memory between sessions and stores no records. When an agent seems to remember, the application is resending the entire transcript. Every new session gets a brilliant new consultant who has read everything and recalls nothing of the last meeting. So agents re-derive conclusions the organization validated last week, yesterday, or four seconds ago by the agent running next to them. I call this the Rediscovery Tax, and it is the single largest yield killer in agentic deployments.

Now look at Anthropic’s 15x multiplier again. Fifteen parallel context windows are fifteen consultants who cannot see each other’s notes. The very architecture that wins by spending tokens is the architecture where redundant spend compounds fastest. The 80 percent finding says token spend drives quality. It does not say wasted token spend drives quality. Those are different claims, and the gap between them is where your budget goes to die.

The metric is Token Yield: necessary spend divided by total spend. Every AI bill splits into unavoidable spend, the genuinely novel questions that legitimately require a frontier model, and recoverable waste, the tokens spent re-buying what you already know. No factory evaluates output per kilowatt. No logistics operator measures the fleet in gallons of diesel. Enterprise AI is the one budget line where we still confuse the meter with the metric.

Why this moves Nate’s verdicts

Run his four estimates on a task and suppose it lands on don’t bother. The economics fail: the task is agent-shaped, but the token bill exceeds the value of the output. That verdict was computed at retail, with every redundant re-derivation priced as if it were novel thinking.

Now compute it at yield. If a meaningful share of the task’s spend is recoverable waste, the effective cost of the necessary thinking is a fraction of the sticker price. Tasks migrate across the don’t-bother line. Not because the agents got smarter. Because you stopped paying full freight for thinking you already bought.

The same logic runs in reverse for the tasks you did dispatch. A team verdict at 15x tokens is only rational if those tokens are doing new work. If your agents spend most of their budget re-establishing context and re-validating each other’s conclusions, you did not buy a team. You bought one consultant fifteen times.

Nate’s rule tells you whether a task deserves purchased thinking. The fifth estimate tells you what that thinking should actually cost. Both questions take about a minute. Only one of them shows up on your invoice every month, forever, compounding with every agent you add.

The way out isn’t fewer tokens. It’s fewer wasted ones.

Sources: Nate’s dispatch guide, July 10, 2026. Brown et al., Large Language Monkeys: Scaling Inference Compute with Repeated Sampling, Stanford Scaling Intelligence Lab, arXiv 2407.21787. Anthropic, How we built our multi-agent research system, anthropic.com/engineering. Datadog State of LLM usage data and Gartner agentic consumption estimates as cited in The Enterprise Token Economy Issue 5.

The industry has seen this whiteboard before. It had "database" written at the top.

The decision every company already made

No enterprise writes its own database engine. Not because they lack the talent. Because the visible ten percent of the problem, store a record and get it back, hides the brutal ninety percent: correctness under concurrency, crash recovery, query planning, replication, governance, performance at scale. Companies that tried spent years discovering requirements one production incident at a time. The market studied that outcome and reached a verdict so complete that nobody argues it anymore. You license the engine. You own the data.

Then the market went further. Enterprises paid a premium for managed databases so they would not have to operate the engine either. Then they paid for serverless databases so they would not have to think about capacity at all. Thirty years of buying behavior points one direction: abstraction up, DIY down. Enterprises pay more, on purpose, to do less infrastructure work. That is not laziness. That is discipline about where differentiation lives.

A compliance platform's moat is compliance judgment. An underwriting platform's moat is underwriting. A legal AI platform's moat is legal reasoning. None of them ever won a customer because of a homegrown storage engine. The engine was undifferentiated heavy lifting, and the market priced it accordingly.

The same decision, arriving again

AI memory is the database decision replaying at higher speed. Every company running agents at scale is about to choose: build the memory layer or license it.

The build looks easy for the same reason the database looked easy. The demo works in a week. An exact-match cache, an embedding model, a similarity threshold. The bill drops in the first test. The whiteboard wins the meeting.

Then the hidden ninety percent arrives. Cache invalidation is one of the two famously hard problems in computer science, and in an enterprise memory layer it is not a punchline. It is a compliance surface. An answer that was correct when generated goes stale the moment its source changes. Serve it anyway and you have not saved money. You have shipped the Stale Answer Tax straight into production, where acting on expired knowledge carries operational and regulatory risk.

The durable fix is structural, three properties built into how AI knowledge gets stored. Lineage: every answer knows the source it came from. Invalidation: when that source changes, the answer expires automatically. Source precedence: a standing rule for which source wins when two disagree, set before the conflict happens, not during it. That triad is governance by architecture, not by contract. It is also months of engineering that nobody budgeted on the whiteboard, built by people whose actual job was the product.

Even a perfect build buys you one pillar

Here is the part the build-vs-license spreadsheet misses. Suppose the in-house team executes. Eighteen months, no incidents, the cache works. What did they get?

Some cost reduction. One pillar out of four.

A licensed memory layer ships the full set. Cost: roughly 42 percent off blended token spend on day one, not in eighteen months. Latency: cache hits in about 8 milliseconds against 2,500 from a frontier round trip, a 312x gap that is an engineering moat in its own right, not a side-project deliverable. Portability: model-agnostic by design, so the layer survives the next model generation, while an in-house build marries whichever API it was written against. And IP security: zero bytes leave the perimeter on a cache hit, with lineage and invalidation already in the architecture instead of on the roadmap.

The pillars are not a feature list to evaluate. They are the parts of the build the in-house team was never going to reach, because each one is a product in itself and their product is something else.

The one place the analogy breaks, in your favor

Databases came with a trade. Self-hosted meant sovereignty and operational burden. Managed and serverless meant abstraction and someone else's perimeter. You picked one.

The memory layer does not force that pick. Excipio deploys as a drop-in semantic proxy network inside the customer's own perimeter, live in hours, one endpoint change, zero rearchitecting. The operational abstraction of serverless. The sovereignty of self-hosted. And the part that compounds, the customer-owned, compounding knowledge graph of validated institutional intelligence, is the customer's asset from the first cached answer.

That distinction is the whole strategic point. Satya Nadella named it at Davos in January 2026: a firm that cannot embed its knowledge in an asset it controls has no sovereignty, and is leaking enterprise value to a model company on every query. The database era's system of record held your transactions. The intelligence era's system of record holds your validated answers. Nobody wrote their own system of record last time. The question is only who owns what accumulates inside it, and the answer has to be you.

The rule

License the engine. Own the asset. The engine is the vendor's job. The intelligence is yours. Confusing the two is how a company ends up building a database in 2026, except this time the failure mode is not a slow query. It is institutional knowledge compounding in someone else's model while six engineers rediscover why invalidation was famous.

The knowledge graph you establish in year one is the moat that compounds permanently. The one you build in year three starts three years behind. And the one you try to write yourself starts behind and stays there.

Subscribe now

## The chorus

Start with Ali Ghodsi. The Databricks CEO opened his Data + AI Summit keynote this June with a blunt diagnosis: “AI doesn’t have an intelligence problem. It has a context problem.” He had the numbers to back it. PwC found that 56% of CEOs report zero financial benefit from AI. The share of companies scrapping AI projects before production jumped from 17% to 42% in a single year. Over the same period, models got dramatically better and API costs collapsed. Intelligence improved. Results got worse. The missing variable is not in the model.

Satya Nadella said a version of the same thing from the Davos stage in January, and regular readers, if I have any,

know I have written about it before: a firm that cannot embed its own knowledge in an asset it controls has no sovereignty, and is leaking enterprise value to a model company on every call. He predicted it would become the most talked about topic in AI this year. Six months in, he is winning that bet.

Pat Grady opened Sequoia’s AI Ascent with a warning to every founder in the room: “The things that you build might be irrelevant tomorrow.” The models move faster than any product built on top of them. Amazon’s top AI executive, Peter DeSantis, put the economic version to The Wall Street Journal in four words: “AI has a cost problem.” And Prukalpa Sankar, co-CEO of Atlan, compressed the whole thesis into the sharpest line of the year: while intelligence converges, context compounds.

Different companies, different incentives, same conclusion. Intelligence is commoditizing. Context is not.

## The tell

Now listen to what the model providers themselves are saying, because this is where it gets interesting.

Sam Altman has spent 2026 telling anyone with a podcast that memory is OpenAI’s real moat. Not model capability. Memory. His stated ambition is an AI with what he calls infinite, perfect memory: every document, every email, every decision you have ever consulted it on. He describes personalization as “extremely addictive” and says users who invest their history into ChatGPT will find it very hard to leave. We are, in his words, in the GPT-2 era of memory.

Read that carefully. The CEO of the largest model company in the world is telling you, in public, that his moat is built from your context. Your questions, your documents, your decision history, accumulated on his infrastructure, creating switching costs that keep you paying him. He is not hiding it. It is the strategy.

For a consumer, that might be a fair trade. For an enterprise, it is the sovereignty problem stated as a product roadmap. Every query your agents send to a frontier model is a small deposit into someone else’s moat.

## Rented context, owned context

Here is the structural choice underneath all of this. Every time one of your AI agents fires a query at a frontier LLM, one of two things happens.

**Rented context.** The query goes out. The model answers from its general training. The exchange is discarded, or worse, it accumulates on the provider’s side of the ledger. Your agent got an answer. You paid for it. You own nothing from the transaction, and you will pay full price to ask a semantically identical question tomorrow.

**Owned context.** The query is intercepted before it leaves your perimeter. The validated answer is stored in a customer-owned, compounding knowledge graph, alongside the semantic fingerprint of the question. The exchange becomes part of a growing corpus of proprietary intelligence about how your specific domain works: your terminology, your edge cases, your approval patterns, your exceptions. The intelligence stays inside. It compounds permanently.

Most enterprises are operating entirely in the first mode. The data says so: roughly 95% of enterprise AI usage still runs on frontier models, per Glean’s CEO, and Datadog’s telemetry shows 69% of enterprise LLM input tokens are system prompts and repeated context. That is the Rediscovery Tax at industrial scale. Firms are renting their own institutional knowledge back from an external model, one API call at a time.

## Why this compounds

The strategic implication takes a moment to land. An enterprise operating in owned-context mode is accumulating something the rented-context enterprise never will. A knowledge graph that grows with production usage is an AI system that gets smarter, faster, and cheaper over time. Not because the underlying model improved. Because your proprietary layer did.

Domain questions start resolving locally in milliseconds instead of round-tripping to a frontier API. The share of agent traffic answered from owned intelligence climbs as the graph matures. Token spend drops compoundingly, because more of the work resolves against knowledge the firm already validated and already owns.

And here is the question a software executive asked me recently that I have been thinking about since: if the model providers cut prices again, does the owned-context advantage shrink? It does not. It grows. Cheaper frontier inference makes the genuinely novel queries more affordable, which enables more agent deployment, which generates more validated answers, which deepens the graph. The moat compounds regardless of what happens to frontier pricing. Lower model prices are a tailwind for the enterprises that own their context and a treadmill for the ones that rent it.

This is Context as the New Moat. It is the difference between an AI system that costs the same per query forever and an AI system that becomes a durable competitive asset. And it is the one moat the model providers cannot absorb, because replicating it would mean commoditizing their own inference revenue.

## Two questions for your vendors

If you are evaluating AI infrastructure right now, two questions cut through most of the noise.

First: is this a capability the model provider is likely to build natively? If yes, understand what you actually own when they do. Features get absorbed. Infrastructure between you and the provider does not.

Second: does my usage of this platform accumulate proprietary intelligence I could not recreate elsewhere? If you could swap the vendor tomorrow and lose nothing but integration work, you are renting context, not building a moat. And if the intelligence accumulates on the vendor’s side rather than yours, you are building someone else’s.

The CEOs have already told you where value accrues next. The only open question is whose balance sheet your context compounds on.

## One thing to read

Jaya Gupta’s “Context graphs: AI’s trillion-dollar opportunity” from Foundation Capital. The venture-side articulation of the same thesis: the next platforms will be built on persistent records of enterprise decisions, not on better models. Systems of record store what happened. Context graphs store why. Worth your time.

## About Excipio

Excipio is a private memory layer for enterprise AI, built in C++, sitting between your agents and the frontier models. We intercept every agent query, serve validated answers from your customer-owned, compounding knowledge graph in under 10ms, and route only genuinely novel questions to the cheapest capable model. Roughly 42% blended token cost reduction. Zero bytes leave the perimeter on a cache hit. Zero changes to your agent code.

If you are running AI agents at scale and want your context compounding on your balance sheet instead of someone else’s, I would like to talk.

**tony@excipio.ai** · **excipio.ai**

*The Enterprise Token Economy publishes on Substack. Forward to anyone building or deploying AI agents at scale.*