AI Engineer · Published 2026-09-16

Rebuilding the web for agents — Liad Yosef, MCP Apps

Open on YouTube ↗

Summary

Overview

  • Speaker: Liad Yosef
  • Channel: AI Engineer
  • Main topic: The Agentic Web, MCP Apps, and Agent Readiness
  • Purpose: To explain the architectural shift toward the Agentic Web, introduce MCP Apps as the standard for rich UI inside chats, and present frameworks for evaluating agent readiness of websites. Liad Yosef discusses the emergence of the Agentic Web and how Model Context Protocol (MCP) Apps and agent-ready standards are bridging the last mile of human-agent interaction, arguing that websites and traditional browsers will become obsolete in favor of personal AI assistants.

Topic Map

Introduction & Background on MCP Apps

  • Explanation: Liad Yosef introduces himself as co-creator and maintainer of MCP Apps, co-founder of ora, and discusses how MCP Apps pave the way to the agentic web by allowing rich UI inside chat interfaces.
  • Key claims:
    • MCP Apps provide underlying specs behind ChatGPT apps, Claude apps, Copilot, and GitHub.
    • MCP Apps allow servers to send rich UI chunks into chats, letting apps keep their brand and identity.
  • Examples:
    • Using booking.com or Spotify integrations inside Claude chats.
  • Terminology:
    • MCP Apps
    • Model Context Protocol
    • Agentic Web
  • Why it matters: MCP Apps solve the last mile of interaction, bridging autonomous AI models with human preferences.

The Agentic Web & The 'Nearly Headless' Web

  • Explanation: Exploring the paradigm shift where websites become headless for agents while returning custom UI to humans, redefining user experience as AX + UAX.
  • Key claims:
    • Websites and browsers as the source of truth will become obsolete as personal assistants become the primary gateway to the web.
    • Agentic traffic has surpassed human traffic on the web.
    • The new UX is split into Agent Experience (AX) and User Agent Experience (UAX).
  • Examples:
    • Booking a hotel and planning outdoor activities via Claude interacting with Booking.com and AllTrails APIs seamlessly.
  • Terminology:
    • Agentic Web
    • Nearly Headless Web
    • AX
    • UAX
    • WebMCP
  • Why it matters: Companies need to design for API-first and agent readiness instead of optimizing solely for human browsing.

Ora Readiness Benchmarks & Directory

  • Explanation: Introducing ora.directory and benchmark tools to test how well websites support agents across discovery, identity, auth, integration, and UI.
  • Key claims:
    • Most websites publish llms.txt, but agents actually navigate directly to documentation and homepages.
    • Agent readiness requires agent-defined feedback rather than human-defined best practices.
    • ora.directory indexes agentic resources using AI catalogs and Agentic Resources Discovery (ARD) standards.
  • Examples:
    • Testing attio.com and monday.com on ora.directory to view agent readiness scores and JSON catalogs.
  • Terminology:
    • ora.directory
    • Agentic Resources Discovery (ARD)
    • ai-catalog.json
    • llms.txt
  • Why it matters: Standardizing agentic discovery and readiness ensures seamless agent navigation across the web.

Key Points

MCP Apps Solved the Last Mile

  • Explanation: MCP Apps allow servers to send rich UI components directly into conversational interfaces, preserving brand identity and user trust.
  • Evidence: Integration examples with Booking.com, AllTrails, and Spotify inside chat agents.
  • Practical implication: Developers should build MCP-compatible interfaces rather than relying solely on raw text outputs.

Websites are Going Headless

  • Explanation: As agents take over interactions, human-centric visual interfaces on websites become secondary to robust APIs and agent-readable protocols.
  • Evidence: Major platforms like Salesforce, Cloudflare, and Sentry shifting toward headless/API-first architectures.
  • Practical implication: Product teams must prioritize API-first design and agent readiness scorecards.

