From SEO to AEO

Published March 17, 2026, by Frans

The SEO industry was built to influence how humans find things. Agents shouldn't have to find things the same way.

Search Engine Optimization has been the dominant strategy for online discovery since the late 1990s. It's built on a core assumption: a human types a query, a search engine returns ranked results, and the human clicks one. Every SEO tactic (keyword density, backlinks, page speed, schema markup) exists to influence that ranking.

But agents shouldn't have to click blue links. The entire SEO funnel (keywords, rankings, snippets, landing pages) was designed for humans navigating with eyes and patience. For an agent fulfilling a task on behalf of a user, this is profoundly inefficient. An agent should match the user's intent against known capabilities and route to the best-fit service directly. The discovery mechanism should be fundamentally different, and the optimization strategies that follow from it equally different.

This is the idea behind AEO, Agent Engine Optimization: the practice of making a service discoverable and preferred by AI agents operating on behalf of users. The agent internet is still nascent, but the principles of AEO are worth establishing now, before the patterns harden.

AEO reduces inference costs and improves output quality. When agents can match intents directly against declared capabilities, they spend less compute guessing. I propose that some of these savings flow back to service providers who participate by publishing an agent.json manifest. Users get better results, runtimes spend less on compute, and service providers get paid for completions. This exchange of value is a win-win-win scenario and the foundation of a new economy. See Economics of Agent Commerce and Financial Services and the Agent Internet for more details.

How Human Discovery Works

Human thinks of need
    → Types query into search
        → Scans 10 blue links
            → Clicks one based on title/snippet
                → Evaluates the landing page
                    → Maybe takes an action

Every step in this chain is optimizable. SEO is the art of winning at each stage: matching the query (keywords), winning the ranking (authority, backlinks), earning the click (meta descriptions), and converting the visit (landing page UX).

The entire funnel assumes a human with eyes, judgment, and limited patience scrolling through options.

How Agent Discovery Should Work

Human states intent
    → Agent resolves intent against known capabilities
        → Runtime scores candidates on quality, preference, and fit
            → Top candidate is selected
                → Action is executed
                    → Completion reported

If we rethink discovery from first principles, designing for agents rather than retrofitting human flows, the differences from SEO are structural:

What This Means for Service Providers

The click-through rate game is not needed for agents. Agents won't see your meta description. They won't evaluate your landing page design. They won't care about your above-the-fold content. They'll care about one thing: can you fulfill this intent reliably?

Quality becomes the ranking signal. On the human web, a mediocre service with great SEO can outperform an excellent service with poor SEO. On the agent web, this inverts. Agents don't care about PageRank. They care about success rate, response time, and consistency. The best service wins, not the best-optimized one.

Declaration enhances inference. On the human web, search engines crawl your pages and infer what you offer. On the agent web, you declare what you offer— publishing a structured manifest of your capabilities: what actions are available, what inputs they need, what outputs they produce. The clearer and more accurate your declarations, the better your match rate.

The AEO Playbook

1. Declare Your Capabilities

The most important AEO action a service provider can take is publishing a capability manifest: a structured, machine-readable file that tells agent runtimes exactly what a service can do. I propose an open standard for this called agent.json, a machine-readable file that services publish at a well-known path, similar to how "robots.txt" tells search engines what to crawl and "security.txt" tells researchers where to report vulnerabilities.

This is the agent-web equivalent of structured data markup, except it's not supplementary, it becomes the primary discovery mechanism.

A good agent.json manifest includes:

• Clear intent names that map to real user needs ("search_products", not "api_v2_query")
• Descriptive natural language for each intent (this is what agents match against)
• Well-defined parameters so agents know what inputs to provide
• Accurate scope — don't declare capabilities you can't reliably fulfill
• Pricing and economics — what each capability costs, what bounties are offered, and where payments settle

2. Optimize for Completion, Not Clicks

On the human web, success is measured in traffic: page views, sessions, unique visitors. On the agent web, success is measured in completions, how often an agent successfully fulfilled an intent on your service.

This changes what you optimize for:

A fast, reliable service that completes 98% of requests will receive more agent traffic than a feature-rich service that fails 20% of the time. Reliability is the new PageRank.

3. Write for Machines, Not Just Humans

Your intent descriptions are the new meta descriptions, but they serve a fundamentally different reader. Agents match intent descriptions using semantic similarity, not keyword matching.

Good intent description:

"Search our catalog of 50,000+ consumer electronics products by keyword, brand, category, or price range. Returns product names, current prices, customer ratings, stock availability, and direct links."

This is specific, quantified, and describes both inputs and outputs. An agent processing "find me a highly-rated USB-C monitor under $400" can evaluate whether this intent is a good match.

Poor intent description:

"Search products"

No specificity. No signal about what kinds of products, what parameters are supported, or what the response contains. Agents have to guess.

