TL;DR: When someone asks ChatGPT “best plumber in San Diego,” will your client’s website get cited? Probably not—unless the site is structured for AI consumption. We built a system that automatically generates llms.txt, ai.txt, FAQ schemas, and AI-friendly robots.txt files for every website we create. Every generated site is instantly discoverable by GPT, Claude, Perplexity, and 15+ other AI crawlers.

The Shift Nobody’s Talking About

Google gets 8.5 billion searches per day. But increasingly, people are asking AI instead:

• “Find me a contractor near me who does kitchen remodels”
• “What’s the best restaurant in [city] for a date night?”
• “Compare electricians in my area”

These queries go to ChatGPT, Claude, Perplexity, You.com, and Google’s AI Overviews. The answers come from websites—but not all websites. AI systems prefer structured, machine-readable content.

If your website is just pretty HTML with no semantic structure, AI systems skip it. They can’t reliably extract your services, hours, contact info, or differentiators.

We decided to fix this for every website we generate.

What We Build: The AEO Stack

Every website generated on WebZum automatically gets these files:

/llms.txt           → AI-friendly business summary
/llms-full.txt      → Extended context for deeper queries
/ai.txt             → AI agent permissions and guidelines
/robots.txt         → Explicit AI crawler access rules
+ FAQ Schema        → Structured Q&A in JSON-LD
+ HowTo Schema     → Step-by-step process markup
+ LocalBusiness     → Schema.org entity data

No setup required. No configuration. It just happens during website assembly.

1. llms.txt — The AI-Readable Business Card

The llms.txt specification is a plain Markdown file that tells AI systems about your business. It’s like robots.txt but for content, not crawling permissions.

We generate it from the business research we’ve already collected:

export function generateLlmsTxt(data: LlmsTxtData): string {
  const { businessResearch, websiteStrategy, websiteUrl, pages } = data;

  let content = `# ${businessResearch.businessName}\n\n`;
  content += `> ${businessResearch.businessName} is a ${businessResearch.businessType}`;

  if (businessResearch.location) {
    content += ` located in ${businessResearch.location}`;
  }

  // Services
  if (businessResearch.services?.length) {
    content += `\n\n## Services\n`;
    businessResearch.services.forEach(s => content += `- ${s}\n`);
  }

  // Service areas (critical for local AI queries)
  if (businessResearch.serviceAreas?.length) {
    content += `\n\n## Service Areas\nWe serve: ${areas.join(', ')}\n`;
  }

  // Contact info, reviews, hours...
  return content;
}

Why this matters: When someone asks Perplexity “plumbers in San Diego that do emergency calls,” Perplexity can parse llms.txt in milliseconds and extract exactly what it needs: services, areas served, hours, and unique selling points.

We also generate llms-full.txt with extended context—company history, competitive positioning, industry trends—for AI systems that want deeper understanding.

2. ai.txt — Permissions for AI Agents

The ai.txt specification is emerging as the standard for telling AI agents what they can and can’t do with your business info:

export function generateAiTxt(data: AiTxtData): string {
  return `
Business-Name: ${data.businessResearch.businessName}
Business-Type: ${data.businessResearch.businessType}
Location: ${data.businessResearch.location}
Canonical-URL: ${data.websiteUrl}

# Permissions
Allow-Recommendations: yes
Allow-Actions: no
Allow-Information-Sharing: yes
Allow-Citation: yes
Allow-Training: yes

# Contact Preferences
Preferred-Contact-Method: ${preferredMethod}
Phone: ${phone}
Business-Hours: ${hours}

# Restrictions
Do-Not: Make price commitments without verification
Do-Not: Impersonate business employees
Do-Not: Share non-public information
  `.trim();
}

The key permission: Allow-Recommendations: yes tells AI systems “Yes, recommend this business when relevant.” Allow-Actions: no means “Don’t try to book appointments or place orders on the user’s behalf.”

This is governance for the AI age. As AI agents start taking actions (booking, purchasing), businesses need to declare what’s allowed.

3. robots.txt — Welcoming AI Crawlers

Most robots.txt files were written for Googlebot. They accidentally block AI crawlers. We explicitly welcome them:

// We support 15+ AI crawler user-agents
const AI_CRAWLERS = [
  'GPTBot', 'ChatGPT-User', 'OAI-SearchBot',    // OpenAI
  'Claude-Web', 'ClaudeBot', 'anthropic-ai',      // Anthropic
  'PerplexityBot',                                  // Perplexity
  'Google-Extended',                                // Google AI
  'YouBot',                                         // You.com
  'cohere-ai',                                      // Cohere
  'Applebot-Extended',                              // Apple Intelligence
  'meta-externalagent',                             // Meta AI
  'Amazonbot',                                      // Amazon/Alexa
  'AI2Bot',                                         // Allen AI
];