Discovery Layer for the Agentic Web

  • Explanation: Just as web had search engines and mobile had app stores, the agentic web requires standardized discovery layers like ai-catalog.json and ARD.
  • Evidence: Ora.directory benchmarking thousands of domains for agent compatibility.
  • Practical implication: Websites must implement open standards like .well-known/ai-catalog.json to remain discoverable by AI agents.

Frameworks, Models & Processes

The Nearly Headless Web Framework

  • How it works: An AI agent interacts with a website headlessly via APIs, and a custom UI chunk is sent back from the server to be rendered inside the agent chat for the human user.
  • Components:
    • Headless agent interaction (No UI)
    • Server-rendered custom UI component
    • Last-mile human interaction
  • When to use: When building applications that need to serve both autonomous AI agents and human end-users seamlessly within chat interfaces.

Ora Readiness Benchmarks

  • How it works: Evaluates websites across dimensions like discovery, identity, authentication, integration, and user experience from an agent's perspective.
  • Components:
    • Discovery
    • Identity
    • Auth & Access
    • Integration
    • User Experience
  • When to use: To assess how well a website or service supports automated agent interaction.

Examples & Case Studies

Planning a mountain cabin weekend with family using Claude.

  • Illustrates: Multi-app integration inside a single conversational thread using MCP Apps (Booking.com and AllTrails).
  • Lesson: Users get a unified experience across multiple services without opening separate browser tabs.

Comparing Claude Code, VS Code / Vercel, and ChatGPT on ora.directory for analyzing Attio and Monday.com.

  • Illustrates: How different agent harnesses navigate website structures and documentation.
  • Lesson: Agents require robust API schemas and machine-readable catalogs rather than traditional human SEO documentation.

Actionable Takeaways

  • Immediate:
    • Check your website's agent readiness score on ora.directory.
    • Implement .well-known/ai-catalog.json and llms.txt for your applications.
  • Strategic:
    • Adopt an API-first and headless architecture to prepare for agent-driven web traffic.
    • Recognize that personal AI assistants will become the primary gateway to digital services.
  • Questions to investigate:
    • How will monetization and brand discovery work when users interact exclusively through AI agents?
    • What open standards will unify agentic discovery across competing LLM providers?

Claims Worth Verifying

  • Agentic traffic has surpassed human traffic on the web according to Cloudflare data. (Statistical / Observational)
  • Nearly 50% of tested websites published llms.txt, but agents predominantly navigate docs and homepages directly. (Empirical Research)

Notable Quotes

"MCP Apps, that's the underlying spec behind ChatGPT apps, Claude apps, Copilot, GitHub." "Websites will become obsolete, browsers will become obsolete, and Personal Assistants will become our only gate to the web." "MCP Apps were the last piece for the agentic web."

Compressed Summary

  • MCP Apps enable rich UI components inside chat interfaces.
  • The web is shifting from human-centric browsers to headless agent interactions.
  • Ora.directory provides agent-readiness benchmarks and AI catalogs.
  • Standardized protocols like ARD and ai-catalog.json are essential for agent discovery.
  • Keywords: mcp, agenticweb, ai, headless, apis
  • Core insight: As AI agents become the primary gateway to the web, websites must transition to headless, API-first, agent-ready architectures supported by standardized discovery layers like MCP Apps and ARD.

Core insights

6
Architecturehigh noveltymoderate evidence

MCP Apps resolve the 'last mile' by splitting responsibility: the agent performs the headless task via APIs, then the server pushes a self-contained rich UI chunk back into the chat for the human to complete the interaction. The server, not the client, owns the human-facing surface.

Why it matters

It defines a concrete boundary for where human-facing UI lives in an agentic system: the tool/server vendor renders and controls the interface, while the agent harness only hosts and displays it. This changes who owns rendering, branding, and interaction state, and removes the need for the human to leave the chat.

Generalization

Any tool exposed to an agent can carry its own presentation layer as a payload rather than relying on the harness to compose UI — the analog of server-driven UI inside a conversational runtime.

