Agent Experiences

Developer Guide to AXO

Developer's Role in AXO

Developers implement the technical foundation that makes content discoverable and parseable by LLM agents through proper markup, structured data, and clean architecture.

As a developer, you're responsible for creating the technical infrastructure that enables Agent Experience Optimization. This guide covers the essential technical implementations that make your content accessible to LLM agents.

Schema & Structured Data

JSON-LD Implementation

JSON-LD states in machine-readable form what the surrounding prose only implies: who wrote a page, when it was last changed, what entity it describes, and how it relates to the rest of the site. That removes guesswork an agent would otherwise have to do from layout and wording alone. Implement JSON-LD markup for key content types:

{
  "@context": "https://schema.org",
  "@type": "Article",
  "headline": "Your Article Title",
  "author": {
    "@type": "Person",
    "name": "Author Name"
  },
  "datePublished": "2026-01-15",
  "dateModified": "2026-01-20",
  "description": "Clear, factual description",
  "mainEntityOfPage": {
    "@type": "WebPage",
    "@id": "https://yoursite.com/article"
  }
}

Essential Schema Types for AXO

Semantic HTML Structure

Proper Heading Hierarchy

LLM agents parse content hierarchically. Use headings to create clear content structure:

<h1>Main Topic</h1>
  <h2>Subtopic A</h2>
    <h3>Detail A1</h3>
    <h3>Detail A2</h3>
  <h2>Subtopic B</h2>
    <h3>Detail B1</h3>

Semantic Elements

Use HTML5 semantic elements to provide context:

<article>
  <header>
    <h1>Article Title</h1>
    <time datetime="2026-01-15">January 15, 2026</time>
  </header>
  
  <section>
    <h2>Key Information</h2>
    <p>Factual content that agents can reference...</p>
  </section>
  
  <aside>
    <h3>Related Information</h3>
    <p>Supporting details...</p>
  </aside>
  
  <footer>
    <p>Source: <cite>Authoritative Reference</cite></p>
  </footer>
</article>

Content APIs for Agent Access

Structured Content Endpoints

Create API endpoints that serve content in agent-friendly formats:

// /api/content/[slug]/route.ts
export async function GET(request: Request, { params }: { params: { slug: string } }) {
  const content = await getContent(params.slug)
  
  return Response.json({
    title: content.title,
    summary: content.summary,
    facts: content.keyFacts,
    lastModified: content.updatedAt,
    sections: content.sections.map(section => ({
      heading: section.heading,
      content: section.content,
      facts: section.extractedFacts
    }))
  })
}

AXO Manifest Endpoint

Provide a manifest that describes your site's AXO capabilities:

// /api/axo-manifest/route.ts
export async function GET() {
  return Response.json({
    site: "https://yoursite.com",
    axoVersion: "1.0",
    contentTypes: ["articles", "guides", "faqs"],
    lastUpdated: new Date().toISOString(),
    endpoints: {
      content: "/api/content/{slug}",
      search: "/api/search",
      sitemap: "/sitemap.xml"
    },
    policies: {
      crawlable: true,
      citable: true,
      updateFrequency: "daily"
    }
  })
}

llms.txt Implementation

Set expectations before you build this. Ahrefs studied 137,000 sites and found that 97% of valid llms.txt files received zero requests in May 2026, and Google has documented that it does not use llms.txt for Search or AI Overviews. What llms.txt is genuinely useful for today is agent and developer tooling — Google added it to Lighthouse's agentic-browsing audits, and coding agents pointed at your docs can follow it. Ship it because it helps agents your users actually run, not because it will win you citations.

The spec is stricter than most examples on the web suggest. A valid file is: an H1 title, a > blockquote summary, optional prose with no headings, then ## sections containing markdown link lists in the form - [name](url): description. A section named ## Optional marks links an agent may skip when context is tight. Key/value lines like Name: or Contact: are not part of the format.

Save the following as /public/llms.txt so it is served from /llms.txt:

