The DOM was never meant to be an API. Stop treating it like one.

Websites declare capabilities. Agents that can follow them, do. The rest reveal themselves.

This site publishes a machine-readable contract at agent.json
See it work View test results

We tested 8 AI agents against this contract

Real agents. Real contract. Standardized prompt. Here's what happened.

50%
Successfully fetched contract
100%
Constraint compliance (of those that fetched)
0
Hallucinations from compliant agents

Same product. Two ways to see it.

Click refresh. Watch the left side change. Watch the right side not.

DOM Scraping Heuristics
Coffee

Ethiopian Dark Roast

$14.99
42 in stock
IntentQL Contract Contract
Coffee

Ethiopian Dark Roast

$14.99
42 in stock
0
DOM changes
0
API changes

This is what AI agents deal with. Every redesign. Every A/B test.

The left side is what breaks AI browsers today.

Every website redesign. Every A/B test. Every dynamic load. The agent parses HTML, guesses at selectors, retries when it fails.

This is how browser copilots, shopping agents, and every automation tool works right now. It doesn't scale. It can't.

Agents don't need better eyes. They need an API.

IntentQL is a simple proposal: websites publish an /agent.json file declaring what they can do. Agents read the contract and call stable endpoints. The UI becomes irrelevant to automation.

But here's what we learned from testing: Contracts don't enforce compliance — they filter for it. Agents that read the contract respected every constraint. Agents that couldn't fetch it failed gracefully or revealed themselves as incapable.

That's the real value. Not universal compliance. Visible capability.

Three moving parts

The contract

/agent.json

A machine-readable file declaring what the site can do. Intents, endpoints, parameters, constraints.

GET /agent.json
The endpoints

Stable APIs

Normal REST endpoints that do the work. Search products, check stock, get details. No DOM required.

GET /api/products
The UI

For humans only

The website looks however you want. Redesign freely. Agents don't care — they're not looking at it.

/* whatever */

Everyone wins differently

Agents

Clear declarations instead of guessing. Agents that read contracts succeed. Agents that don't, fail visibly. Know which is which.

Site owners

See which agents can follow instructions — and which can't. Audit your agent-readiness. Redesign your UI without breaking capable integrations.

Enterprise

Contracts, not heuristics. Audit trails showing what was declared and what was attempted. The kind of evidence procurement and legal require.

Not ready for the full spec?

Just publish what you don't support. Even a constraints-only contract reduces hallucinations.

{
  "constraints": {
    "no_price_filtering": true,
    "no_checkout": true,
    "no_customer_data": true,
    "no_inventory_guarantees": true
  },
  
  "rules": [
    "Do not assume real-time pricing",
    "Do not promise shipping availability",
    "Do not invent product attributes"
  ]
}

No endpoints. No intents. Just boundaries. If agents read it, they'll know your limits. If they don't, you'll know they're not ready.

This is going to happen.

The only question is whether it's open or proprietary.