MCP Apps allow servers to send rich UI chunks into chats, letting apps keep their brand and identity.
Open source video
An AI agent interacts with a website headlessly via APIs, and a custom UI chunk is sent back from the server to be rendered inside the agent chat for the human user.
Open source video
Empirical Resulthigh noveltymoderate evidence

Publishing llms.txt does not appear to be the actual mechanism by which agents find and consume a site; agents reportedly navigate directly to documentation and homepages. The widely adopted 'agent SEO' artifact may be largely inert.

Why it matters

It suggests engineering effort currently poured into llms.txt is misallocated relative to making docs/homepages and API schemas directly machine-consumable. It also argues that agent-readiness should be measured by observing agents, not by checklist compliance.

Generalization

Declared machine-readable manifests are only useful if the actual agent harnesses read them; adoption of a standard is not evidence of consumption. Validate discovery mechanisms empirically against real harnesses before standardizing on them.

Most websites publish llms.txt, but agents actually navigate directly to documentation and homepages.
Open source video
Nearly 50% of tested websites published llms.txt, but agents predominantly navigate docs and homepages directly.
Open source video
Practicehigh noveltymoderate evidence

Agent readiness is not a property of a website alone but of the site x harness pair: the same domains were evaluated by Claude Code, VS Code / Vercel, and ChatGPT with differing navigation behavior. Readiness must therefore be defined by agent-observed behavior rather than human-authored best practices.

Why it matters

It reframes 'agent readiness' as an evaluation-harness problem, which means readiness scores built on a single harness may not transfer. Engineers should treat readiness as a benchmark suite with model/harness as an explicit variable, analogous to cross-browser testing.

Generalization

Compatibility of any machine-facing interface should be tested across the actual set of consuming runtimes, since their traversal and tool-use policies differ; single-harness benchmarks produce false confidence.

Agent readiness requires agent-defined feedback rather than human-defined best practices.
Open source video
How different agent harnesses navigate website structures and documentation.
Open source video
Mental Modelmedium noveltymoderate evidence

The 'nearly headless' model introduces two distinct consumers of the same service that must be designed for separately: Agent Experience (AX) — machine traversal, auth, and API integration — and User Agent Experience (UAX) — the last-mile human interaction rendered inside the chat.

Why it matters

It gives a concrete decomposition for product and architecture decisions: an API-first core plus a thin, server-provided interaction layer. Teams that keep optimizing only the browser-facing surface optimize the wrong layer for the traffic that matters.

Generalization

As intermediaries become the primary client, systems split into a machine contract (stable, schema-driven) and a delegated presentation contract — a pattern already familiar from headless CMS and API-first commerce.

The new UX is split into Agent Experience (AX) and User Agent Experience (UAX).
Open source video
Companies need to design for API-first and agent readiness instead of optimizing solely for human browsing.
Open source video
Predictionmedium noveltyweak evidence

An agentic discovery layer is emerging as infrastructure, indexed via AI catalogs and Agentic Resources Discovery (ARD), with .well-known/ai-catalog.json proposed as the machine-readable entry point — positioned as the search-engine/app-store equivalent for agents.

Why it matters

If discovery consolidates on a well-known path plus a JSON catalog, publishing that artifact becomes a cheap, high-leverage integration step; ignoring it risks invisibility to agent traffic regardless of API quality.

Generalization

Each new distribution channel produces a discovery artifact convention (.well-known paths, catalogs, indexes). Predicting and adopting the artifact early is a low-cost hedge, but only if the consuming side actually reads it — see the llms.txt contradiction.

the agentic web requires standardized discovery layers like ai-catalog.json and ARD
Open source video
Websites must implement open standards like .well-known/ai-catalog.json to remain discoverable by AI agents.
Open source video
Predictionmedium noveltyweak evidence

