What is an agentic website? (And what we did to make ours one)
An agentic website runs its own growth and lets AI agents operate it directly — not a site AI built once. What it is, how it differs from the agentic web and AI builders, WebMCP, and what's hype. From an agency running one.
An agentic website is a website wired to its own data and to AI agents so it does two things a normal website can't: it runs its own growth — SEO, content, conversion, freshness — with a human on judgment, and it lets outside AI agents read and act on it directly instead of just looking at it. The shorthand we use is a website that runs itself. It is not a site an AI built once and left sitting there; it is a site an AI operates continuously. Two different ideas hide under the term, and almost every article blurs them: a site that improves itself from data, and a site that AI agents can operate. Both are real, both arrived in 2026, and most of the web is about to need both — because as of June 2026, for the first time in the internet's history, machines visit more of the web than humans do. We run one. This is the honest field guide, including where the hype runs ahead of reality.
The web crossed a line this year
In June 2026, automated traffic passed 57.5% of all web requests. Bots, crawlers, and AI agents now visit more of the internet than people do — the first time machines have held the majority since the web existed (HUMAN Security's 2026 benchmark). Traffic specifically from AI agents and agentic browsers grew an estimated 7,851% year over year (Digital Applied's 2026 crawler data). Gartner expects 40% of enterprise applications to include agentic AI by the end of 2026, up from less than 1% in 2024.
Sit with what that means for a website. The thing you built for humans to read is now mostly visited by software — software that increasingly doesn't want to read your page, it wants to use it: pull your prices, book your slot, submit your form, compare you against three competitors and report back to its human. A website designed only for a human reader is, in 2026, optimized for the minority of its own traffic.
That is the pressure creating the agentic website. And because the term is new, it's a mess. Let's clean it up.
The two things hiding under "agentic website"
Almost every take on agentic websites blurs two genuinely different ideas. Separating them is the whole game.
Agent-improvement: the site optimizes itself. This is a website wired to its own performance data — search rankings, competitor moves, citation data, analytics — with agents that read that data, decide what to fix, and ship the changes on a loop, while a human makes the strategic calls. The site gets better on its own. This is the sense we live in: our own SEO program runs this way.
Agent-operability: outside agents can act on the site. This is a website that publishes a structured set of actions an external AI agent can invoke directly — "book a consult," "request a quote," "add to cart" — instead of scraping your HTML and guessing. The emerging standard for this is WebMCP, which we'll get to. This is the sense the protocol crowd means.
A fully agentic website does both: it runs itself and it's operable by the agents that now make up the majority of web traffic. Most articles pick one and call it the whole thing. Holding both is the clearest way to understand where the web is going — and it's the difference between a site that survives the agent era and one that's merely visible during it.
Agentic website vs the agentic web vs an AI website builder
Three terms get used interchangeably and shouldn't be. Here's the clean separation.
The agentic web is the infrastructure — the protocols (MCP, WebMCP, NLWeb) that let agents and sites talk. It's the plumbing of the whole internet, championed by Microsoft, Google, and Anthropic. You don't own it; you build on it. An agentic website is one specific site wired to take advantage of that plumbing.
An AI website builder (Wix, Squarespace, Lovable, v0, Replit) uses AI to generate a website once. You prompt it, it builds, you publish, and then it sits there exactly like any other static site. That's AI that builds a site. An agentic website is AI that runs a site. We call the difference between them the operator gap — and it's the gap where almost all the durable value lives, because a site AI built is a commodity by next quarter, while a site AI runs compounds.
A chatbot bolted onto your homepage is none of these. The agency in an agentic website lives in the operating loop, not in a widget that answers questions.
| What it is | Who owns it | |
|---|---|---|
| Agentic web | The protocols that let agents and sites interact (MCP, WebMCP, NLWeb) | The whole internet / standards bodies |
| AI website builder | AI that generates a site once, then stops | The tool vendor; you, briefly |
| Agentic website | A specific site that AI runs and that agents can operate | You |
The improvement loop, with our receipts
We don't describe this from the outside. The site you're on runs its own growth.
Every weekday, an agent pulls our Google Search Console data, runs live checks against the AI Overviews and search results we're trying to win, compares the results to the day before, ships the low-risk fixes itself, and queues the judgment calls for a human. It keeps a running ledger of which pages get cited by which AI engines, and when a defended page slips, that's a flag, not a surprise. Over its first stretch the program grew our search visibility by roughly 850%, captured a Featured Snippet, and started earning citations by name inside Google's AI Overviews — including, this quarter, getting our coined definition of an "automaton agency" adopted into the AI Overview itself.
That's the agent-improvement half of an agentic website, running in production. The architecture under it is the one we documented as the five-layer framework: the model, the connectors to live data, the workflows, the operator (human plus agent), and the institutional memory that knows what's already been tried. The full build is written up as a case study and a 90-day field report with the actual citation data. The point isn't the tooling. The point is that a website running its own growth is a thing you can have today, not a forecast.
And here's the part that matters if you're weighing whether you could just copy this: the value isn't the agent. Everyone will have agents soon. The value is the earned workflow underneath it — the hundred small, hard-won rules the loop has accumulated about when to ship a fix versus flag it for a human, how to defend a ranking the moment it starts to slip, how the whole cadence has to change as the site grows from a handful of pages to dozens. That's months of human-and-machine co-creation, and it's the reason a site an AI runs compounds while a site an AI merely built just sits there. The agent is the cheap part. The earned workflow is the moat — we make that full case in our piece on service as software.
The operability layer: WebMCP, and what we're doing to our own site
The improvement loop is here now. The operability layer is arriving fast.
WebMCP is a proposed open web standard, rolled out by Google at I/O 2026, that lets a website publish a structured "tool contract" — a list of actions an AI agent can call directly, instead of scraping your page and hoping. It builds on the Model Context Protocol that Anthropic introduced in late 2024 and that OpenAI and Google DeepMind have since adopted. WebMCP is now in an experimental origin trial in Chrome 149, which is the on-ramp to shipping native agent capabilities to over three billion Chrome users (WorkOS's developer breakdown). In plain terms: the browser is about to be able to use your website on a person's behalf, and WebMCP is how your site tells it what it's allowed to do.
It comes in two flavors: a declarative version (you annotate your existing forms with a couple of attributes) and an imperative one (a JavaScript API for richer actions). For most sites, the declarative path is the entire job — you describe what your contact form and your quote request actually do, and an agent can invoke them cleanly.
So we started building it on this site — and the build is the honest part of the story.
The first thing we shipped isn't the flashy part; it's the prerequisite almost everyone skips. Before an agent can act on your site, it has to be able to find and read it. So we built the discovery layer: a robots policy that explicitly welcomes the AI crawlers and answer engines we want citing us — GPTBot, ClaudeBot, PerplexityBot, Google-Extended and the rest — which is the opposite of the reflexive "block the bots" posture, plus an /llms.txt file (the emerging llmstxt.org convention) generated live from our own content so an AI reading our site gets a clean, current map of it. Both are live. Being read is the table stakes of being cited.
The operability layer — agents doing things, not just reading — is where the honest gotchas live, and they're more instructive than a clean success story would be. When we scoped exposing our actual conversion actions as agent tools, we hit two real walls. Our contact form is an embedded third-party form on another domain (a cross-origin iframe), and WebMCP's simple declarative path can't reach across that boundary — the easy version stops working the moment your form lives on someone else's origin. And a route we'd listed in our own sitemap didn't actually exist yet, which an agent would discover as a dead end faster than any human would. Neither is exotic. Both are exactly the kind of thing you only learn by trying to ship it.
What they taught us is the part worth keeping: don't build for the protocol. Build each capability once as a plain action your own backend owns, then wear WebMCP (for browser agents) and classic MCP (for chat assistants like Claude or ChatGPT) as thin adapters over the same capability. The protocols are young and will churn; the capability underneath them won't. Capability first, protocols as costumes — which is the same lesson as the earned workflow: the durable thing is the system you own, not the standard you happened to be wearing this year. Doing it early is cheap (the discovery layer is inert to browsers that ignore it and pure upside to the agents that don't) and it means the site is ready the day native agent support lands. Being early is cheap; being late is a scramble.
What's hype and what's real
We'd rather lose a reader to candor than keep one with overclaiming.
llms.txt is not an agentic website, and it's not a ranking factor. It's a proposed file — a plain-text summary of your site for language models — and it's a reasonable thing to add, but adoption by the major AI engines is partial at best, and no one should tell you it earns you citations. It's one small, optional lever, not the thing — we serve an llms.txt on this very site and still wouldn't claim it earns us a single citation. We treat it as exactly that: one lever among several in making a site agent-ready.
WebMCP is real but pre-stable. Origin trial, not native shipping. Build for it as an early adopter, not as a finished standard.
"Agentic website" search demand is still small. People aren't yet typing the phrase in volume — they're typing "can AI build my website" and "AI web design." The category is ahead of the search term, which is exactly when it's worth defining the term — but we're not going to pretend the traffic is here yet. It's coming because the traffic that matters — the agents — already arrived.
How to start, if you run a business
You don't need all of it at once, and you shouldn't buy the operability layer first.
Start with the improvement loop. The highest-leverage version of an agentic website for almost everyone is the part that runs your growth — a site wired to its own data with agents doing the repetitive optimization and a human on strategy. That pays for itself in performance, today, with mature tools.
Add the operability layer as it matures. Annotate your key conversion actions for WebMCP now (cheap, future-proof), and deepen it as the standard ships natively over the next year.
Keep the human on the judgment layer. The whole point of an agentic website is not "no humans." It's humans freed from the repetitive operation so they spend their time on the calls only judgment can make. A site that runs itself is only as good as the person deciding what it should be running toward.
That's the honest shape of it. The web tipped to a machine majority this year. The websites that win the next few years are the ones built to be run, and to be used by the agents that are now most of their traffic — with a human still deciding what all of it is for.
Frequently asked questions
What is an agentic website?
An agentic website is a website wired to its own data and to AI agents so it can run its own growth (SEO, content, conversion, freshness) with a human on judgment, and let outside AI agents read and act on it directly rather than just view it. In short: a website that runs itself and that agents can operate, rather than a static page built once and left alone.
Is an agentic website the same as the agentic web?
No. The agentic web is the infrastructure — the protocols (MCP, WebMCP, NLWeb) that let AI agents and websites interact. An agentic website is one specific site built to take advantage of that infrastructure. The agentic web is the road system; an agentic website is a particular vehicle built to drive on it.
How is an agentic website different from an AI website builder?
An AI website builder (Wix, Squarespace, Lovable, v0) uses AI to generate a site once, then the site sits static. An agentic website uses AI to run the site continuously — optimizing it from data and exposing it to agents. The difference is the "operator gap": AI that builds a site versus AI that operates one. The value compounds on the second.
What is WebMCP?
WebMCP is a proposed open web standard, rolled out by Google at I/O 2026, that lets a website publish a structured list of actions an AI agent can invoke directly instead of scraping the page. It builds on Anthropic's Model Context Protocol and is in an experimental origin trial in Chrome 149. It's the leading way to make a website agent-operable.
Do I need llms.txt for an agentic website?
No. llms.txt is an optional plain-text summary of your site for language models. It's reasonable to add, but adoption by major AI engines is partial and it is not a ranking or citation factor. It's a minor lever, not what makes a website agentic.
Do I need an agentic website?
If your customers (or the AI agents acting for them) increasingly find, compare, and transact through AI, then yes — but start with the part that runs your growth from data, which pays off today, and add agent-operability (WebMCP) as the standard matures. Most businesses should not build the operability layer first.
What to do next
If you want to understand whether your site should be running itself — and which parts — our Revenue Audit maps it against your actual business. If you'd rather see the model behind it, How It Works and our stack write-up are the place to start. We run an agentic website; we're not describing one we read about.
About the author: Joseph Cone runs Automaton Agency, a creative technology firm that builds and runs AI-powered systems for SMBs and growth-stage companies. This website runs its own SEO and answer-engine optimization on the model described above. We are not affiliated with Google, Microsoft, or Anthropic.
Last updated: 2026-06-29.
Related: Service as software · What is an automaton agency? · The Automaton stack