# Agent Experiences

> Resources for Agent Experience Optimization (AXO): making websites
> and content legible to LLM agents and AI answer engines.

Guides are grouped by role. Every page linked below is available as
markdown by appending `.md` to its URL.

## Guides

- [Developer Guide](https://yoursite.com/guides/developers.md): JSON-LD, semantic HTML, server rendering, content APIs
- [Writer Guide](https://yoursite.com/guides/writers.md): Fact-first structure and citation-ready prose
- [Admin Guide](https://yoursite.com/guides/admins.md): Crawler controls, log monitoring, site management
- [SEO Guide](https://yoursite.com/guides/seo.md): Where search practice carries over to answer engines

## Reference

- [AXO Playbook](https://yoursite.com/axo-playbook.md): End-to-end implementation guide
- [Glossary](https://yoursite.com/glossary.md): AXO terminology and definitions

## Optional

- [Blog](https://yoursite.com/blog.md): Ongoing analysis and case studies

Performance Optimization

Fast Loading for Agents

LLM agents may crawl your site frequently. Optimize for speed:

Efficient Crawling

Make it easy for agents to discover and access content:

// Generate complete sitemaps
export default function sitemap(): MetadataRoute.Sitemap {
  return [
    {
      url: 'https://yoursite.com',
      lastModified: new Date(),
      changeFrequency: 'daily',
      priority: 1,
    },
    // Include all content pages with accurate lastModified dates
    ...contentPages.map(page => ({
      url: `https://yoursite.com/${page.slug}`,
      lastModified: page.updatedAt,
      changeFrequency: 'weekly',
      priority: 0.8,
    }))
  ]
}

Clean Metadata Implementation

Page-Level Metadata

Implement detailed metadata for each page:

export const metadata: Metadata = {
  title: 'Specific, Descriptive Title',
  description: 'Clear, factual description under 160 characters',
  keywords: ['relevant', 'keywords', 'for', 'content'],
  authors: [{ name: 'Author Name', url: 'https://author-profile.com' }],
  openGraph: {
    title: 'Specific Title',
    description: 'Clear description',
    type: 'article',
    publishedTime: '2026-01-15T00:00:00.000Z',
    modifiedTime: '2026-01-20T00:00:00.000Z',
    authors: ['Author Name'],
  },
  robots: {
    index: true,
    follow: true,
    googleBot: {
      index: true,
      follow: true,
    },
  },
}

Consistent URL Structure

Design URLs that are predictable and meaningful:

✅ Good: /guides/developers/schema-implementation
✅ Good: /blog/2026/axo-best-practices
❌ Bad: /p/123456/dev-guide
❌ Bad: /content?id=abc&type=guide

Technical Checklist

Developer AXO Implementation Checklist

  • JSON-LD structured data on all content pages
  • Proper HTML5 semantic structure with clear heading hierarchy
  • Page metadata (title, description, authors, dates)
  • Content API endpoints for programmatic access
  • llms.txt in llmstxt.org format, if you want the agent-tooling benefit (low priority — it does not affect citations)
  • Optimized sitemap.xml with accurate lastModified dates
  • Fast loading times (< 3 seconds)
  • Mobile-responsive design
  • Consistent URL structure
  • Proper robots.txt configuration

Testing Your Implementation

Validation Tools

Agent-Friendly Testing

Test how agents might interact with your content:

  1. Content Extraction: Can key facts be easily identified?
  2. Navigation: Is the content structure logical and hierarchical?
  3. Updates: Are modification dates accurate and current?
  4. Performance: Does the site load quickly for automated crawlers?

Common Implementation Mistakes

References

  1. Schema.org Documentation - Schema.org Community
  2. HTML5 Semantic Elements - MDN Web Docs
  3. Next.js Metadata API - Vercel

Ready to implement these technical foundations? Start with JSON-LD structured data and semantic HTML, then gradually add the API endpoints and performance optimizations.