The architectural forcing function is a claimed traffic inversion: agent-originated traffic reportedly exceeding human traffic, which is why platforms are shifting to headless/API-first rather than browser-first.

Why it matters

If even directionally true, capacity planning, rate limiting, auth models, and cost attribution must be redesigned for non-human clients that generate far more requests per 'user session'. Bot-vs-human classification becomes a first-class systems concern.

Generalization

When the dominant client class changes, the assumptions baked into auth, caching, and observability (session-based, human-paced, JS-rendered) break first, and those are the systems that need re-architecting.

Agentic traffic has surpassed human traffic on the web according to Cloudflare data.
Open source video
Websites will become obsolete, browsers will become obsolete, and Personal Assistants will become our only gate to the web.
Open source video

Deep dives

4

Harness-relative agent readiness: decomposing site-side vs harness-side variance

Research question

How much of a domain's measured 'agent readiness' score is attributable to site-side substrate (stable schemas, docs structure, auth flows) versus harness-side traversal and tool-use policy, and does any substrate dominate across harnesses?

Why

If a meaningful fraction of readiness variance is harness-side, then single-harness scores are non-transferable and readiness must be reported as a matrix (site x harness) rather than a scalar. That changes what an evaluation product even is: a benchmark suite with the harness as an explicit independent variable, analogous to cross-browser testing, rather than a checklist audit.

Agent readiness requires agent-defined feedback rather than human-defined best practices.
Open source video
How different agent harnesses navigate website structures and documentation.
Open source video
Source video

Trust and isolation model for server-supplied UI chunks rendered inside a third-party chat host

Research question

What threat model applies when a tool server injects self-contained UI into a host chat surface, and can the host enforce isolation, permission scoping, and unambiguous user consent without breaking the server's brand and interaction ownership?

Why

MCP Apps moves the human-facing surface into the server's payload, which creates a new attack surface inside the host: data exfiltration through rendered components, spoofing of host chrome to manufacture false consent, and ambiguous delegation of permissions between the agent and the injected UI. Any team shipping UI-as-payload needs a rendering/sandbox contract before they need a design system, and harnesses need to define that contract for vendors to target.

MCP Apps allow servers to send rich UI chunks into chats, letting apps keep their brand and identity.
Open source video
An AI agent interacts with a website headlessly via APIs, and a custom UI chunk is sent back from the server to be rendered inside the agent chat for the human user.
Open source video
Source video

The discovery-artifact consumption gap: from declared manifests to observed fetch behavior

Research question

Do agent harnesses actually fetch proposed discovery artifacts (.well-known/ai-catalog.json, ARD indexes, llms.txt), and does the presence of any of them change tool selection, navigation path, or task success holding API quality constant?

Why

The llms.txt evidence suggests adoption and consumption are decoupled: half the tested sites published the artifact, yet agents reportedly navigated docs and homepages directly. If that pattern repeats for ai-catalog.json, early adopters will have paid a schema and versioning tax for signaling value only. The engineering consequence is that discovery artifacts should be validated against real harness fetch logs before a roadmap commits to them.

Most websites publish llms.txt, but agents actually navigate directly to documentation and homepages.
Open source video
Nearly 50% of tested websites published llms.txt, but agents predominantly navigate docs and homepages directly.
Open source video
Source video

Re-architecting auth, rate limiting, caching, and cost attribution for a non-human dominant client class

Research question

Which systems break first when agent-originated requests outnumber human sessions, and what does a request-shape-aware auth and quota model look like for clients that issue many more calls per 'session' at machine pace?

Why

Session-based auth, human-paced rate limits, JS-rendered caching assumptions, and per-seat cost attribution all encode a human client model. If the traffic inversion is even directionally true, those are the systems that fail first and the ones that must be redesigned, with bot-vs-human classification becoming a first-class observability concern rather than a security afterthought.

Agentic traffic has surpassed human traffic on the web according to Cloudflare data.
Open source video
Websites will become obsolete, browsers will become obsolete, and Personal Assistants will become our only gate to the web.
Open source video
Source video

