How the agentic web is forcing the data-first discipline the web has dodged for thirty years, and why the shelf is open for whoever inverts the build order first
The web’s original idea was to model meaning so machines could understand it. We turned that into a ranking trick and spent twenty years retrofitting structure onto pages that were never built to have any. Agents don’t read the page; they read the layer you skipped. Here is why building that layer is now the requirement rather than the nicety, and why the brands that build it first will own a shelf their competitors can’t see.
We build backwards, and everyone knows it
Most websites are built in the wrong order, and everyone in the business knows it, even if no one says it in the meeting.
The sequence is always the same. You design the experience that wins the pitch: the hero, the story, the journey, the comp that makes the client say yes. That artifact is built to be approved, not to be operated. Then the pitch is won, and a backend gets wired up underneath a design that was never modeled, because the design is what the client bought. The selling artifact becomes the product. The data structure is whatever can be conformed to the layout after the fact.
It gets worse one layer down. Anyone who has lived through a CMS build knows the prototype problem: the proof of concept, the fast scaffolded thing built to render for the demo, gets approved, reskinned in the brand palette, and shipped as the delivery layer. The throwaway becomes load-bearing. Nobody goes back and builds it properly because it works, and there is no budget line for replacing something that works. The most disposable version of the work quietly becomes the permanent one.
So we have spent two decades shipping the artifact that won approval as the system we are then stuck operating. The pitch comp becomes the site. The prototype becomes the platform. And because the data was never first-class in either case, an entire industry grew up to reconstruct the archaeological structure back out of the rendered page after the fact. That industry has a name you know: it is most of what “doing schema” means in practice today.
A fact with five homes
Here is the absurdity made concrete. Take a single fact: a price.
Where does that price live? On the page, hand-keyed into the layout. In the schema markup, reverse-engineered off the page to satisfy Google. In the product feed, maintained separately to keep the shopping channels accurate. And soon, if the agentic web plays out as it is plainly going to, in an llms.txt, in an EntityMap, in an ARD manifest. One number, five or six homes, each maintained by a different process, all assumed to agree.
They agree by luck and labor, not by architecture. The moment someone edits the page, they drift. You do not actually have a source of truth. You have a source-of-truth-shaped rendering, with copies smeared across every surface that needs the number, and a standing tax to keep them roughly in sync.
This was survivable for one reason only: the sole consumer was a human looking at the finished page. The inefficiency was hidden behind the pixels. Nobody saw the five copies; they saw one price, rendered nicely, and bought the thing. The mess was real, but it was invisible, and an invisible mess does not get fixed.
The agent removes the cover. It does not see your reskin, your journey, or your typography. It reads your data directly, and if your data only exists as a layout, the agent is reading a twenty-year-old prototype with your facts spread across the presentation tier. The technical debt that was hidden plumbing becomes the product that the machine judges you on. The audience changed into one that can only see the part you never built properly.
The fix starts with one block
The objection this argument always invites is that it sounds like a massive replatforming. It is not. It starts with one block on one page, and a real example shows why.
A website sells tickets and, like everyone, runs deals: weekend offers, holiday promotions, and special-occasion promotions. The deal’s name changes with the occasion, and so does the price. “Memorial Day Amazing Deal” is much longer than “July 4 Deal,” so to fit, the developer changes the font, text size, and the wrapper div. Nothing wrong with that; it is the job. But now consider the scraper that pulls the price into the schema markup. It finds the price by its position in the page, an XPath that means “the value in this div, in this place.” Change the layout to fit the longer name and the address moves. The fact did not change; its coordinates did. The XPath breaks, the automated system correctly flags a drift and refuses to auto-replace, because it is protecting against exactly the ambiguity the architecture guarantees. So every routine holiday offer becomes a manual review. The better engineered the scraper, the more often it stops and asks a human because it correctly refuses to trust a foundation it knows is unstable.
That same price is feeding a merchant feed maintained by a third party running its own crawler, and the site editor, and soon an llms.txt and an EntityMap. The offer was born as clean structured data, in the offers team’s system, at the moment of creation. It got de-structured into a styled webpage, and now three separate processes spend money trying to re-structure it back out. The offer is born as data and dies as a layout, and then three crawlers are paid to attend the resurrection.
This failure has a name in the enterprise schema world. Milestone’s Benu Aggarwal calls it schema drift: when human-visible content like price or hours changes but the machine-readable layer goes stale, AI systems catch the inconsistency, lower their confidence in you, and stop citing you. Her prescription points exactly where this essay is heading: governance that assigns clear entity ownership, wires the schema in at the template level so it updates automatically as content changes, and validates the data continuously. The deeper cure, though, is to remove the gap entirely, so there is nothing left to drift.
The fix is small and immediate: put the offer on the page as a structured block of named fields instead of styled prose. offer.name, offer.code, offer.sku, offer.price, offer.valid_from, offer.valid_to. The values change every holiday; the names never do. A simple assembler script renders the page from that block, and every consumer reads the price by name, not by position. “Memorial Day Amazing Deal” and “July 4 Deal” can be any length at all, because nobody is keying off the third div anymore; they are asking for offer.price. Identity replaced location. The XPath fragility, the drift flag, the manual review: gone, because there is nothing left to guess at.
Notice what just happened. That named block is the offer entity, arriving through the back door. You did not announce a grand data-modeling initiative; you shipped a structured block on one page and pointed the renderer and the feed at it. And it climbs a ladder where each rung pays for itself before you reach the next. First, the block lives on the page, and consumers read named fields instead of scraping layout: cheap, fast, and it kills the fragility today. Next, the block stops being authored on the page and starts being imported from the offers source, so the page becomes a reader of the truth rather than its home. Finally, that source is exposed as something others can call directly, so the crawlers can stop crawling and start requesting. You do not have to believe in the third rung to fund the first. Rung one’s business case is “we stop manually reviewing every holiday, and the feed stops breaking,” and it pays for itself the first long weekend.
The honest intermediate truth is that, early on, you cannot all call from the same feed. The block still lives on the page, and the page is still the integration point. But the third-party crawler is now reading a clean, stable, named block instead of guessing at styled prose, so the drift tax collapses even before the architecture is finished. You walk to the single source. You do not leap to it.
Search was the detour
To understand why this is fixable, and why now, it helps to see that the fix is not new. It is the web’s original idea, returning after a long detour.
Follow one career and the whole arc comes into focus. In the mid-1990s, R.V. Guha built the Meta Content Framework, an early attempt to give machines a model of what things are and how they relate. That work fed into RDF at the W3C, the rigorous, academic-grade version of the same idea. He had a hand in RSS. In 2011, he helped create Schema.org with the major search engines, the pragmatic mass-market version: a shared vocabulary for declaring that this is a Person, who is the author of this Recipe, which requires these Ingredients. And now he is behind NLWeb, the project for turning a site’s structured data into something an agent can talk to.
That is not someone who keeps stumbling into markup standards. It is one person pursuing a single conviction across thirty years: give machines a structured model of meaning, and the web becomes something they can reason about rather than scrape. RDF was too hard for the masses. Schema.org was simple enough to adopt, but it arrived before the consuming machine was smart enough to do anything interesting with the model. NLWeb arrives at the moment the consumer finally is. The history does not need a thesis put in Guha’s mouth; the pattern speaks for itself. When the person who has spent his career trying to get the web to declare its entities shows up at the dawn of the agentic web, the signal is hard to miss. The structured-meaning web was always the destination. Search was the detour.
Here is where it went sideways, and why so many practitioners now say structured data has no value. Schema.org’s purpose was a model of entities and relationships. But the incentive Google bolted onto it was rich results and better ranking. So adoption happened for the reward, not the purpose. Site owners did not model their business; they stuffed the minimum markup needed to get stars on a search listing, usually generated by a vendor pointed at their chaotic site and told to beat structure out of it at scale. Google, for its part, used the markup as a lossy crutch, a way to wring some structure out of fundamentally unstructured pages so it could build search features and trust a feed as a handshake.
Between the two, a vocabulary for meaning got operationalized as a ranking tactic. That is why “schema is dead for AI” feels true to the people saying it: their schema is genuinely low-value, because it is a thin veneer of price-and-product markup retrofitted onto a page, not a model of anything. They are right about their own data. They are wrong that the data is the ceiling. The entities, the actual model of the business, were never the part that lost value. They are precisely the part of NLWeb, and every successor format is reaching straight back for.
The detour cost us more than a clean data layer; it cost us the people who used to build one. There were once professionals whose entire job was the structure: ontologists, taxonomists, and information architects who determined a site’s hierarchy and nomenclature. That was a craft. It got displaced in the gold rush by two forces working together. The creative side made the experience the point and the structure an afterthought. And the SEOs, and we were among them, treated Google as an opportunity to be strip-mined rather than a structure to be respected, optimizing for whatever extracted the most traffic rather than for any coherent model of meaning. Between the two, the people who organized meaning lost their seat at the table, and structure stopped being a craft anyone owned. We used to employ people to model meaning. We fired them in the gold rush. And now the machines have arrived that need precisely what those people did, and we have almost no one left who does it. That is the detour in one sentence: we discarded the discipline the agentic web would have required, and some of us did so with our own hands.
The requirement: model first, render many
So the requirement the agentic web imposes is not “adopt a new file format.” It is the inversion of the build order the entire web industry is organized around. Model the meaning first. Render everything else, the website, the catalog, the agent envelopes, as equal outputs of that model.
This is not exotic. It is the oldest discipline in serious publishing. Aerospace, pharma, financial filings, technical documentation: any domain that could not afford to be sloppy has run on single-source, structured-content publishing for decades. Author the content once, in a neutral structured layer, then transform it into any final format, print, web, PDF, app. Two tribes have been solving the same problem in parallel for thirty years: the semantic-web people modeling entities, and the structured-content people separating content from presentation. The agentic web is where they finally merge, because there is now a consumer who demands exactly what both were building toward.
The shape of the layer is three things, and it is worth being concrete without getting lost in tooling.
First, an entity model. Not a pile of pages, but a declared graph of the things your business is and how they relate: products, people, policies, locations, and the relationships between them. This is what Schema.org was always pointing at, lifted out of the page and made the source rather than the residue. It is the unglamorous core, and it is the whole game.
Second, the emotifacts hung on those entities. This is the piece neither old tribe had, and it is the reason marketing never adopted single-source publishing: structuring the data felt like it would sand the soul off the brand. It does not. Emotion can be a first-class, modeled field. “Warm enough for a Reykjavik winter, packs to nothing” is a fact and a feeling fused, and it can live in the model as a structured, reusable attribute instead of being trapped in a rendered layout. The full case for this is the subject of the first article in this series, “The Friction Is the Code, Not the Feeling“; the short version is that the thing that scared marketers away from structure for thirty years is dissolved the moment you accept that meaning includes the persuasive part, not just the spec sheet.
Third, serialization. Once the model exists, emitting llms.txt and an EntityMap and an OKF library and an ARD manifest is a publishing step, not four content strategies. You author once and serialize many. The website is one view onto the model. The agent’s envelope is another. They are siblings, both rendered from the same governed source, and they cannot drift because they are generated, never hand-maintained.
This is the answer to the anxiety the standards landscape provokes. You do not have to bet on which format wins, and you do not have to choose among them. They are envelopes, not rival strategies. Be wedded to none of them; be fluent in the substrate that feeds them all. The price has one home and many windows. That is the entire idea, and it is what makes “be ready when the standard emerges” a real, affordable posture rather than a prayer.
The assembly tax: when the model is scattered, not copied
The price problem is one fact in too many places. The opposite problem is just as common and more expensive: one thing whose facts are scattered across too many pages.
Consider a car model. It is rarely one page. It is nine or twelve: a glossy main page built as a vibe machine, all aspiration and adrenaline, with the actual specifications buried in a tag that links out to dimension pages, trim pages, safety pages, towing pages, interior and package pages, and warranty pages. The model exists, but only as a constellation of documents, each wrapped in its own presentation, each linking to the next.
Now put Jeremy’s agent on it. The user does not ask for “the model page.” They ask for something like “an SUV for New England winters with room for seven and heated seats I can actually afford.” To answer, the agent has to find the relevant model, fetch and parse a dozen pages, strip the rendering off each, extract the handful of attributes that bear on the question, hold them together, and reason across them to decide whether the vehicle matches. That assembly has a cost, and the cost is real and measurable: every page fetched is tokens spent, and latency added, most of it on Chrome, the agent discards to reach a few facts. Multiply by every competing model the agent compares, and the assembly cost becomes the deciding factor in whether the agent finishes the job well, finishes it badly, or gives up and guesses. We have already seen what “gives up and guesses” looks like: the confidently wrong inventory answer for a car the manufacturer could locate in real time, because nothing was assembled and callable.
Here is the part worth internalizing, because it is the new economics. In an agentic world, the cost of assembling you is borne by the agent, and the agent prefers sources that are cheap to consume. Being expensive to assemble is a competitive disadvantage even when your facts are technically present, because the agent that must crawl through 12 pages to understand your model will favor the competitor whose model it can read in one call. Make yourself cheap to assemble, and you make yourself more likely to be invoked. Assembly cost is the new page speed.
The fix is the same inversion, applied to aggregation rather than deduplication. The car model is an entity. Declare it once, with its attributes aggregated into one structured representation: seating capacity, drivetrain, the heated-seats option, the price of the trim that has it, the towing figure, the winter-relevant features, all hung on the model rather than scattered across the documents that happen to render them. The dozen pages become views onto that entity, not the place where its facts live. On the schema side, this is exactly what the vocabulary was built for: aggregate the features and attributes onto the model entity, and use the relationship predicates, isPartOf and hasPart, to declare that the dimensions document and the trim document and the safety document are parts of the one model, rather than leaving the agent to infer the relationship from a buried link. You are telling the machine, in its own language, that these twelve things are one thing, and here is the one thing.
There is an honest gradient here too. Declaring isPartOf across the existing pages is the cheap first move: it does not assemble the entity for the agent, but it lets the agent traverse declared relationships instead of guessing which pages belong together, which already cuts the error rate and some of the cost. The fuller win is the assembled entity itself, a single representation the agent can retrieve in one call without traversing anything, which is where the assembly cost actually collapses. Same ladder as the offer: declare the relationships first, assemble from the source next, and expose the assembled entity for direct call last.
And this is where the loop closes. The glossy main page is the emotifact layer, the vibe, and the aspiration that genuinely sells the car to a human. The spec pages are the facts. The assembled entity has to carry both, because the agent shopping for a New England family is matching on the hard facts (seats seven, all-wheel drive, heated seats available, this price) and on the emotifacts (why this trim is right for that life). Model the entity, aggregate the specs, attach the emotion as structured meaning, link the parts with the existing vocabulary, and the hype machine and the spec sheet finally become one callable thing instead of twelve scattered renderings the agent has to pay to reassemble.
Why now, and why first
The why-now is not that a new standard appeared. It is that the consumer changed into one that can only see the modeled layer, and that consumer is becoming the buyer.
Our friend Jeremy Sanchez has the sharpest metric for what is at stake, which he calls Share of Invocation: not how often an AI mentions you, but how often it actually uses you, citing your data as the substance of an answer or calling your system to complete the task. Mentioned is visibility; used is revenue. A brand can be named in most of its category’s answers and be the executed choice in none of them. And invocation is decided at the modeled layer, because that is the only layer the agent reads.
Here is the offensive case, the part a strategist can carry upward. Almost nobody in your category has built this. The whole industry is pitch-comps and calcified prototypes with retrofitted schema, beautiful facades with no readable substance behind them. That means the shelf is open. The competitor who inverts the build order first is not merely more efficient; they are legible to the agent while everyone else is still a rendering the agent cannot parse. And invocation looks likely to be stickier than search ever was: an agent that learns to call you for a task tends to keep calling you, because re-shopping a working capability is cost the agent has no reason to pay. First-mover advantage in invocation may be a default position that competitors cannot easily dislodge. The window is open precisely because the whole industry built itself facade-first, and it will not stay open once the category notices.
The honest price of admission
None of this is free, and the pitch is stronger for saying so plainly.
The reason the structured-meaning dream stayed a dream is that the hard part is not the tooling, it is the modeling and the governance. Deciding your entity model, and keeping it clean as the business changes, is organizational work, not a product you buy. It is slower in the first mile than throwing up another beautiful page. It requires someone to own the model, which is awkward because that ownership is too technical for marketing and too commercial for engineering, so in most companies, it belongs to no one. That orphaning is the real reason this does not happen on its own, and as the detour showed, it is not a new vacancy. It is the chair we removed twenty years ago, suddenly load-bearing again.
So fill it. We have argued before, in the context of the emerging answer economy, that companies need a VP of Answers: a senior, cross-organizational owner, reporting to the C-suite, accountable for one thing, that when a customer asks, the brand is the answer they get. That article framed the role around content and the buyer’s questions. This one reframes the same seat around the substrate beneath those answers. Because the VP of Answers cannot deliver answers a machine will use without owning the layer this essay is about: the entity model, the emotifacts hung on it, and the assembly and retrieval that make the brand cheap for an agent to consume. Their job, stated in this essay’s terms, is to make assembly and retrieval painless, so that when an agent reaches for your category, you are the source it can read in one call rather than the twelve-page facade it gives up on. The metric they answer to is Jeremy’s: share of invocation, how often you are used, not merely mentioned.
A title without a method just relocates the orphaned problem onto one overwhelmed person, which is why we built the program that gives the chair an operating system: an Answers Management Program. In the language of this essay, the program is how you build and keep the layer instead of admiring the idea of it. It establishes a single, governed repository of verified answers, structures them so machines can ingest them, assigns ownership across marketing, sales, support, and product, and measures what is actually used rather than what is merely published. The VP of Answers is who sits in the chair; the Answers Management Program is what they run; the modeled data layer is what it produces.
The reason this has to be one accountable owner, and not a committee, is the whole diagnosis of this piece. Meaning got smeared across five copies and twelve pages precisely because it belonged to no one, sitting between marketing and engineering in a seat neither owns. A VP of Answers is the structural cure for diffusion of ownership, which is the actual disease. And the role pays for itself on today’s waste before any agentic upside arrives: the offer that breaks the feed every holiday, the price maintained in five places, the model no agent can assemble. You are not hiring a bet on a standard. You are hiring the person who finally stops the bleeding you have been paying for all along.
And the patterns that got us here were not stupidity. The creative genuinely wins the deal. Conforming data to an approved design is genuinely the faster path to shipping a campaign. The five copies of the price persisted because the cost of maintaining them was hidden behind the pixels, and the revenue did not depend on fixing it. People were responding rationally to incentives that hid the cost. What changed is not that everyone suddenly got wiser. It is the incentive that hid the cost that just disappeared. The agent reads the layer, the layer is the product, and the debt is now visible to the only audience that is growing.
So the requirement is honest and specific. Build the layer you skipped. Model your entities, attach the emotion as structured meaning rather than as rendered decoration, and treat every surface, human and machine, as a view onto a single governed source. Do it before your category does, because the shelf is open now, and the cost of waiting is a competitor’s default position you will not be able to dislodge later.
The pitch upward is not “let us adopt a standard that has not won.” It is “let us finally build the source of truth we have faked for twenty years, because for the first time the payoff is the whole point rather than a snippet decoration, and because the brands that build it first get on a shelf the rest of the market cannot yet see.” The web’s original idea was right in 1997. It got compromised into a search hack for two decades. The agentic web is the forcing function to build it properly, and the same person who started the idea is, not coincidentally, standing at the door.
Search was the detour. The destination is a web that knows what it means. Build the part of it that the machines can read, before being readable stops being an advantage and becomes the price of being in the room at all.
This is the second article in a series. The first, “The Friction Is the Code, Not the Feeling,” makes the case for emotifacts and the machine layer (bisandigital.com). On the VP of Answers role and the answer economy, see “In the New Answer Economy, Do You Need a VP of Answers?” For the program that builds and governs the layer described in this post, see “What Is an Answers Management Program?”