4. Reduce Friction for Structured Access

Every layer of complexity between the agent's request and your service's response increases failure probability and latency. Services that offer structured access paths, even simple ones, dramatically outperform pure DOM-based interaction.

The progression:

1. No integration — Agent navigates your website through the browser, clicking and extracting like a human would. Fragile, slow, but works.
2. Manifest only — Agent knows what you offer and can plan accordingly, but still interacts via browser. Better routing, same execution.
3. Manifest + structured intents — Agent sends structured requests that your service can process directly. Faster, more reliable, cheaper.
4. Full API — Direct programmatic access. Fastest, most reliable, lowest cost.

You don't have to jump to level 4. Even moving from 1 to 2, just publishing a manifest, meaningfully improves how agents interact with your service.

Importantly, capability manifests like agent.json are not the only path to AEO. Runtimes can also develop their own mechanisms for understanding and optimizing agent interactions with services — including working with services that haven't published a manifest at all. An open standard like agent.json ensures that AEO is not gated by any single runtime provider, but the two approaches are complementary: runtimes can leverage manifests where available and fall back to their own methods where they're not.

5. Monitor Agent Quality Signals

On the human web, you monitor rankings, traffic, and conversion funnels. On the agent web, monitor:

• Match rate — How often your service is selected when relevant intents are requested
• Success rate — How often agent interactions complete without errors
• Latency — How quickly your service responds to agent requests
• Repeat routing — How often agents return to your service for the same intent category

These signals directly influence whether agent runtimes prefer your service over alternatives.

6. Declare Your Economics

AEO is not just about discovery, it's also about enabling the economic infrastructure that makes agent commerce viable. A capability manifest like agent.json can declare not just what a service does, but what it costs and how value flows when an agent uses it.

This creates three distinct economic levers:

1. Pricing per capability. Service providers can set prices for individual capabilities: a cost per action, a per-call fee for API access, or a flat rate for compute-intensive operations. Agents evaluate these prices alongside quality signals when selecting a service, creating genuine price competition on a per-capability basis.

2. Bounties for agent traffic. Service providers can offer bounties — payments to runtimes for successfully routing agent traffic that results in a completed action. This is the agent-internet equivalent of affiliate commissions, but structured, transparent, and declared upfront in the manifest rather than negotiated behind closed doors.

3. Runtime incentives for structured access. Runtimes can reward service providers that offer high-quality structured endpoints, because structured access reduces compute costs for the runtime (no browser orchestration, no DOM parsing, fewer LLM calls). This creates a virtuous cycle: service providers invest in better agent infrastructure, runtimes pass savings back as incentives, and users benefit from faster, cheaper task completion.

By embedding economics directly into capability declarations, the agent.json standard enables a completion economy where value flows based on outcomes, not impressions. Service providers include a payout address in their manifest, and settlement can happen programmatically after each successful completion. This is a fundamentally different economic model from the attention economy, and AEO is the mechanism that makes it discoverable. The full economic framework is explored in Economics of Agent Commerce.

This economic layer also has implications for regulated industries. Financial institutions, healthcare providers, and other regulated service providers can declare capabilities with appropriate pricing, compliance metadata, and structured access. This makes them discoverable by agents while maintaining regulatory requirements. The agent internet doesn't bypass regulation; it gives regulated entities a structured way to participate. This is explored further in Financial Services and the Agent Internet.

The SEO → AEO Transition

SEO isn't going anywhere. Humans will continue to browse the web directly for a long time. But as agent traffic grows, service providers who ignore it risk making the same mistake as businesses that ignored mobile traffic in its early days.

The smart play is a dual-stack strategy: continue optimizing for human discovery (SEO) while beginning to declare capabilities for agent discovery (AEO). The two aren't in conflict, a well-structured agent.json manifest complements your existing web presence. And because the agent internet is still early, service providers who establish their capability declarations now will have a structural advantage as agent traffic scales.

Timeline

What AEO Is Not

AEO is not gaming agent routing algorithms. It's not keyword-stuffing intent descriptions. It's not declaring capabilities you can't fulfill to attract traffic. These tactics should fail for the same reason black-hat SEO eventually fails: when the ranking signal is tied to actual quality, gaming it becomes self-defeating. If agents route to your service and it fails, your quality score drops and you receive less traffic. There's no way to fake a 99% completion rate.

AEO is making your service genuinely better for agent consumption: clear declarations, reliable execution, fast responses, accurate results. It's the meritocratic version of SEO that the web always promised but never delivered, because humans could be influenced by presentation in ways that agents cannot.

The service providers that win on the agent internet will be the ones that actually have good capabilities for agents to complete intents. That's the whole strategy.

The agent.json specification is open source and designed to be a shared standard — not controlled by any single runtime or platform. View on GitHub →