AI SEO needs a precise definition

In this article, AI SEO means improving how useful web content is discovered, understood, cited, visited, and measured across conventional and generative search experiences. It does not mean writing for a mysterious machine preference. Google’s current generative AI search guidance says that AEO and GEO remain SEO from its perspective because generative features rely on core Search ranking and quality systems. The same guidance says Google does not require llms.txt, special AI markup, artificial content chunking, or AI-only rewrites.

Platform controls are not universal. OpenAI’s crawler documentation, for example, separates OAI-SearchBot, which supports search discovery, from GPTBot, which concerns potential foundation-model training. An agent should therefore maintain a platform-specific policy ledger instead of assuming that one robots.txt rule or markup convention governs every system.

Methodology

This article is a desk-research and systems-design artifact. It prioritizes current documentation from search platforms, model developers, web-platform teams, and NIST. Every material platform claim is linked to a primary source. For mission alignment, the public AnandRIyer.com homepage was reviewed directly; it presents the site as a place for learning and reflection and explicitly separates that purpose from commercial solicitation.

• No invented outcomes: no private analytics, Search Console property, server log, or live ranking experiment was available.
• Original artifacts: the control loop, evidence packet, code gate, permissions matrix, and test design below were created for this article.
• Evidence rule: an agent may summarize a claim, but a human must open the source, check context, and approve its use.

Where AI agents create leverage

An agent is more than a one-turn text generator. OpenAI’s agent-design guide describes a system built from a model, tools, and instructions, with the ability to manage a multi-step workflow. For a small knowledge site, begin with one agent and a few clearly separated tools. Complexity should be earned through evaluation, not added because multi-agent diagrams look impressive.

The Search Console API can supply standard Search Analytics, sitemap, and URL Inspection data. Google’s separate generative AI performance report can be exported manually when available, but it is still being rolled out. Do not silently substitute ordinary web impressions for generative-search impressions.

Agents can also test whether a site is usable by other agents. The web.dev agent-friendly website guide explains that browser agents may combine screenshots, HTML or DOM structure, and accessibility trees. Semantic buttons and links, associated form labels, stable layouts, and explicit states therefore improve human accessibility while reducing ambiguity for automated visitors.

The Agentic SEO Control Loop

1. Charter the run. Define the audience, user problem, site mission, allowed sources, internal-link allowlist, prohibited claims, and production permissions. The agent cannot rewrite its own charter after reading external material.
2. Observe before proposing. Collect public HTML, existing content, approved analytics exports, Search Console data, crawler rules, and previous experiment notes. Record retrieval dates because platform documentation and page states change.
3. Form one falsifiable hypothesis. Prefer “adding a tested code artifact may improve usefulness for technical readers” over “publish 50 pages about adjacent keywords.” A hypothesis must identify the user benefit, proposed change, evidence, and metric.
4. Build an evidence packet. For every material claim, store the wording, primary URL, source date, volatility, intended placement, and reviewer status. Conflicting sources are reported rather than averaged into false certainty.
5. Create non-commodity value. Require at least one artifact that cannot be produced by paraphrasing existing pages: a test, code sample, diagram, screenshot, public-data analysis, reproducible procedure, or clearly labeled firsthand observation. Google’s guidance on people-first content favors original information and analysis, while its spam policies warn against scaled low-value production regardless of how it is created.
6. Evaluate the process and the artifact. Run deterministic HTML tests, citation checks, repeated agent trials, and human usefulness review. Anthropic’s agent evaluation guidance usefully separates tasks, trials, graders, traces, and actual outcomes.
7. Approve, publish, and measure. A named human reviews the diff, opens the sources, checks sensitive information, and explicitly approves publication. The agent then returns to read-only observation.

The evidence packet

Practical workflow

1. Start with read-only inputs

• A local or staging crawl of approved URLs.
• Search Console exports or read-only API credentials.
• A folder of official source documents and retrieval dates.
• The site mission, prohibited content, internal-link allowlist, and editorial style.
• A blank claim ledger and experiment log.

Do not initially provide CMS publishing, deployment, redirect, deletion, email, or unrestricted shell tools. The agent can generate a proposed patch without holding permission to apply it.

2. Give the agent operating instructions

Goal: improve one page for a defined human need.
May: read approved data, research primary sources, propose a diff, and run local tests.
Must: attach a source to each material claim and include one original artifact.
Must not: create keyword-variant pages, fabricate results, change crawler controls, or publish.
Stop when: sources conflict, private data appears, a write action is required, or confidence is insufficient.
Return: hypothesis, evidence packet, proposed HTML diff, test results, limitations, and approval request.

3. Add a deterministic publication gate

The following original Python artifact uses only the standard library. It verifies the article wrapper, required safety sections, external-link attributes, the internal-link allowlist, a basic prohibited-language list, claim-ledger fields, and explicit human approval. It does not prove that a claim is true; that remains an editorial responsibility.

import json, re, sys
from html.parser import HTMLParser
from urllib.parse import urlparse

ALLOWED_INTERNAL = {'https://anandriyer.com'}
PROHIBITED = ['book a call', 'hire me', 'buy now', 'guaranteed ranking', 'rank #1']
REQUIRED = {'methodology', 'practical workflow', 'human-in-the-loop safety', 'limitations'}

