Somewhere on your site right now, an autonomous agent may be giving up. It found you, decided you were the right answer, then hit a checkout flow it could not operate without a human. It left. No error logged, no ticket filed, no analytics event. The customer never knew, because the customer was never watching. The next agent running that errand goes to whoever built a path it can walk.

That silent failure is the case for machine-first architecture. It is not a content technique or a schema checklist. It is a build sequence in which the most constrained visitor you have (a machine that cannot infer meaning from layout, guess at ambiguity, or recover from a dead end) is the one the site is designed around.

The precedent is mobile-first. The point there was never that phones mattered more than desktops, but that the small screen is the harder constraint, and building against the harder constraint forces you to decide what actually matters. Google made it policy fast: Mobilegeddon began demoting non-mobile-friendly sites in April 2015, StatCounter recorded mobile passing desktop globally in October 2016, and mobile-first indexing was announced a month later, completing its migration in October 2023. Today the harder constraint is not a small screen. It is no screen.

Four questions, asked in order

An agentic visit is a chain, and chains fail at their weakest link. Before a machine acts on your behalf it answers four questions in sequence:

1. Who is this? Can the entity be resolved confidently across sources?
2. What data does this page hold? Can facts be extracted programmatically?
3. Should I repeat it? Is the content attributable, dated and modular?
4. Can I act here? Can a task complete with no human in the loop?

Excellent writing cannot rescue a brand the model cannot identify. A crisp identity does nothing if the specifications sit behind JavaScript a crawler will not run. Both are wasted when an agent arrives ready to transact and finds a flow built entirely from visual affordances.

Machine-first does not mean human-last. Designing for the constrained consumer improved desktop rather than degrading it, and the same holds here.

Identity: resolve the entity first

AI systems cannot recommend a brand they cannot pin down. Google’s Knowledge Graph holds tens of billions of entities and well over a trillion facts about them, with credibility signals applied at the person-entity level. Models assemble a picture of your organization by reading several platforms in parallel and reconciling differences. When your site says “AI consultancy,” LinkedIn says “digital agency” and your Google Business Profile says “IT services,” the model either averages that into something vague or loses confidence entirely.

The fix is a canonical definition: a structured document describing the organization in fields, not prose. Treat it like API documentation. What you do, who for, where, what makes you credible, who the key people are, which entities you connect to. Every bio, directory listing, schema block and social description then derives from that one source.

Two things follow. When a model answers “who are the leading firms here,” it traverses connections between founders, clients, categories and publications, so publish those relationships as structured data rather than leaving them implied in blog copy. And because identity is synthesized continuously, one stale profile degrades the whole picture.

Research published by The Digital Bloom in December 2025 found brands mentioned on four or more platforms are 2.8 times more likely to appear in ChatGPT responses. That compounding only works when the platforms tell the same story, which is what this pillar enforces. We covered maintaining that single source in how to build an AI-ready source of truth.

Structure: data model before page design

This inverts the normal build order. Conventionally you wireframe a page, then work out what data it needs. Here you define the discrete, extractable facts the page exists to expose, then wrap a design around them.

It is a different question from the one a technical audit asks. An audit tells you whether your product page exposes price, availability and specifications; the architecture decides those are the facts the page exists to express in the first place.

• Hierarchy for machines, not eyes. Machines read heading levels, semantic HTML, schema and position, not font size or color. Decide what occupies the first content block of each page type before deciding how it looks.
• Declared relationships. Declare taxonomies, service hierarchies and parent-child structures through internal linking, breadcrumbs and schema. The test: starting from your homepage, could a machine build an accurate map of everything you offer by following published relationships rather than guessing from menu labels?
• Rendering. Critical data must exist in the initial HTML response. Ship a heavy single-page app where price and availability arrive after render, and that data is invisible to every crawler that does not execute JavaScript. Retrofitting it later is the most expensive correction in this discipline.

The rendered page is only one output of the data model; voice answers, chat citations and agent tool calls draw on the same facts. If design comes first, the data model becomes whatever the design happened to support. That is the same ground we covered in why you should build what AI can read.

Content: three decisions made before the draft

Most published AI-search guidance lives in this pillar, and much of it is good: answer-first writing, extractability, citable specificity, position on the page. Three architectural decisions determine whether that craft can land at all.

Authorship connected upstream

Models evaluate authorship against the wider knowledge graph when deciding whether to cite. Make it explicit through schema with sameAs links to verified profiles, and make the author entity the same one your canonical definition establishes. A bio buried in a footer contributes nothing.

Time declared at claim level

Recency carries real weight, and a 2024 guide loses ground to a 2026 one regardless of quality. Duane Forrester has noted that pre-cutoff and post-cutoff material behave differently inside the same model: the former is presented confidently and without attribution, the latter arrives hedged and cited. Declare when a specific claim was true and what supports it, at finer granularity than a publish date, so a system can judge individual claims rather than stamping one timestamp on the page.