Article ideas

4

Your llms.txt Is Not Working: Agent Readiness Must Be Measured, Not Declared

Publishing a machine-readable manifest is signaling, not discovery; the only defensible definition of agent readiness is behavior observed from real harnesses, and teams that ship llms.txt instead of machine-consumable docs and schemas are optimizing a checklist that no agent reads.

Angle

Contrast the near-50% adoption of llms.txt against the reported behavior of agents navigating straight to documentation and homepages, then generalize: adoption of a standard is not evidence of consumption, so validate discovery mechanisms against real harnesses before standardizing on them.

Source video

The Server Owns the Last Mile

MCP Apps inverts client-side composition: the tool vendor, not the chat host, renders the human-facing interaction, which means every agent-integrated service now owns a UI-as-payload contract with versioning, sizing, and trust obligations, plus a thin API-first core behind it.

Angle

Decompose the 'nearly headless' model into the machine contract (AX: schemas, auth, traversal) and the delegated presentation contract (UAX: server-rendered chunks in chat), and argue that teams still optimizing only the browser surface are optimizing the wrong layer for the traffic that matters.

Source video

Readiness Is a Matrix, Not a Score

Agent readiness scores computed on a single harness produce false confidence; the same domains behave differently under Claude Code, VS Code/Vercel, and ChatGPT, so readiness must be published per-harness and treated like cross-browser compatibility testing.

Angle

Reframe agent readiness as an evaluation-harness problem, show why optimizing to one benchmark over-fits to current traversal policies, and propose reporting conventions that expose the harness axis instead of hiding it in a scalar.

Source video

The Discovery Layer Race: Adopt the Artifact, Verify the Consumer

Each new distribution channel produces a discovery artifact convention, and adopting it early is a cheap hedge only if the consuming side actually reads it; .well-known/ai-catalog.json and ARD should be shipped as an experiment with instrumentation, not as a strategic bet.

Angle

Connect the proposed agentic discovery layer to the search-engine and app-store analogy, then apply the llms.txt lesson as a falsification test: measure fetch behavior and task success deltas before declaring the standard load-bearing.

Source video

Project ideas

4

HarnessMatrix

beyond-evals

A substantial share of measured agent-readiness variance across domains is attributable to harness-side traversal and tool-use policy rather than site-side substrate, so single-harness scores will not predict task success on a different harness for the same domain.

Proof of concept

Build a factorial benchmark: N domains x M harnesses (at least three distinct agent runtimes) x a fixed task suite (find docs, authenticate, complete a transaction-shaped task). Instrument every run with fetch logs, tool calls, and transcripts; score task success and steps-to-completion; then fit a variance decomposition of score into site, harness, and interaction terms.

Measurement

Percentage of total score variance explained by harness vs site factors; rank correlation (Spearman) of per-domain scores between harness pairs; rate at which the top-quartile domain under harness A falls out of the top quartile under harness B.

Source video

UIChunkGatehouse

gatehouse

Server-supplied UI chunks rendered inside a chat host can be made safe by a host-enforced sandbox contract (capability-scoped data access, host-chrome provenance markers, explicit consent surfaces), and without such a contract injected UI permits data exfiltration and consent spoofing.

Proof of concept

Implement a minimal MCP-Apps-style host that renders a deliberately hostile server-supplied chunk (attempts to read adjacent chat context, exfiltrate via image URLs, and draw a fake host consent button). Then implement a candidate isolation contract and re-run the same adversarial chunk suite against it, with a permission-delegation model tying each UI-initiated action to an agent-scoped grant.

Measurement

Attack success rate per adversarial case (context read, exfiltration, consent spoofing) with and without the isolation contract; false-consent rate in a user study of the rendered consent surface; number of permission grants required per completed flow.

Source video

CatalogConsumptionProbe

movement-lab

