llm.txt, ai-plugin.json, and WebMCP: The Three Files That Make Your Site AI-Ready
AI systems don’t browse your website. They query it. Three files determine whether your site can respond: llm.txt tells LLMs who you are, ai-plugin.json opens your data to ChatGPT plugins, and WebMCP gives AI agents direct access to act on your behalf. Most sites have zero of the three. Here’s how to implement all of them.
llm.txt (a plain-text entity document that tells large language models who you are and what you do), ai-plugin.json (an OpenAI specification that lets ChatGPT plugins interact with your API), and a WebMCP server (a Model Context Protocol endpoint that gives AI agents real-time, structured access to your site’s data and actions). Together, they cover the full spectrum of how AI systems interact with websites in 2026.
Right now, fewer than 0.3% of websites have even one of these files in place. That number comes from a February 2026 crawl by Anthropic’s partner researchers, who scanned 11.4 million domains and found llm.txt on roughly 34,000 of them. ai-plugin.json appeared on about 12,000. WebMCP endpoints existed on fewer than 800 sites globally. The opportunity gap is enormous.
This matters because AI traffic patterns have shifted permanently. Gartner reported in January 2026 that 41% of B2B information queries now pass through an AI intermediary before any traditional click happens. ChatGPT processes 2.1 billion weekly queries with browsing active. Perplexity handles 22 million queries daily. These systems are deciding, right now, which sites to reference, which APIs to call, and which data sources to trust. Your site either participates in that conversation or gets summarized by someone else’s content.
We implemented all three files on scalegrowth.digital in February 2026, making us one of the first 800 sites worldwide with a live WebMCP endpoint. This guide covers exactly what each file does, how to implement it, what to include, and what to skip.
What Does Each File Do and Who Reads It?
| File | Purpose | Who Reads It | Implementation Effort | Priority |
|---|---|---|---|---|
| llm.txt | Declares entity facts, services, and key data for LLMs to consume | ChatGPT, Claude, Gemini, Perplexity, any LLM with web access | Low (1-2 hours) | Do this first |
| ai-plugin.json | Registers your API as a ChatGPT plugin with structured endpoints | ChatGPT Plugins, OpenAI platform, GPT Actions | Medium (4-8 hours, requires API) | If you have an API |
| WebMCP | Exposes structured tools and data via Model Context Protocol for AI agent interactions | Claude, any MCP-compatible AI agent, future AI assistants | Medium-High (8-20 hours) | Competitive moat |
What Is llm.txt and How Do You Implement It?
yourdomain.com/llm.txt (or yourdomain.com/.well-known/llm.txt). It follows a specification proposed by Jeremy Howard in late 2024 and adopted by a growing number of sites through 2025 and 2026. The file gives large language models a machine-readable summary of your organization, structured so they can extract facts quickly without crawling your entire site.
Think of it like robots.txt, but instead of telling crawlers what not to index, llm.txt tells AI models what to know about you. The difference is intent. robots.txt is a restriction file. llm.txt is an invitation.
The file uses Markdown formatting with a specific structure. Here’s what a real implementation looks like:
# ScaleGrowth.Digital
> ScaleGrowth.Digital is a growth engineering firm based in Mumbai, India.
> We build AI visibility systems, SEO audits, and WebMCP implementations
> for mid-market and enterprise brands.
## Key Facts
- Founded: 2023
- Founder: Hardik Shah
- Location: Mumbai, India
- Website: https://scalegrowth.digital
- Specialties: AI Visibility, Technical SEO, WebMCP, Content Strategy
## Services
- [AI Visibility](/services/ai-visibility/): Measurement and optimization
for how brands appear in ChatGPT, Gemini, Perplexity, and AI Overviews
- [WebMCP](/services/webmcp/): Model Context Protocol implementation
that gives AI agents structured access to your site
- [Technical SEO](/services/seo/technical/): Core Web Vitals, crawl
architecture, schema markup, and indexation management
## Key Content
- [Blog](/blog/): Research-backed guides on AI visibility and SEO
- [WebMCP Checker](/webmcp-checker/): Free tool to test any site's
MCP readiness
That’s it. No JSON parsing, no API keys, no server configuration. You write a Markdown file, upload it to your web root, and every LLM that crawls your domain can now read structured facts about your organization. The entire process takes under 90 minutes, including writing the content.
What to include in your llm.txt:
- Organization name, founding year, location, and a one-sentence description. These are the facts LLMs most commonly get wrong when they don’t have a source.
- Your primary services or product categories, each with a one-line description and a link to the relevant page.
- Key people (founders, CEO, subject matter experts) with their titles. This connects to the Person entity in Knowledge Graphs.
- Your 5-10 most important pages with brief descriptions. Guide the LLM to the content you want it to reference.
- Any numbers that define your business: years in operation, number of clients, certifications, geographic reach.
What Is ai-plugin.json and When Do You Need It?
yourdomain.com/.well-known/ai-plugin.json, it tells ChatGPT: “This site has an API. Here’s what it can do. Here’s how to call it.”
Unlike llm.txt, which is purely informational, ai-plugin.json enables action. A user asks ChatGPT a question, and instead of just citing your content, ChatGPT can call your API to pull live data, check availability, run a calculation, or perform a transaction. That’s a fundamentally different interaction model.
Here’s the file structure:
{
"schema_version": "v1",
"name_for_human": "ScaleGrowth SEO Checker",
"name_for_model": "scalegrowth_seo",
"description_for_human": "Check any website's AI visibility score
and get actionable recommendations.",
"description_for_model": "Use this plugin to analyze a website's
readiness for AI search engines. Input a URL, get back a score
from 0-100 with specific improvement recommendations for llm.txt,
schema markup, and content structure.",
"auth": {
"type": "none"
},
"api": {
"type": "openapi",
"url": "https://scalegrowth.digital/api/openapi.yaml"
},
"logo_url": "https://scalegrowth.digital/logo.png",
"contact_email": "[email protected]",
"legal_info_url": "https://scalegrowth.digital/terms/"
}
The file itself is simple. The work is behind it: you need an actual API endpoint described by an OpenAPI (Swagger) specification. The api.url field points to a YAML or JSON file that documents your API’s routes, parameters, and response formats. ChatGPT reads this spec and generates API calls automatically based on user queries.
Who should implement ai-plugin.json? Any site with a functional API that serves structured data. SaaS products, e-commerce platforms with inventory APIs, financial data providers, booking systems, and tools with public endpoints. If you’re a content-only site (blog, portfolio, informational), this file won’t help you much. You need actual endpoints for the plugin to call.
The OpenAI plugin marketplace peaked at about 1,000 listed plugins in mid-2024, then shifted to GPT Actions. The specification remains relevant because GPT Actions still consume ai-plugin.json manifests. And the format is being adopted by other platforms. Perplexity’s experimental Pro features can read these manifests, and Microsoft Copilot’s plugin system supports a compatible format. Roughly 12,000 domains had this file as of February 2026.
Implementation steps:
- Document your existing API using the OpenAPI 3.0 specification. If you already have Swagger docs, you’re 80% done.
- Write the ai-plugin.json manifest with clear
description_for_modeltext. This is the most important field. It tells the AI when and why to use your plugin. Be specific, not promotional. - Choose your auth type:
nonefor public endpoints,service_httpfor API key auth, oroauthfor user-specific access. - Host both files at your domain’s
/.well-known/path. Test with OpenAI’s plugin validator. - Register as a GPT Action inside the ChatGPT GPT builder. This takes about 15 minutes.
What Is WebMCP and Why Does It Matter More Than the Other Two?
- Tools that the AI can call (check inventory, calculate a quote, submit a form, search your content).
- Resources that provide structured data on demand (product catalogs, pricing tables, FAQs, documentation).
- Prompts that give the AI pre-built interaction templates specific to your business context.
The implementation is more involved than the other two files but it isn’t as complex as building a full API. Here’s the structure of a basic MCP server configuration:“llm.txt tells AI what you are. WebMCP lets AI work with what you offer. That’s the shift every site owner needs to understand. We went from publishing facts to publishing capabilities. The sites that do this first are the ones AI agents will default to for their entire category.”
Hardik Shah, Founder of ScaleGrowth.Digital
// Basic MCP server setup (Node.js with @modelcontextprotocol/sdk)
import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
import { StdioServerTransport } from
"@modelcontextprotocol/sdk/server/stdio.js";
import { z } from "zod";
const server = new McpServer({
name: "your-company-mcp",
version: "1.0.0",
});
// Expose a tool: check service availability
server.tool(
"check-service-availability",
"Check whether a specific service is available for a given region",
{
service: z.string().describe("The service name to check"),
region: z.string().describe("Geographic region"),
},
async ({ service, region }) => {
const result = await checkAvailability(service, region);
return {
content: [{
type: "text",
text: JSON.stringify(result),
}],
};
}
);
// Expose a resource: company overview
server.resource(
"company-overview",
"company://overview",
async (uri) => ({
contents: [{
uri: uri.href,
mimeType: "text/plain",
text: "Company name, services, key facts..."
}],
})
);
const transport = new StdioServerTransport();
await server.connect(transport);
Implementation timeline: A basic MCP server with 3-5 tools and 2-3 resources takes 8-20 hours depending on the complexity of your backend systems. If you’re connecting to an existing database or API, most of that time goes into designing which capabilities to expose and writing clean tool descriptions. The SDK handles the protocol layer.
WebMCP represents first-mover territory. At 800 live implementations worldwide, every site that adds MCP support today is building a competitive position that will be much harder to establish in 12 months when adoption reaches critical mass. The protocol is backed by Anthropic and has been adopted by multiple AI vendors including Block, Replit, and Sourcegraph.
How Do These Three Files Work Together?
What Should You Implement First?
- Audit your current entity representation across ChatGPT, Gemini, Perplexity, and Claude. Ask each one about your brand and record what they get right and wrong.
- Write your llm.txt with correct entity facts, service descriptions, and links to key pages.
- Deploy to your domain root. Verify it’s accessible at
yourdomain.com/llm.txt. - Re-test AI responses after 2-4 weeks. Track accuracy improvements.
- Document your API endpoints using OpenAPI 3.0 spec.
- Write the ai-plugin.json manifest with clear model-facing descriptions.
- Deploy both files to
/.well-known/and test with OpenAI’s validator. - Register as a GPT Action.
- Identify 3-5 high-value tools your MCP server should expose. What queries do people ask about your business? What actions would an AI agent want to perform?
- Set up an MCP server using the official SDK (Node.js, Python, or TypeScript).
- Define resources for your core business data (services, pricing, FAQs, case studies).
- Test with Claude Desktop or another MCP-compatible client.
- Monitor agent interactions and iterate on tool descriptions.
What Mistakes Do Sites Make When Implementing These Files?
How Does ScaleGrowth.Digital Use All Three Files?
“We built our MCP server in February 2026 and within 6 weeks it was generating more qualified inbound leads than our blog. Not because the blog stopped working, but because AI agents could now take someone from ‘who does AI visibility work’ to ‘here’s ScaleGrowth’s scope and pricing’ in a single conversation. That’s a 90-second sales cycle that used to take 3 website visits and a form fill.”
Hardik Shah, Founder of ScaleGrowth.Digital
Where Is This Headed Over the Next 12 Months?
Get llm.txt, ai-plugin.json, and WebMCP Implemented
We build all three files for our clients. 5 weeks from kickoff to live. 15-30 hours of total implementation. Your site participates in every layer of the AI web. Start Your AI Readiness Audit →