Agent-RankingIs your company ready for the AI agent revolution?
AI agents are starting to search, compare, and buy on behalf of people - and most businesses are invisible to them, because their websites are built for humans, not machines. Agent-Ranking scans your site and API, scores how agent-ready you are, then builds what's missing: an agents.json manifest, an llms.txt file, and an MCP wrapper around your API, thus making your site compatible with AI agents.
Generate an agents.json file and wrap the API as an MCP server.
The internet is splitting into a human web and an agent web.
For twenty years, the internet was built for one kind of visitor: a person, deciding what to click. That's changing. Personal and business agents are starting to do the searching, comparing, and buying - and they don't respond to branding. They respond to structure.
The human web
- Wins on persuasion - brand, copy, design
- Navigated through search results and clicks
- Trust built through reviews and reputation
- Buying is a multi-step, manual journey
The agent web
- Wins on structure - schemas, docs, permissions
- Navigated through APIs and machine-readable specs
- Trust built through identity and verifiable capability
- Buying is a direct, automated transaction
Beautiful, persuasive, and completely invisible to an agent.
These are three real e-commerce storefronts, doing exactly what a good human-facing storefront should do: bold hero banners, discount badges, product photography, carousels, urgency copy. None of that is wrong - it works on people. It just doesn't work on an agent, because an agent isn't looking at pixels. It's looking for structure it can parse, and none of the value on these pages is expressed as data.
Persuasion-first hero
A rotating banner, a discount badge, and a "Shop now" button - all communicated visually. An agent can't read a percentage off a graphic, or know what "Shop now" actually does without a link it can already guess.
Price and stock, as an image
Price, discount, and stock level are all real data here - $1800.99, 29% off, 180 in stock - but they're rendered as styled page content, not exposed anywhere an agent could query them directly.
Categories as pictures
"Free shipping," "secure payment," and a full catalog of categories are all here - but again, as copy and icons. An agent evaluating this business has to guess at capabilities a machine-readable manifest would just state.
The same business, described the way an agent needs it.
None of this requires giving up the storefront above - it requires publishing a second, parallel description of the business that a machine can read directly. This is what that looks like.
llms.txt - a plain-language summary
What the business is, and where to find everything else.
Company: Example Electronics Co
Summary: Consumer electronics - audio, smart home, gaming
Docs: https://example.com/docs
Pricing: https://example.com/pricing.json
MCP: https://example.com/.well-known/mcp
Product schema - price and stock as data
The same $59.99 and "in stock" from a product photo, machine-readable.
"@type": "Product",
"name": "Wireless Gaming Controller",
"sku": "WGC-2049",
"offers": {
"price": "59.99",
"availability": "InStock"
}
}
agents.json - what an agent can actually do
Not "Shop now" as a button - a callable action with a name.
"name": "Example Electronics Co",
"auth": "api_key",
"actions": [
{ "name": "search_products" },
{ "name": "add_to_cart" },
{ "name": "checkout" }
]
}
Agent Website Integration (AWI) is the new Search Engine Optimization (SEO).
In the 2000s, businesses that ignored search engine optimization became invisible to an entire generation of customers - ranking wasn't optional, it was the front door. Agent Website Integration (AWI) is the same shift one layer up: the audience deciding who gets found isn't a search algorithm reading keywords anymore, it's an AI agents ability to read structured data. The businesses that adapt early get discovered, cited, and recommended by agents. The ones that don't are as invisible to agents as an un-indexed site once was to Google.
SEO (2000s–2020s)
- Optimized for keyword rankings and backlinks
- Meta tags and page titles written for crawlers
- Success measured in search rank and click-through rate
- Won by matching what a ranking algorithm rewarded
AWI (now)
- Optimized for structured data an agent can parse and trust
- agents.json, llms.txt, and schema markup written for machine readers
- Success measured in whether an agent can find, use, and recommend you
- Won by exposing capabilities an agent can safely act on
From scan to fully remediated, in four steps.
Submit a URL and we handle the rest - from finding the gaps to shipping the fix.
Scan & analyze
We crawl your site, API, and docs to check for structured data, MCP support, and clear pricing.
Score & report
You get a readiness score broken down by category, with every gap explained in plain terms.
Generate the fix
We auto-generate your agents.json, llms.txt, schema markup, and an MCP wrapper around your API.
Deploy & sync
Once live, we re-scan on a schedule and keep everything current as your API and pricing change.
Two files and a wrapper - that's most of the gap.
Most companies are missing three specific things. Here's what each one is, and what we produce for you.
A plain-language summary for agents
Sits at your site root, like robots.txt. Gives an agent a fast, curated read on what you do and where your key docs live - instead of forcing it to scrape a marketing page built for humans.
Company: Acme Payroll
Summary: Payroll and contractor payments API
Docs: https://acme.com/docs
Pricing: https://acme.com/pricing.json
MCP: https://acme.com/.well-known/mcp
Contact: agents@acme.com
A capability manifest for agents
Structured JSON describing exactly what an agent can do here - which actions, what's required to authenticate, and any limits - so nothing has to be guessed from a webpage.
"name": "Acme Payroll",
"auth": "oauth2",
"actions": [
{ "name": "create_payment_run" },
{ "name": "get_contractor" }
],
"rate_limit": "120/min"
}
Wrapping your API as an MCP server
If you already have an OpenAPI spec, we map every endpoint to a callable tool an agent can invoke directly - no scraping, no guessing.
See what a full evaluation looks like.
Browse a sample readiness report, or submit your own site to get started.