ASM · ACP · LEAN

Three specs for the agentic web,delivered in one file.

Two questions every site owner needs to answer:

1.
Will your site still work when there is no screen and no human?
2.
Can you allow autonomous agents to transact while still blocking unwanted traffic?

robots.txt cannot answer either question. Its entire vocabulary is an allow or deny rule per user-agent and path, so it cannot express a rate limit, a conditional permission, or the actions a site supports. It is also non-binding on exactly the traffic that matters most: two of the three major AI vendors document that their user-directed fetchers may or do ignore it.

One file, two blocks, everything an agent needs

Deploy /.well-known/agents.json and every agent on the internet can discover your site and call your APIs, with no SDK, no local server and no context injection at startup.

/.well-known/agents.json

{
  "version": "1.0",
  "site": {
    "name": "...",
    "description": "...",
    "capabilities": { ... },
    "navigation": { ... }
  },             // ASM: site-level manifest
  "services": {
    "name": "...",
    "auth": { ... },
    "tools": [ ... ]
  }              // ACP: service-level protocol
}

A website with no API only needs the site block, a headless API only needs the services block, and a full product carries both.

Spec	Full Name	Scope	Deliverable
ASM	Agent Site Manifest	Site-level	site block in agents.json
ACP	Agent Context Protocol	Service-level	services block in agents.json
LEAN	Layered Efficiency for Agentic Navigation	Design philosophy	Guides authoring of both

ASM

Agent Site Manifest

Site-level · the site block

ASM tells agents what your site is, what it offers, and how to behave. It replaces the guesswork agents currently do (fetching your homepage, parsing navigation, inferring capabilities) with a single structured declaration.

Traffic Governance

A three-tier model that goes beyond the binary allow or block of robots.txt:

Tier 1Training Crawlers: Bulk content harvesters. Governed by robots.txt as before.

Tier 2Agentic Visitors: Agents acting on behalf of users. Allowed to browse, compare, transact.

Tier 3Automated Services: Machine-to-machine integrations. Full API access with rate limits.

Scoring Framework

ASM includes a measurement system that scores agent-readiness across six weighted dimensions, ordered so that a site failing Content Survivability cannot score well on anything downstream.

Content Survivability: 25%; Does content exist without JavaScript?

Structural Legibility: 20%; Can agents parse the page layout from the DOM?

Interactive Manifest Clarity: 20%; Can agents find and invoke your CTAs?

Data Extractability: 15%; Is business data in semantic, parseable HTML?

Navigation Traversability: 10%; Can agents explore via static links?

Agent Response Fitness: 10%; Does the text stream tell a coherent story?

Read the ASM Spec See Audit Case Studies

ACP

Agent Context Protocol

Service-level · the services block

ACP defines how services advertise their capabilities to AI agents. Instead of requiring agents to run local adapter servers, the service hosts a structured manifest that agents fetch at runtime before calling the API directly over HTTPS.

No local server process
No SDK dependency
No context injection at startup
No resource overhead between tasks

The service bears the cost of describing itself rather than pushing it onto the agent, and one JSON file is enough for every agent on the internet to consume it.

services block

"services": {
  "name": "Your API",
  "base_url": "https://api.example.com/v1",
  "auth": {
    "type": "bearer",
    "instructions": "API key as Bearer token."
  },
  "tools": [
    {
      "id": "do_thing",
      "description": "Does the thing.",
      "endpoint": "/thing",
      "method": "POST",
      "input": {
        "type": "object",
        "required": ["name"],
        "properties": {
          "name": { "type": "string" }
        }
      }
    }
  ]
}

The Cost Inversion

The current model for agent-service integration requires agents to run a local server for every service they use. Each server injects tool definitions into the agent's context window, consumes local resources, and has to be maintained by the consumer. ACP inverts this.

Comparison	MCP	ACP
Who runs the adapter?	The agent (consumer)	Nobody. It is a JSON file.
Tool definitions live...	Injected into context at startup	Fetched on demand from service
What runs locally?	A server process per service	Nothing
Who maintains it?	The consumer	The service provider
Scaling to 50 services?	Poorly	Same as 1 service

ACP does not replace MCP for local tools (file system, databases, IDE integration), private integrations behind firewalls, or use cases requiring persistent bidirectional connections. For public services with REST APIs, ACP is simpler.

Read the ACP Spec

LEAN

Layered Efficiency for Agentic Navigation

Design philosophy · guides authoring of both ASM and ACP

Every token an agent carries costs money and displaces reasoning capacity, so LEAN replaces “send everything, let the agent filter” with “send the minimum, let the agent expand.”

Five Principles

1
Default Minimal
Initial responses contain the smallest useful representation.
2
Depth on Demand
Full details remain one request away, never forced.
3
Reversible Depth
Agents can expand and contract their context.
4
Layer Independence
Detail at one layer does not force breadth at another.
5
State Consistency
Expanding or contracting never corrupts state elsewhere.

Four Layers

Tool Availability: What tools are loaded; Start with a minimal set, activate more at runtime.

Content Resolution: How much detail the agent sees; Orientation first, drill into full detail on demand.

Element Resolution: How the agent finds targets; Semantic search returns matches, not catalogs.

Response Resolution: What comes back after an action; Structural diffs, not full state re-sends.

Tool definition overhead reduction (Layer 1 alone): ~48%

Tokens saved across 100-page, 550-call session: 1.9M

Fewer tokens vs traditional tool servers in multi-layer scenarios: 5 to 10x

See Charlotte, the open-source reference implementation, for LEAN applied across all four layers.

Read the LEAN Spec

Quick start: five minutes to Level 1

Create /.well-known/agents.json with your site's basic information and agents can discover you from that one file.

/.well-known/agents.json

Level 1: copy and edit

{
  "version": "1.0",
  "site": {
    "name": "Your Site Name",
    "description": "What your site does in one sentence.",
    "primary_language": "en",
    "contact": "https://yoursite.com/contact",
    "capabilities": {
      "actions": [
        {
          "id": "contact",
          "description": "Send a message via contact form.",
          "entry_point": "/contact",
          "method": "form_submit"
        }
      ]
    },
    "navigation": {
      "sections": [
        { "name": "Home", "path": "/" },
        { "name": "About", "path": "/about" },
        { "name": "Services", "path": "/services" }
      ],
      "sitemap": "/sitemap.xml"
    },
    "access": {
      "public_content": true
    },
    "agent_policy": {
      "tier2_allowed": true,
      "tier3_allowed": true,
      "crawl_delay_seconds": 1,
      "max_requests_per_minute": 30
    }
  }
}

1
Create the file
2
Fill in your details
3
Deploy it to /.well-known/

Related Tooling

The reference implementation our founder builds and maintains against these specs.

Open Source

Charlotte

An MCP server that turns web pages into structured, text-native representations for AI agents, and our reference implementation for LEAN across all four layers.

Is Your Infrastructure Agent-Ready?

Enter your domain and we will run a free Level 1 compliance check against the ASM spec.

Request a Full Audit See Our Case Studies