The Friction Is the Code, Not the Feeling

Why the agentic web reads for your facts and your emotion, and skips your pageantry

AI agents skip the pageantry and read for the facts, and platforms, publishers, and toolmakers are racing to rebuild the web to feed them. But what’s being stripped away isn’t the emotion; it’s the rendering tax. A field guide to the machine layer taking shape beneath the web, the half-finished standards fighting to define it, and why “someone’s already selling it” is not the same as “it works.”

For most of the web’s life, we built for one audience, and we built generously. The hero video, the scroll-triggered animation, the carefully sequenced customer journey: what an engineer calls bloat, a marketing team calls a high-converting experience. They’re both right. Humans don’t buy from raw data dumps; they buy on affinity, trust, and story. The pageantry isn’t bolted onto the sale; for a person, it often is the sale.

But in 2026, the web is living a split-screen reality. The same era that made flashy frontends trivial to ship also filled the web with AI search engines and agents indifferent to the glitter. When an agent hits a bloated enterprise site, it burns tokens and time stripping cookie banners, nav chrome, and hydration scripts just to reach the handful of facts it came for. Confuse it badly enough, and it hallucinates, or quietly drops your site from its context window.

So, if machines now read the web too, and they’re tuned to extract something different from what humans come for, what exactly are they skipping past?

The mistake almost everyone makes

The lazy version of this argument, and I’ve made it myself, says the shift means you strip the sizzle and serve the facts. Kill the theater, ship the spec sheet. That’s wrong, and it matters because it treats two very different things as if they were the same.

The first is rendering overhead: the cookie banner, the 2MB hero, the JavaScript that hydrates before a single sentence of text exists. This carries no decision value. It’s pure delivery cost, the tax an agent pays to reach the meaning. Nobody mourns the cookie banner, and this is what every emerging convention is racing to let machines bypass.

The second is emotion that actually decides things, a different animal entirely.

Emotifacts: emotion welded to fact

I call them emotifacts: content where the emotional, engaging element and the hard fact are fused into a single payload that changes a decision.

“This jacket runs warm enough for a Reykjavik winter but packs down to nothing.” That’s emotion (reassurance, the picture of yourself unbothered in the cold) welded to fact: warmth, packability. Strip the feeling, and you haven’t handed the agent the meat; you’ve handed it a spec sheet and thrown away the part that decides.

This is the crux. The “reduce to facts” crowd assumes emotion lives in the pageantry: that if you kill the rendering theater, the feeling dies with it. Emotifacts prove otherwise. Emotion can be structured: it rides in clean markdown, in a Schema.org review field, in a product description rewritten for a feed. The container changes; the emotional-factual cargo survives. The friction worth shedding is the code, not the feeling.

Two camps, two legitimate wants

Here’s what I want to be honest about, because it’s tempting to declare a winner and I don’t think there is one: both layers are real, both have a purpose, the two camps want what they want, and neither is wrong to do so.

The human camp wants the full experience and should have a way to wow potential customers. The journey converts; the pageantry earns trust and commands a premium price. Tell an enterprise to flatten its storefront into a JSON feed for the sake of agent-readiness, and you’ve handed its conversion rate to a competitor who didn’t listen. The theater is load-bearing for the audience it was built for.

The machine side needs the meaning without the operational overhead tax. An agent acting for a person doesn’t need the hero video to render; it needs the facts (and, critically, the emotifacts) clean and cheap. Force it to mine those out of a bloated DOM, and you lose to whoever made it easy.

The mistake isn’t choosing one camp; it’s thinking you have to. You don’t. The end state is dual-channel: keep the theatrical experience for the humans who buy it, and publish a parallel machine layer that still carries the emotifacts, minus the code tax. Same meaning, two deliveries, decoupled. That’s the whole game.

What the machine layer looks like (and why not to bet on any one of them)

Once you accept that a machine-facing layer is coming here, the question is: what format? The honest answer is nobody knows yet, so don’t bet the house on one horse. A handful of conventions are converging on the same idea: a clean, root-level layer written for machines instead of browsers. None is finished or widely adopted, but side by side, they show the shape of the thing.