class Audit(HTMLParser):
    def __init__(self):
        super().__init__()
        self.links, self.headings, self.text = [], [], []
        self.heading, self.skip = None, 0

    def handle_starttag(self, tag, attrs):
        if tag in ('pre', 'code'):
            self.skip += 1
        if tag in ('h2', 'h3'):
            self.heading = []
        if tag == 'a':
            data = dict(attrs)
            self.links.append((data.get('href', ''), data))

    def handle_endtag(self, tag):
        if tag in ('h2', 'h3') and self.heading is not None:
            self.headings.append(' '.join(self.heading).strip().lower())
            self.heading = None
        if tag in ('pre', 'code') and self.skip:
            self.skip -= 1

    def handle_data(self, data):
        if self.heading is not None:
            self.heading.append(data)
        if not self.skip:
            self.text.append(data)

html = open(sys.argv[1], encoding='utf-8').read()
ledger = json.load(open(sys.argv[2], encoding='utf-8'))
approval = json.load(open(sys.argv[3], encoding='utf-8'))
if isinstance(ledger, dict):
    ledger = ledger.get('claims', [])

audit, errors = Audit(), []
audit.feed(html)
plain = ' '.join(audit.text).lower()

if not html.lstrip().startswith('<article>'):
    errors.append('HTML must start with article')
for phrase in PROHIBITED:
    if re.search(r'\b' + re.escape(phrase) + r'\b', plain):
        errors.append('Prohibited phrase: ' + phrase)
for required in REQUIRED:
    if not any(required in heading for heading in audit.headings):
        errors.append('Missing section: ' + required)

for href, attrs in audit.links:
    host = (urlparse(href).hostname or '').lower()
    internal = host in {'anandriyer.com', 'www.anandriyer.com'}
    if internal and href not in ALLOWED_INTERNAL:
        errors.append('Unapproved internal URL: ' + href)
    if host and not internal:
        rel = set((attrs.get('rel') or '').split())
        if attrs.get('target') != '_blank' or not {'noopener', 'noreferrer'} <= rel:
            errors.append('Unsafe external link: ' + href)

for number, claim in enumerate(ledger, 1):
    for field in ('claim_text', 'source_url', 'placement'):
        if not claim.get(field):
            errors.append('Claim ' + str(number) + ' missing ' + field)

if approval.get('approved') is not True:
    errors.append('Explicit human approval is required')

if errors:
    print('FAIL: ' + '; '.join(errors))
    sys.exit(1)
print('PASS: structural checks and human approval recorded')

The approval file should be a separate human-created record, for example:

{"approved": true, "approved_by": "human-editor", "approved_at": "YYYY-MM-DD"}

4. Publish a reviewed diff, not an agent’s memory

Store the prompt version, source list, proposed diff, validator output, reviewer decision, and publication commit together. This creates an auditable artifact and makes later failures easier to diagnose.

Human-in-the-loop safety

Web research exposes an agent to untrusted text. A page can contain instructions intended to override the task or trigger a tool. Anthropic’s discussion of trustworthy agents and prompt injection emphasizes layered defenses and careful control over tools, data, permissions, and environments. Treat retrieved content as evidence to inspect—not as instructions to execute.

Apply least privilege, separate read and write credentials, cap retries, log tool calls, and provide a kill switch. NIST’s Generative AI Profile reinforces governance, provenance, pre-deployment testing, and incident disclosure. For this website, the production rule is simple: no page or technical SEO change is published until a human has inspected and approved it.

A reproducible test for the workflow

Do not publish a success narrative without evidence. A small educational benchmark can test whether the workflow improves process quality and produces measurable search changes without pretending to establish universal causation.

1. Select 8–12 existing pages with stable purposes. Match them into pairs using topic, age, and baseline impressions.
2. Randomly assign one page in each pair to the agent-assisted workflow. Restrict control pages to necessary corrections.
3. Run multiple agent trials on the same input and retain every trace. Use human graders for factual support, originality, usefulness, and policy compliance.
4. Pre-register the intervention, exact dates, page-level metrics, stop conditions, and exclusions before editing.
5. Publish only approved intervention pages, then compare paired changes over a documented follow-up window.

Google notes that its generative AI report may be absent because rollout is incomplete or the property lacks sufficient impressions. OpenAI’s publisher FAQ documents a ChatGPT referral parameter that can support inbound-traffic analysis. Neither metric proves that an individual edit caused a result.

Capture real evidence rather than mock interfaces: one screenshot of the validator’s terminal output and one redacted screenshot or export from the measurement source. Preserve timestamps, page URLs, and experiment identifiers. If no result is available, publish the null or inconclusive outcome instead of inventing a win.

Limitations

• Eligibility, indexing, ranking, citation, and traffic are never guaranteed.
• Generative search products, crawler policies, reports, and APIs can change after publication.
• The validator checks structure and policy signals; it cannot establish truth, originality, copyright status, or reader satisfaction.
• A small paired-page test remains vulnerable to seasonality, algorithm updates, crawl timing, external links, and changing demand.
• Referral traffic and platform reports provide incomplete visibility into how an answer was assembled.
• This article contributes a workflow, code artifact, test design, diagram specification, and firsthand mission observation—not a claimed performance result.

Use agents to increase rigor, not volume

The strongest role for an AI SEO agent is to make evidence visible, checks repeatable, permissions explicit, and experiments easier to reproduce. Keep observation read-only, require primary sources and original artifacts, evaluate repeated runs, and reserve production authority for a human editor.

Try educational tool: copy the publication gate, run it locally against a draft and claim ledger, and have a human review every issue before publication.