Modular knowledge units

Retrieval systems lift claims, not narratives, and long documents suffer a documented middle-section problem where models attend most strongly to the beginning and end. Self-contained sections survive that. Give each one its own scope, question and evidence so it still makes sense extracted alone.

Interaction: the half nobody finishes

Visibility work covers the first half of the journey. Accessibility solves a related but different problem, because a screen reader still assumes a human is in control. Machine interaction has no human at the point of action.

Be honest about today’s volumes. The eye-catching trade numbers, including 393% year-over-year jumps in AI-referred traffic and conversion lifts near 42%, mostly measure humans arriving from AI browsers and answers, then shopping themselves. But the direction is obvious: the person who today asks ChatGPT to recommend a product and clicks through to buy will increasingly ask it to buy.

The vendors deciding whether to cite you are the same ones building the agents: OpenAI ships agent mode inside ChatGPT alongside the Atlas browser, Google merged Project Mariner into Gemini Agent and Chrome’s auto-browse capability in May 2026, Anthropic pairs Claude with computer use, Perplexity has Comet, and Microsoft built Agent Mode into Edge. The protocol layer firmed up alongside them: Model Context Protocol and A2A under the Linux Foundation, WebMCP as a W3C Community Group draft, the Agentic Commerce Protocol from OpenAI and Stripe, Google’s Universal Commerce Protocol announced with Shopify, Etsy, Target and Walmart at NRF in January 2026, and Visa’s Trusted Agent Protocol in production.

What a site owes an agent is concrete:

• Discoverable actions. A human infers a button is clickable. An agent needs a manifest of available actions, their inputs and their outcomes. Schema.org actions are one route, WebMCP another.
• Predictable outcomes. Every action returns machine-readable confirmation: item added, cart holds three items, total is this, next step is checkout.
• Workflow continuity. Multi-step flows expose current step, remaining steps and required inputs, with revision that does not destroy progress.
• Structured error recovery. “Something went wrong” is a dead end. “Unavailable in size M; available in S, L, XL; comparable product in M” is a decision point.
• Verifiable trust. Padlock icons mean nothing to a machine committing real money. Pricing, returns and guarantees must be evaluable programmatically.
• Declared agent policies. Browse only or transact? Compare prices? Identify itself? The standards are unsettled, but the need is stable: state what agents may do before they try.

Why the order is not negotiable

Content depends on identity, because structured authorship references the entity the canonical definition establishes. Interaction depends on structure, because an action manifest sits on the same data model that exposes price and availability. And interaction cannot be bolted on late; sites that try end up with disconnected widgets that simulate machine-readability without delivering it, and agents detect the gap and leave.

Traditional SEO covers structure plus parts of identity through schema. Generative engine optimization covers content plus retrieval-side structure. Accessibility touches structure and interaction, but only for human-assisted access. Organizational identity at one end and autonomous interaction at the other sit outside all three, and that union is where machine-first architecture operates. When you are inheriting years of accumulated problems, sequencing matters even more, as we argued in why a new SEO vendor cannot build on a broken foundation.

One move per pillar this week

• Identity. Write the canonical definition as fields, then search your own business name and compare every result against it. Each platform telling a different story is a leak.
• Structure. Take your three most important page types and list the facts each exists to expose, in priority order, before touching layout.
• Content. Take the three pages most likely to be cited. Schema-link the author entity to the canonical definition and add claim-level dating.
• Interaction. Complete a core action using only a screen reader. If you cannot get through it, neither can an agent, and an agent has far less patience.

Frequently asked questions

Is this just SEO with new terminology?

No. SEO optimizes a page’s chance of ranking and is mostly evaluated after a site exists. This is a build sequence applied before design, extending in both directions: to how the organization resolves as an entity, and to whether an agent can transact unattended.

Do I need to rebuild from scratch?

Rarely, but the order still applies to remediation. Identity work is cheap and unblocks everything downstream, so start there.

Are agent transactions actually happening yet?

Not at meaningful volume against human traffic. The infrastructure is live, the first flows are running, and the same vendors control both citation and agent layers. Sites that wait for traffic to force the issue will rebuild under pressure.

How is this different from accessibility?

Accessibility assumes a human stays in control, using assistive technology to interpret and decide. Screen reader testing is a useful proxy for agent readiness, but passing it is a floor, not a finish line.

The compressed curve

Mobile-first took years to play out, but the transition that mattered, the point where ignoring it started costing money, happened in months. The same curve is running again, faster. The infrastructure for machine identification, extraction, citation and action is shipping now, from the companies that also decide who gets named in the answer. Building for it is not speculation about a future web.