llms.txt is a root-level signpost telling an incoming LLM what a site is about and where the high-value content lives. It’s contested: SE Ranking’s analysis of roughly 300,000 domains found it on about 10% of sites; there is no measurable link between having one and being cited by AI systems; and no major AI lab has committed to consuming it. A cheap forward bet: thirty minutes that might matter if the platforms ever formalize support, but not a proven channel.

agents.md is, today, a README for coding agents: a repo file telling AI dev tools how to build your project. The appetite for a root-level behavioral contract (specifying what a shopping agent may do and how to transact) is real, but that version doesn’t exist yet. The closest working validation is Shopify’s Universal Commerce Protocol, co-developed with Google.

OKF — Google Cloud’s Open Knowledge Format (June 2026) — formalizes the “LLM-wiki” pattern (Andrej Karpathy’s living markdown knowledge base): flat markdown files tagged with a little YAML front matter. Google built it to solve an internal problem: packaging the scattered organizational knowledge your agents need, such as table schemas and runbooks. The SEO world is already borrowing it for public discovery; practitioners like Marie Haynes reframe it as a shift from being found by search engines to making business knowledge usable by agents, even floating sellable “knowledge bundles,” a use its authors didn’t quite design for.

EntityMap is the most mature on paper: a stable v1.0 where the others are drafts. It publishes an entity-first index, a root-level entitymap.json that, where a sitemap lists what pages exist, declares what a site knows: which entities it covers, how they relate, and where the evidence lives, each claim backed by a source-attributed chunk. The caveat: it came from one vendor’s ecosystem (the brilliant Dixon Jones and Fred Laurant entity-solutions firm behind InLinks and Waikay), not a broad consortium, so its weight is in craftsmanship, not coalition, and adoption is nascent.

EntityMap matters for this argument specifically. Its vocabulary splits claims by how much judgment they carry: hard predicates (PART_OF, PRODUCED_BY) stand alone, but interpretive ones (IMPROVES, SUITED_FOR, TARGETS) require a declared confidence level. In the language of this article, a shipping standard has formalized the distinction between a fact and an emotifact. “Suited for cold-weather travelers” is exactly the affinity signal a human buys on, and the standard doesn’t discard it: it structures it, separates it from the hard facts, and labels how far to trust it. That’s the clearest existing proof of the central claim: emotion can be made machine-legible without being flattened into noise.

Milestone’s Benu Aggarwal has been making the parallel case from the schema and knowledge-graph side: the web is moving from pages to entities, where a brand’s structured entities become, in effect, its API, and the aim is to be operable, not just discoverable. Her companion metric, Share of Model, tracks how often your entities surface in generative answers, a close cousin of the invocation idea running through this piece.

The point isn’t to crown one. These are interchangeable implementations of a single inevitability: the web is separating its human-facing presentation from a clean, machine-facing meaning layer. You don’t need to know which wins; you need to structure your content to survive whichever, or all, get adopted. Every spec here, mature or draft, is evidence of the trend, not a bet you’re asked to make.

Should I just Use All of them?

In practice, yes, you could deploy all of them and hedge against the ultimate winner. That’s the strategically important answer, because it dissolves the “which horse do I bet on?” anxiety that these different standards set up. The reason it’s feasible is that these formats aren’t really rivals at the data level; they’re different envelopes for the same payload. If your facts and emotifacts live in one clean, structured, well-described source of truth, emitting them as llms.txt, an entitymap.json, an OKF library, and an ARD manifest is mostly a publishing step, not four separate content strategies. You author once and serialize many. That’s exactly where strict data and content standards come into play – it enables data consistency, and a deployment layer can be anything.

With any “deploy them all” mindset, I need to offer specific caveats:

The cost isn’t uniform. A signpost file (llms.txt) is half an hour. A genuine entity graph with confidence-rated relationships, or an ARD capability manifest backed by real callable endpoints, is real engineering — the latter especially, because a manifest that advertises “I can check inventory” has to point at a service that actually does. Verification/identity adds another layer of work. So “do them all” is cheap at the signpost end and meaningfully expensive at the capability end.

Maintenance multiplies, not just creation. Four emitters of stale data are worse than none, because now you’re confidently wrong in four machine-readable places. What makes “all of them” feasible is generating them automatically from a single source, so they can’t drift. Hand-maintaining four files is the trap.