// Each gets explicit access to AEO files
crawlers.forEach(crawler => {
  rules += `User-agent: ${crawler}\nAllow: /\n`;
  rules += `Allow: /llms.txt\nAllow: /llms-full.txt\nAllow: /ai.txt\n\n`;
});

We also block known bad actors (scrapers, spam bots) while welcoming legitimate AI systems. The distinction matters—you want ChatGPT to cite your business, not a content scraper to steal your copy.

4. FAQ Schema — The Answer Engine’s Best Friend

AI systems love FAQ schemas. When they’re deciding how to answer “What does [business] offer?”, structured FAQ data is the easiest to parse and cite:

export function generateFaqSchema(data: FaqSchemaData): object {
  const faqs = [];

  // Auto-generate from business data
  if (data.services?.length) {
    faqs.push({
      question: `What services does ${data.businessName} offer?`,
      answer: `${data.businessName} offers: ${data.services.join(', ')}.`
    });
  }

  // Industry-specific FAQs
  if (isHomeServices(data.businessType)) {
    faqs.push(
      { question: 'Do you offer free estimates?', answer: '...' },
      { question: 'Are you licensed and insured?', answer: '...' },
      { question: 'Do you handle emergency calls?', answer: '...' }
    );
  }

  return {
    '@context': 'https://schema.org',
    '@type': 'FAQPage',
    'mainEntity': faqs.map(faq => ({
      '@type': 'Question',
      'name': faq.question,
      'acceptedAnswer': { '@type': 'Answer', 'text': faq.answer }
    }))
  };
}

We generate industry-specific FAQs for restaurants, home services, healthcare, beauty, retail, fitness, and professional services. A plumber’s FAQ is different from a salon’s FAQ—and AI systems know the difference.

5. Entity Disambiguation with Schema.org

The hardest problem in AI discovery: there are 50 businesses named “ABC Plumbing.” How does an AI system know which one you mean?

We use sameAs links for entity disambiguation:

{
  "@type": "Plumber",
  "name": "Just Plumbing San Diego",
  "sameAs": [
    "https://www.facebook.com/justplumbingsd",
    "https://www.yelp.com/biz/just-plumbing-san-diego",
    "https://www.google.com/maps/place/..."
  ]
}

When an AI sees the same entity referenced across multiple authoritative sources, it gains confidence. “Just Plumbing San Diego” isn’t a made-up entity—it exists on Facebook, Yelp, and Google Maps.

The Assembly Pipeline

All of this happens automatically during our website generation assembly step:

// During website assembly (assembly-step.ts)
const llmsTxt = generateLlmsTxt({ businessResearch, websiteStrategy, websiteUrl, pages });
await storage.writeText('llms.txt', llmsTxt);

const llmsFullTxt = generateLlmsFullTxt({ businessResearch, websiteStrategy, websiteUrl, pages });
await storage.writeText('llms-full.txt', llmsFullTxt);

const aiTxt = generateAiTxt({ businessResearch, websiteUrl, allowRecommendations: true });
await storage.writeText('ai.txt', aiTxt);

const robotsTxt = generateRobotsTxt({ businessResearch, websiteUrl });
await storage.writeText('robots.txt', robotsTxt);

// Schema markup goes inline in each HTML page
const faqSchema = generateFaqSchema({ businessResearch });
const localBusinessSchema = generateLocalBusinessSchema({ businessResearch });

Zero configuration. Every business gets the full AEO stack.

Why This Matters Now

The AI search market is growing fast. Perplexity alone processes millions of queries daily. ChatGPT with browsing is becoming a default behavior. Google’s AI Overviews appear on 30%+ of searches.

Businesses that aren’t structured for AI consumption are invisible to this traffic. It’s not about gaming an algorithm—it’s about making your information parseable.

A well-structured llms.txt file isn’t manipulation. It’s accessibility. You’re making your business information available in a format AI systems can reliably read.

The Competitive Advantage

Most website builders don’t generate any of this. They give you a pretty page and hope Google’s crawler figures it out. That worked in 2020.

In 2026, your website needs to speak two languages:

1. Human — Beautiful design, clear copy, intuitive navigation
2. AI — Structured data, plain-text summaries, explicit permissions, semantic markup

We generate both simultaneously. Every WebZum site is designed for humans and parseable by machines.

How Does Your Business Score?

We built a free tool that evaluates any business across all 6 AEO dimensions: AI Discoverability, Structured Data, Entity Clarity, Content Answerability, Trust & Authority, and Voice Readiness.

Check Your AEO Score Free →

Most small businesses score between 20-45 out of 100. Every WebZum site starts at 90+.

Try It

Visit any WebZum-generated site and check:

• /llms.txt — AI-readable business summary
• /ai.txt — AI agent permissions
• View source → <script type="application/ld+json"> — Structured data

Then ask ChatGPT or Perplexity about that business. The difference is measurable.

---

Want to see where you stand? Get your free AEO Score — we evaluate your site across the same 6 dimensions we optimize automatically.