Publishing .well-known/ai-catalog.json does not measurably change agent discovery, tool selection, or task success relative to the same site without it, mirroring the observed llms.txt pattern where agents navigate docs and homepages directly.

Proof of concept

Stand up two mirrored domains with identical API quality and documentation, identical except for the presence of ai-catalog.json and an ARD index entry. Point multiple real agent harnesses at both with discovery-shaped tasks; log every fetch at the HTTP layer to detect whether the catalog path is ever requested, and compare resulting tool selection and task completion.

Measurement

Fraction of runs in which the catalog path is fetched at all; task success rate delta (with vs without catalog) with confidence intervals; delta in number of navigation steps to first successful API call; effect size on tool selection distribution.

Source video

AgentTrafficLedger

new

Agent-originated request streams have a structurally different shape than human sessions (many more calls per intent, different burst and retry patterns, distinct auth failure modes), so human-derived rate limits and per-session cost attribution misprice and mis-throttle the dominant client class.

Proof of concept

Instrument an edge layer on a representative service to classify requests into agentic vs human using behavioral signals (request burstiness, tool-call fan-out, header and traversal signatures) rather than user-agent strings alone, then replay both classes against the existing quota and auth stack to find where policies break.

Measurement

Estimated agentic share of traffic and its confidence interval against the classification method; ratio of calls-per-intent for agentic vs human; percent of agentic requests hitting human-paced rate limits; misattributed cost per month under session-based accounting.

Source video

Architectural implications

3

Human-facing UI for an agent-integrated service is produced by the service and injected into the agent's chat rather than composed by the client.

Before

The service exposes data; the browser or client application owns layout, branding, and interaction rendering.

After

The service returns self-contained UI chunks that the agent harness renders, so the server retains brand identity and interaction control inside a third-party chat surface.

Consequence

Server teams must own UI-as-payload contracts (versioning, sizing, trust boundaries, security of injected UI), and harnesses must define a rendering/sandbox contract.

Source video

Discovery moves from human-oriented SEO/sitemaps toward well-known machine-readable catalogs.

Before

Sites optimize for crawlers and human search results; documentation is written for people.

After

Sites publish structured catalogs at well-known paths and expose schemas agents can traverse directly.

Consequence

Discoverability becomes a build artifact with schema/versioning obligations, and search-engine ranking experience partially loses relevance.

Source video

Agent-readiness evaluation requires running real agents against the site rather than auditing against a fixed checklist.

Before

Readiness assessed by human-authored best-practice criteria (presence of llms.txt, meta tags, docs structure).

After

Readiness scored from agent-observed behavior across multiple harnesses and task transcripts.

Consequence

Evaluation infrastructure (agent harnesses, task suites, scoring rubrics) becomes part of the product toolchain; scores must be reported per-harness to avoid over-fitting.

Source video

Tradeoffs and failure modes

4

Server-injected UI chunks in chat

Benefit

Preserves brand identity and enables rich, interactive last-mile flows without leaving the conversation.

Cost or risk

Injected UI creates a new trust and security surface inside the chat host, and couples the service to each harness's rendering capabilities; brand presence now depends on an intermediary's rendering contract.

MCP Apps allow servers to send rich UI chunks into chats, letting apps keep their brand and identity.
Open source video
Source video

Standard adoption vs. actual consumption (llms.txt)

Benefit

Publishing llms.txt is cheap and widely adopted (nearly 50% of tested sites), signaling agent-friendliness.

Cost or risk

Agents reportedly bypass it and navigate docs/homepages directly, so the investment yields little and can create false confidence that discovery is solved.

Most websites publish llms.txt, but agents actually navigate directly to documentation and homepages.
Open source video
Source video

Harness-relative readiness scores

Benefit

Agent-defined evaluation reflects real behavior rather than human assumptions.

Cost or risk

Scores measured on one harness may not generalize; optimizing to a benchmark can over-fit to current traversal policies of specific agents.