And the part that the tools quietly solve: you increasingly won’t hand-roll these. The whole point of the Yoast/NLWeb “schemamap” example later in the article is that the CMS layer is starting to emit the machine view for you from the structured data you already keep. That’s the real answer to “be ready when the standard emerges”: own a clean, structured source of truth, and let the platform serialize it into whichever format wins.

So the precise framing for your decision tree is being legible to all of them is feasible if you treat it as one data-modeling problem with many output formats, not by adopting four standards. Be wedded to none, fluent in the substrate that feeds all.

Who’s Driving These Standards?

Worth saying plainly who is, and isn’t, behind this, because it’s stranger than it looks. With the partial exception of Google (which authored OKF and co-developed ARD and the Shopify commerce protocol), these conventions aren’t coming from the AI labs whose agents actually read the web. They come from the SEO and marketing world (EntityMap, the public OKF reframing), from independent developers (llms.txt), from publishers, and from one web-standards lineage running through Schema.org’s co-creator (NLWeb, out of Microsoft).

And here’s what should stop a brand cold before it spends a dollar: as of mid-2026, not one major AI system has publicly committed to reading any of them. The companies proposing the formats aren’t the ones that decide whether an agent honors them. No model card promises to parse your llms.txt. Supply is sprinting ahead of any demand-side promise to consume it, a peculiar way to build a potentially critical layer of the web.

The underlying problem is real: agents do pull stale, wrong, or competitor data when a site gives them nothing authoritative to read. So the puzzle isn’t whether the need exists; it’s the silence from the AI systems around it.

Which raises the question the field is dancing around: if surfacing clean, trustworthy facts to agents is this important and this hard, why haven’t the few companies that build agents sat down to ratify a single standard?

The first answers aren’t flattering. The labs feel little urgency because the cost of messy data falls on users and brands, not on their own balance sheets. Each would sooner have its own approach win by default than cede control of ingestion, ranking, and monetization to a shared spec. And committing early is a liability when you can stay format-agnostic and let publishers structure the data for free.

But the deepest irony is the one the field keeps walking past. Normally, the party that feels a problem most acutely is the one that fixes it; here, the labs feel it least. When an agent garbles your price or recommends your rival, the lost sale is yours; their product still “answered.” So the actor with both the most power to set a standard (it decides what its agents read) and the loudest public stake in accuracy (hallucination is the thing it apologizes for) is the one doing least to fix the problem at its source, while everyone with no leverage structures data on spec, hoping someone eventually reads it.

And we have run this fix before, which makes the silence louder. Twenty years ago, search engines wanted cleaner data and simply offered a bribe: mark up your pages with Schema.org, get rich results, and better ranking. Publishers complied because the powerful consumer made a concrete promise. That exact playbook is sitting on the shelf; the very person who co-created Schema.org, R.V. Guha, is in this fight through NLWeb. And still no lab offers the carrot. Why would they? In 2026, they don’t need to pay you to structure your data; they can scrape the mess, reason over it well enough, and let “not quite well enough” be your problem. A shared open standard would also democratize accuracy (anyone authoritative consumed equally), which a lab sitting on exclusive licensing deals and proprietary ranking has little reason to want. Hold those facts together, and the stated problem and the real one come apart: accuracy is what they say is broken; control is what they are protecting. The fix isn’t missing because it’s hard. It’s missing because the only seat that could ship it doesn’t think it’s broken enough.

I read the silence as a signal: the side that would have to honor these standards doesn’t feel enough pain to converge, so betting on any single format is betting on a winner in a race the favorites haven’t entered. Be legible to all; be wedded to none. And don’t mistake the loudest contestant for the rulemaker. In the same breath as publishing ARD as an open spec, Google shipped the first commercial product built on it: its Gemini Agent Registry. Volume across OKF, ARD, and commerce is real, but volume is not a mandate, and one vendor’s choices hardening into defaults by sheer reach is not the industry agreeing they’re right.

None of this is hypothetical: the machine layer is already shipping in tools that enterprises run. On millions of WordPress sites, Yoast built Schema Aggregation with Microsoft’s NLWeb project. Flip it on, and your site exposes a single “schemamap” endpoint that sends an AI your entire connected structured-data graph (articles, authors, products, relationships) in a single request, instead of crawling hundreds of pages. Their architect frames it as directing the AI wave rather than stopping it (“You can’t stop the AI wave, but you can direct it”), and as a way to manage server load while ensuring agents get the semantics to represent you correctly. That’s dual-channel as a plugin toggle: humans get the site, agents get the clean graph.

