Agents can't read your website.
AgentRead serves every AI agent clean, scored Markdown while humans see your site untouched. Same content, a fraction of the tokens, one line of middleware.
1,000 free reads / month · no credit card · MCP server included
Speaks standard MCP — drops into any compatible client
Illustrative preview — see it running for real in the Playground.
The Render Tax
Most of what you ship isn't content.
Your site ships JavaScript bundles, CSS frameworks and tracking pixels to a reader that wants none of it. Agents pay for every token of that noise — then hallucinate around it. Example below: a typical e-commerce product page.
Raw HTML what the agent downloads
≈ 203,114 tokensper read. Prices hidden in JS-rendered spans. Buttons the model can't see. That's where hallucinations come from.
With AgentRead what the agent receives
Input cost per read drops from roughly $0.61 to $0.006 at $3/M tokens on this example. Multiply by every agent, every visit, every day.
less payload on this example — the render tax, refunded
Architecture
Read today. Serve today. Act next.
One engine under all three layers: read any site clean now, serve your own site agent-legible today, then let agents transact on it.
Read
REST API + remote MCP server that turns any URL into clean, scored Markdown — with an explainable ReadScore and hallucination-risk flags on every response.
For AI developers building agents
Serve
Next.js middleware that detects verified AI crawlers and serves them the same clean Markdown, while human visitors see your site completely unchanged. This site runs its own Serve middleware on itself — try curling it with a GPTBot user-agent.
For site owners & engineering teams — see the real snippet below
Act
The browser interaction layer. Agents stop scraping pixels and start executing intents — semantically, against the same clean structure they read. Not built yet — the honest label is "future," not a quarter we'd have to walk back.
For autonomous agents and the agent economy
Layer 2, for real
The actual middleware — not a package that doesn't exist yet.
No published npm package yet, so here's the real, working code instead of a fictional install command. Paste this into any Next.js site's middleware once you have an AgentRead API key.
import { NextResponse, type NextRequest } from "next/server";
const AI_CRAWLERS = ["GPTBot", "ChatGPT-User", "ClaudeBot", "PerplexityBot", "CCBot", "Bytespider"];
export async function middleware(request: NextRequest) {
const ua = request.headers.get("user-agent") ?? "";
if (!AI_CRAWLERS.some((c) => ua.includes(c))) return NextResponse.next();
const res = await fetch("https://agentread.dev/api/v1/read", {
method: "POST",
headers: {
Authorization: `Bearer ${process.env.AGENTREAD_API_KEY}`,
"Content-Type": "application/json",
},
body: JSON.stringify({ url: request.url }),
});
if (!res.ok) return NextResponse.next(); // never block a crawler on our own failure
const { markdown } = await res.json();
return new Response(markdown, { headers: { "content-type": "text/markdown" } });
}
export const config = { matcher: "/:path*" };MCP native
Speak MCP? Then you're already done.
One config block and any MCP-capable client can read and score the live web — with risk flags attached. Remote server, no local install required.
{
"mcpServers": {
"agentread": {
"url": "https://agentread.dev/api/mcp",
"headers": { "Authorization": "Bearer sk-ar-…" }
}
}
}What's in the box
Built for agents. Honest about what's next.
Everything below marked Live runs for real in this codebase today. Everything marked Roadmap is exactly that — not yet built, not pretending otherwise.
ReadScore Live
Every read returns a 0–100 score for how faithfully the Markdown represents the page an agent would act on — fully transparent, every deduction ships as a human-readable flag.
"readScore": 82Hallucination risk flags Live
JS-only prices, disabled buttons, missing content — flagged per read with severity, so your agent knows what not to trust.
"hallucinationRisk": "low"Serve middleware Live
Detects known AI crawlers and serves them Markdown instead of full HTML — see the real snippet above.
In-memory response cache
Repeat reads within 10 minutes return instantly from cache — no re-fetch, re-render, or re-score.
Batch & site maps Roadmap
batch reading many URLs in one call and map_site for a crawlable domain outline — not built yet.
Crawl Roadmap
Point at a domain, get the whole site as a clean Markdown corpus for RAG ingestion. Not built yet.
Watch Roadmap
Diff-based change detection with webhooks when a page's content changes. Not built yet.
llms.txt Studio Roadmap
Auto-generate and host your llms.txt / llms-full.txt. Not built yet.
Agent analytics Roadmap
See which agents read you and what they misread. Not built yet.
Pay-per-crawl Roadmap
Charge unverified AI crawlers per read instead of giving away content free. Not built yet.
Developer experience
Real endpoints. No fictional SDKs.
curl -X POST https://agentread.dev/api/v1/read \
-H "Authorization: Bearer $AGENTREAD_API_KEY" \
-H "Content-Type: application/json" \
-d '{"url": "https://example.com/pricing"}'
# → { "markdown": "# Pricing…", "readScore": 82,
# "hallucinationRisk": "low", "tokensAfter": 1942, "cache": "MISS" }Why not just use…
Why not just use Firecrawl?
Scrapers read other people's sites. AgentRead also fixes how your site is read — and is honest about which parts of that are live vs. roadmap.
| Capability | AgentRead | Firecrawl | Browserbase | Vercel / Cloudflare |
|---|---|---|---|---|
| Clean HTML → Markdown | ✓ | ✓ | — | edge only |
| Explainable ReadScore | ✓ | — | — | — |
| Hallucination risk flags | ✓ | — | — | — |
| Serve your own site to agents | ✓ any host | — | — | their infra only |
| Cached repeat reads | ✓ 10 min TTL | — | — | ✓ |
| Change tracking / Watch | roadmap | ✓ | — | — |
| Structured extraction | roadmap | ✓ | — | — |
| Browser interaction | Act · roadmap | actions | ✓ | — |
| Monetize agent traffic | roadmap | — | — | CF pilot |
Signal, not hype
The shift is already public.
External citations from PROJECT.md — not independently re-verified by this codebase, carried over as market-timing context.
"~99% payload reductionobserved" serving Markdown to agents from their own edge.
"<15 msnative HTML→MD at the edge" — conversion is becoming a network primitive.
Research showing context structure materially improves model accuracy on downstream tasks.
RFS calling for agent-economy infrastructure — the rails agents will read, pay and act through.
Free ReadScan — really live
How readable are you to agents? Find out for real.
This calls the live Read API right now — no demo data, no waitlist.
Pricing
Start free. Lock the founding price.
Billing isn't wired up yet — paid tiers below are the plan, join the waitlist to lock the rate when it ships.
For hacking on agents, tonight.
- 1,000 reads / month
- Real MCP server (read_url, score_url)
- ReadScores on every read
- Community support
Scale with your agents, not a seat count.
- Same bearer-auth endpoint, higher limits
- Batch, map_site & extract roadmap
- Crawl & Watch roadmap
Your site, perfectly readable by every agent.
- Serve middleware, any host — live today
- ReadScore monitoring & alerts roadmap
- llms.txt Studio roadmap
- Founding rate, forever
For platforms and publishers at agent scale.
- Pay-per-crawl monetization roadmap
- Dedicated regions, SSO, audit logs roadmap
- Early access to Act
FAQ
Questions, answered.
How is AgentRead different from Firecrawl?
Firecrawl reads other people's sites well, at scale, with funding AgentRead doesn't have. AgentRead reads too — with a ReadScore and hallucination flags Firecrawl doesn't have — but the differentiated bet is Layer 2: making your site serve clean Markdown to agents from real middleware (live today, not a roadmap promise), plus the ReadScore standard itself.
What exactly is a ReadScore?
A 0–100 measure computed from explainable signals: payload-reduction ratio, script count, price/CTA text present in raw HTML but missing from extracted text, disabled buttons, lazy content, and llms.txt presence. Every deduction ships as a flag — see the full formula on /docs.
Do I have to change my website?
No. The Serve layer is a small middleware snippet (shown above — real code, not a hypothetical). Human visitors get your site exactly as it is; verified AI crawlers get the Markdown twin.
What are hallucination risk flags?
Per-read warnings on things agents commonly get wrong: prices rendered only in client-side JavaScript, CTAs disabled in markup, very little extractable text. Your agent gets the flag alongside the Markdown, so it can hedge instead of confidently inventing an answer.
Which AI agents and crawlers are supported?
The Read API and MCP server work with anything that can call REST or MCP. The Serve layer currently recognizes 12known crawler user-agents (GPTBot, ClaudeBot, PerplexityBot, CCBot, Bytespider and others) — this list is reviewed against each vendor's published docs, not exhaustive or permanent.
When does Act ship?
No committed date — it's the least-scoped layer and the least honest thing we could do is promise a quarter. It builds on the same structure Read/Serve already produce, so agents already consuming AgentRead Markdown won't need to migrate when it lands.
Early access
Agents are already reading you.
Make sure they read you right.
Join the waitlist — founding price locked the day billing ships.