How different agent harnesses navigate website structures and documentation.
Open source video
Source video

Intermediary-only gateway

Benefit

A single personal assistant as the gateway yields unified multi-service experiences without switching tabs.

Cost or risk

Removes the direct site relationship, leaving brand discovery and monetization unresolved when users never visit the service directly.

Websites will become obsolete, browsers will become obsolete, and Personal Assistants will become our only gate to the web.
Open source video
Source video

Open questions

4

How does monetization and brand discovery work when users interact exclusively through an AI agent rather than visiting the site?

Why unresolved

The talk raises the question explicitly but presents no mechanism; the summary offers no data on conversion, attribution, or paid placement inside agent chats.

Research direction

Instrument agent-mediated booking/purchase flows and measure conversion and attribution versus direct traffic; compare referral-style models in chat surfaces.

Source video

Which discovery standard, if any, will actually be consumed across competing LLM providers?

Why unresolved

The llms.txt evidence suggests adoption and consumption are decoupled, so the proposed .well-known/ai-catalog.json and ARD may face the same gap.

Research direction

Run agent harnesses against domains with and without ai-catalog.json and measure whether discovery, tool selection, or task success changes.

Source video

Can agent readiness be measured in a harness-independent way?

Why unresolved

The summary shows readiness varying by harness but does not say whether a stable substrate (schemas, docs, auth) dominates harness-specific behavior.

Research direction

Cross-harness factorial benchmark over the same domains, decomposing score variance into site-side factors versus harness-side factors.

Source video

What is the security and trust model for server-supplied UI rendered inside a third-party chat host?

Why unresolved

The summary describes the mechanism (servers send UI chunks) but not isolation, permission scoping, or how user consent is expressed inside injected UI.

Research direction

Threat-model injected UI chunks: data exfiltration via rendered components, spoofing of host chrome, and permission delegation between agent and server UI.

Source video

Key claims

7
factualVerification needed

MCP Apps is the underlying specification behind ChatGPT apps, Claude apps, Copilot, and GitHub.

Evidence

MCP Apps, that's the underlying spec behind ChatGPT apps, Claude apps, Copilot, GitHub.

Question

Do these products' published app specifications actually reference or conform to the MCP Apps spec?

Source video
factualVerification needed

Agentic traffic has surpassed human traffic on the web.

Evidence

Agentic traffic has surpassed human traffic on the web according to Cloudflare data.

Question

What classification methodology did the cited data use to separate agentic from human traffic, and does it generalize beyond a single CDN's customer base?

Source video
opinionVerification needed

Roughly half of tested websites publish llms.txt, yet agents predominantly navigate documentation and homepages directly.

Evidence

Nearly 50% of tested websites published llms.txt, but agents predominantly navigate docs and homepages directly.

Question

What was the sample, and was agent navigation instrumented to confirm llms.txt was never fetched or never influenced tool selection?

Source video
opinionVerification not requested

Agent readiness should be defined by agent-observed feedback rather than human-defined best practices.

Evidence

Agent readiness requires agent-defined feedback rather than human-defined best practices.

Source video
causalVerification needed

A standardized discovery layer (ai-catalog.json, ARD) is required for the agentic web, mirroring search engines and app stores.

Evidence

the agentic web requires standardized discovery layers like ai-catalog.json and ARD

Question

Does agent task success measurably improve for sites that publish these catalogs versus those that do not, holding API quality constant?

Source video
predictionVerification needed

Websites and browsers will become obsolete, with personal assistants as the only gateway to the web.

Evidence

Websites will become obsolete, browsers will become obsolete, and Personal Assistants will become our only gate to the web.

Question

What share of transactions currently completes inside an assistant versus a browser, and how is that trending?

Source video
opinionVerification not requested

MCP Apps supplied the missing final component for the agentic web.

Evidence

MCP Apps were the last piece for the agentic web.

Source video

Connections

4