It’s also the right way to hold the whole zoo in your head. As Schema App’s Mark van Berkel put it in the session where ARD was announced live: “Standards will come and go, but the data will stay constant.” The names (llms.txt, OKF, EntityMap, NLWeb, schemamap, ARD) will churn. The discipline under them won’t: clean, connected, well-described, meaning any of them can carry.

ARD: the layer that finds you and decides whether to trust you

One element the root-level files never answered just got a serious answer: how does an agent find your machine layer across the open web, and once it does, why should it believe a word of it?

Agentic Resource Discovery (ARD), published in June 2026, is the discovery-and-trust layer above the formats. Google announced it and is integrating it into its own Gemini enterprise stack, but the substrate isn’t Google’s alone: ARD is Apache-licensed and built on the AI Catalog data model, governed by a Linux Foundation working group, with reference registries already being set up elsewhere (GitHub, Hugging Face). You publish a manifest (an ai-catalog.json) on your domain; federated registries crawl and index it; agents query them in plain language to find the right capability at runtime, instead of having every tool hand-installed.

The cleanest way to feel the leap is to line that manifest up against the files the web already knows. robots.txt told crawlers what they were allowed to touch; sitemap.xml told them what pages existed; ai-catalog.json tells an agent what you can do. Permissions, then inventory, then capabilities: from being searched to being invoked. The web spent thirty years getting good at publishing pages; ARD is the start of publishing actions.

That reframes where the opportunity sits, a reframing my friend Jeremy Sanchez maps sharply in a LinkedIn article called The Verb Economy. For twenty-five years, demand arrived as a noun (“best CRM,” “trail running shoes”) because the system could only hand back a document. Reasoning agents changed the grammar: people give them verbs now, like compare these on the total cost of ownership, find a hotel under $300 with a gym, and book it. A noun asks to be found; a verb asks to be fulfilled. And to fulfill a verb, an agent needs something it can call: a feed, a calculator, or an endpoint. Offer nothing callable, and it does its best with whatever it can scrape, and its best is frequently outdated, mistaken, or a rival’s. Sanchez tells it through shopping for a car from a maker that knows the real-time location of every vehicle it has built, and getting confidently wrong answers anyway, because none of that inventory was invocable. The problem wasn’t discoverability. It was executability.

His sharpest contribution is the metric that follows, Share of Invocation: not how often AI mentions you, but how often it uses you, citing your data as the substance of an answer or calling your system to do the task. Mentioned is visibility; used is revenue. A brand can be named in 80% of its category’s answers and be the executed choice in none. And the shift underneath isn’t subtle: in June 2026, Cloudflare reported that automated traffic had accounted for roughly 57% of the requests it saw, with bots overtaking humans for the first time and, as its CEO admitted, more than a year ahead of his own forecast. (That’s request volume, not time spent; people still dominate the hours.) Which is why Sanchez argues a brand is becoming infrastructure: a set of capabilities the reasoning layer either builds on or routes around. Almost everyone is still working on the content question: how do I get cited? Few are working on the capability question: how does an agent discover how it can quote the policy, check the stock, and book the slot? That gap is the open field.

But discovery is the half that gets the headlines, and the less interesting half. ARD is about publishing, discovering, and verifying capabilities across the web, and the third verb is the one that matters: it lets an agent cryptographically confirm who published a resource before acting on it. As one implementer put it, discovery without verification is just a way to industrialize trusting strangers.

Notice what that trust step is. “Who published this, and can I prove it?” isn’t a raw fact; it’s a confidence signal, reassurance encoded for machines. Even the trust protocols turn out to transmit something fundamentally emotional, stripped of the friction of how it’s painted on a screen. The agentic web isn’t deleting emotion; it’s standardizing how emotion (reassurance, trust, fit) travels without the bloat.

And ARD didn’t reach verification on its own. EntityMap, from a different corner of the ecosystem, built its own trust ladder: self-declared, generator-draft, third-party-verified, the top rung backed by a certification registry. When two unrelated efforts both conclude that discovery without verification is worthless, that’s the ecosystem telling you that provenance is becoming part of the payload. For a brand, the machine layer isn’t only about exposing your facts cleanly; it’s about proving they’re yours.

(One caveat, in the spirit of the rest: ARD is brand new. The spec went public in June 2026, and while the first registries and Google’s Agent Registry are coming online, real-world adoption has barely begun. The industry weight is real; the “enterprises are deploying this at scale” story is not. It’s the clearest signal yet of where things are heading, not something you can buy on Tuesday.) Maybe it is another behavioral shift Google can do by tying it to search benefits.

Someone’s already selling it, which proves demand, not that it works

All of this could read as abstract theorizing if there weren’t real money moving through it. There is, and it’s worth being precise about what that money proves. The clearest sign the dual-channel web is real isn’t a spec document; it’s a publisher booking actual revenue from it. What that doesn’t prove, yet, is that the thing being sold actually delivers.

Time’s COO describes the setup in almost exactly the terms of this article: humans go to time.com for the full experience; bots go to a markdown page, “a stripped-down version” with the metadata. Same brand, two deliveries. And here’s an irony worth savoring: an earlier era of SEO had a name for serving humans one thing and crawlers another. It was called cloaking, and Google would bury your site for it. Reborn for the agentic web, the same maneuver is a product roadmap. Call it Cloaking 2.0, with one redeeming twist: this time the bot’s version is the honest one, the same facts with the theater stripped out, not a keyword-stuffed decoy. For now, at least, until the sponsored content arrives. Because Time isn’t treating the machine channel as a defensive chore; it’s a product. They route purpose-built branded content to those pages, feed licensed streams to AI partners, and are reportedly building a pure data product that never publishes to the open web at all, designed solely to market to bots.

There’s a second-order signal there worth naming. The publishers aren’t the only believers; the marketers writing the checks are. Budget is the most expensive opinion there is: when brands pay to be present in the machine layer, they reveal a conviction about direction that no survey can match. They needn’t be right about any single tactic for the aggregate to inform: a market of motivated, well-resourced buyers putting money down is strong evidence the direction is credible, even while the efficacy of what they buy stays unproven. Belief backed by spend is a data point, about trajectory, not return.

The shift underneath is well-evidenced, and it should worry anyone optimizing only for blue links. Brands are watching roughly two-thirds of their Google search traffic vanish into zero-click answers, and by one estimate, around 84% of what AI engines cite comes from publishers (not self-reported numbers), and they point the same way. The audience didn’t disappear; it moved to the machine layer, so being legible there is table stakes. Axios, “popping” in LLM answers, credits its “smart brevity” house style: what’s new and why it matters up top, exactly the part an LLM scrapes first. Treat that as a plausible story, not a proven mechanism: it’s the emotifact lesson as an editorial habit, but even Axios is describing a correlation it likes.

Here’s where the skepticism has to bite, the same skepticism that this article applies to everything else. Selling a thing proves demand; it doesn’t prove the thing works. Stack the claims and they separate: that the audience moved to AI answers is reasonably evidenced; that you can build a bot-readable channel is trivially true; that paying to route branded content into it changes what an AI says and moves a purchase is the actual product, and it rests almost entirely on the seller’s word (“our domain authority is high,” “it’s really taken off”). Those are pitch lines, not measured lift, from chief revenue officers on a rented Cannes superyacht whose job is to sell exactly this.

Time’s COO even notes the sales team didn’t grasp the product until press coverage drove inbound: demand generation working, not the tactic proven. What would settle it (independent lift studies, citation-share gains attributable to the spend, downstream conversion) is mostly absent in public. And it all sits on LLM behavior the publisher doesn’t control: a vendor can change how it ranks or cites overnight, the way search engines have vaporized SEO tactics that worked right up until they didn’t. A market forming around a tactic isn’t the same as the tactic surviving the next platform update.

And there’s a catch worth thinking hardest about. The moment the clean machine layer becomes a paid channel (branded content on the bot pages, the Washington Post selling sponsored slots inside its AI answers, agencies selling “be more visible in ChatGPT”), the fact layer inherits the original sin of the human web: it can be bought. And a stripped markdown fact, shorn of the visual cues a human uses to sense “this is an ad,” is far harder to spot as sponsored once an agent has ingested it as plain text.

Which is exactly why the verification thread through ARD and EntityMap stops looking like plumbing and starts looking like the point. When the machine layer is free, provenance is a nicety; when it’s monetized, provenance is the only thing between a trustworthy fact and an undisclosed ad an agent repeats as truth. The emotifact a brand most wants to send, trust me, is the one that needs cryptographic backing the instant money enters. The publishers are proving the demand is real and the direction set. Whether the products they’re selling actually work, and whether the channel stays trustworthy enough to be worth buying, is the unsettled question the trust protocols exist to answer.

The honest boundary: not every purchase needs a soul

Emotifacts aren’t universally valuable, and pretending they are would weaken the argument. Their worth scales with how complex and subjective the decision is. For a pure reorder (paper towels, the same cartridge again), all the agent needs is price and availability; emotifacts are dead weight and the spec sheet is the answer. But for considered, high-affinity, identity-laden purchases (the ones your enterprise clients care about), the emotifact layer is the ballgame. A fact-only feed loses to a competitor whose machine layer kept the why this is right for you. Knowing which end of that spectrum a product sits on is the real strategic work.

What to actually do

You don’t have to pick a standard, and you don’t have to choose between your humans and the machines. Do two things.

1. Keep the pageantry on the site for the people who buy on it: the journey isn’t bloat to them, it’s the reason they convert.
2. Publish a parallel machine layer that carries the meaning, facts, and emotifacts both, without the rendering tax. Decouple the data layer from the presentation, so the same content serves theatrically to a human and cleanly to an agent.

Then, as the discovery and trust protocols mature, you’re already legible to them.

Alternatively, you don’t have to choose a method. In reality, they are all simply envelopes, not rival strategies: author your facts once, in one clean, structured source, then emitting several of these formats is a publishing step, not four content plans. Be wedded to none, but ensure you are fluent in the data that feeds them all.

The web isn’t splitting into a world of feeling and a world of facts. It’s learning to deliver to both audiences, in the form each can use. The winners won’t be the ones who stripped the emotion out. They’ll be the ones who shipped it without the code.

Be sure to check out part 2 of this series, “Search Was the Detour – 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.”

Further reading

The standards and protocols in this piece are moving fast, and most are weeks rather than years old. These are the primary sources worth tracking.

• NLWeb: Microsoft’s open project for turning a site’s data into a natural-language interface (and an MCP server). Reference implementation: github.com/nlweb-ai/NLWeb.
• The entity and schema view: Benu Aggarwal (Milestone), “Why entity authority is the foundation of AI search visibility” and “Agentic AI discovery requires machine-readable brands“, on entities as the brand’s API, schema drift, and Share of Model.
• Agentic Resource Discovery (ARD): the discovery-and-verification spec; Google’s announcement (developers.googleblog.com, June 2026) and the specification at agenticresourcediscovery.org.
• EntityMap: the entity-first index standard, with its predicate vocabulary and certification model; spec at entitymap.org/spec/v1.0, live reference at waikay.io/entitymap.html.
• Open Knowledge Format (OKF): Google Cloud’s announcement, How the Open Knowledge Format can improve data sharing (cloud.google.com, June 2026). For the SEO-world reframing, see Marie Haynes, The Open Knowledge Format (OKF) from Google is a new layer for agents (mariehaynes.com/okf).
• Yoast Schema Aggregation + NLWeb: the shipping CMS implementation, Futureproof your website for the agentic web with Yoast SEO Schema Aggregation (yoast.com, March 2026).
• R.V. Guha on the agentic web: Schema App’s webinar recap, Preparing for the Agentic Web: Key Insights from R.V. Guha and Schema App, where ARD was announced live and the “standards come and go, the data stays constant” framing comes from (schemaapp.com).
• The business model, in the wild: Time and Axios turn AI prominence into advertising revenue (Press Gazette, June 2026), publishers describing the bot-readable markdown layer, sponsored AI answers, and “marketing to the bots” as live revenue products.
• From discovery to invocation: Jeremy Sanchez, The Verb Economy (LinkedIn, June 2026), the noun-to-verb shift, the “Share of Invocation” metric, and the case for treating your brand as callable infrastructure. https://www.linkedin.com/pulse/verb-economy-jeremy-sanchez-pppec/
• Does llms.txt work?: SE Ranking’s analysis of ~300,000 domains found ~10% adoption and no measurable correlation between the file and AI citations (seranking.com/blog/llms-txt), corroborated by log studies from OtterlyAI and Ahrefs.