ANIP – open protocol so websites can talk directly to AI agents

An open standard for websites to speak directly to AI agents.

The web was designed for humans. Buttons, menus, forms — all built so a person with eyes and a mouse can navigate them.

AI agents can use these interfaces, but it's inefficient. An agent trying to book a flight or send an email has to scrape HTML, guess at form fields, and handle visual layouts that carry no meaning to a machine.

ANIP is the missing layer.

Any website can add a single file at /.well-known/anip.yaml

that describes, in structured machine-readable form, exactly what the site can do and how to call it. AI agents can discover this file, understand the site's capabilities, and act — without scraping, without custom integrations, without reading documentation.

It is to AI agents what HTML is to web browsers: a universal format that lets any agent understand any site.

anip: "0.1"

site:
  name: Your Site
  description: A brief description of what your site does.
  url: https://yoursite.com

capabilities:
  - id: search-products
    name: Search Products
    description: Search the product catalog by keyword or category.
    intents:
      - search for products
      - find items in the store
      - browse product catalog
    endpoint:
      url: https://yoursite.com/api/products/search
      method: GET
      type: rest
    auth:
      type: none
    input:
      type: object
      properties:
        q:
          type: string
          description: Search query
        limit:
          type: integer
          description: Maximum results to return
    output:
      type: object
      properties:
        products:
          type: array
          description: Matching products
        total:
          type: integer
          description: Total result count
    tags: [ecommerce, search, free, no-auth]
python
import httpx, yaml

resp = httpx.get("https://yoursite.com/.well-known/anip.yaml")
doc = yaml.safe_load(resp.text)

for cap in doc["capabilities"]:
    if any("search" in intent for intent in cap["intents"]):
        result = httpx.get(cap["endpoint"]["url"], params={"q": "laptop", "limit": 5})
        print(result.json())
        break

That's it. No custom SDK. No API key hunt. No documentation reading.

The full specification lives in spec/ANIP-1.md.

Key design choices:

One well-known URL. Always/.well-known/anip.yaml

. Agents know where to look.YAML. Human-readable. Any developer can write and review it.Intent-based discovery. Capabilities are described by what agentswant to do, not by endpoint paths.Protocol-agnostic. Works with REST, MCP, GraphQL, or gRPC.Backwards compatible. Adding ANIP to your site doesn't change your existing API at all.No central authority. Any site publishes its own document. No registration required.

anip/
├── spec/
│   ├── ANIP-1.md              # Core protocol specification
│   ├── ANIP-2.md              # Registry protocol (optional, for discoverability)
│   └── anip.schema.json       # JSON Schema for validation
│
├── reference-implementations/
│   ├── python/                # Python library (pip install anip)
│   ├── typescript/            # TypeScript library (npm install anip)
│   └── go/                    # Go library (go get github.com/anip-protocol/anip-go)
│
├── tools/
│   └── cli/anip.py            # CLI: validate, check, fetch, scaffold
│
├── examples/
│   ├── website-integration/   # How to add ANIP to your site
│   ├── agent-client/          # How agents use ANIP
│   └── mcp-bridge/            # Using ANIP with MCP servers
│
└── rfcs/                      # Proposals for spec changes

Step 1: Create /.well-known/anip.yaml

(or run python tools/cli/anip.py scaffold

)

Step 2: Serve it. Most web servers do this automatically. For nginx:

location /.well-known/ {
    alias /var/www/well-known/;
    add_header Access-Control-Allow-Origin *;
}

Step 3: Validate it:

pip install pyyaml
python tools/cli/anip.py validate ./anip.yaml

Step 4: Check it's live:

python tools/cli/anip.py check yourdomain.com

Done. Your site now speaks to AI agents.

pip install pyyaml httpx
python
import asyncio
import httpx
import yaml

async def discover_and_call(site: str, goal: str):
    async with httpx.AsyncClient() as client:
        resp = await client.get(f"https://{site}/.well-known/anip.yaml")
        doc = yaml.safe_load(resp.text)

        for cap in doc["capabilities"]:
            if any(goal.lower() in intent.lower() for intent in cap["intents"]):
                print(f"Found: {cap['name']} at {cap['endpoint']['url']}")
                return cap

asyncio.run(discover_and_call("open-meteo.com", "weather forecast"))

Or use the Python reference implementation:

pip install anip
python
from anip import fetch_sync

doc = fetch_sync("open-meteo.com")
results = doc.search("weather forecast")
cap = results[0]
print(cap.endpoint.url)   # https://api.open-meteo.com/v1/forecast
print(cap.auth.type)      # none
npm install anip yaml
js
import { fetch } from "anip";

const doc = await fetch("open-meteo.com");
const results = await doc.search("weather forecast");
const cap = results[0].capability;

console.log(cap.endpoint.url);  // https://api.open-meteo.com/v1/forecast
console.log(cap.auth.type);     // none
go get github.com/anip-protocol/anip-go
python
import anip "github.com/anip-protocol/anip-go"

doc, err := anip.Fetch(context.Background(), "open-meteo.com")
results := doc.Search("weather forecast")
cap := results[0].Capability

fmt.Println(cap.Endpoint.URL)  // https://api.open-meteo.com/v1/forecast
pip install pyyaml httpx

python tools/cli/anip.py scaffold

python tools/cli/anip.py validate ./anip.yaml

python tools/cli/anip.py check open-meteo.com

python tools/cli/anip.py fetch open-meteo.com

ANIP is a community standard. Contributions to the spec, implementations, and documentation are welcome.

See CONTRIBUTING.md for the process.

What we need most right now:

• Rust reference implementation
• Java / Kotlin reference implementation
• Real websites adding ANIP support (open a PR linking yours)
• Feedback on the spec from real implementors

What we don't need yet:

• A central registry
• Trust scores
• Payment integrations
• Governance structures

Keep it simple. The protocol is the product.

Because infrastructure that everyone depends on should belong to everyone.

TCP/IP is not owned by a company. HTTP is not owned by a company. DNS is not owned by a company. These protocols work because they are open, stable, and governed by the community.

ANIP should be the same: the foundational layer that any company, any startup, and any developer can build on — without asking permission, without paying fees, without depending on a single vendor.

If ANIP succeeds, the companies that build on top of it will generate the value. That's the right outcome.

The ANIP specification (spec/

) is released under CC0 1.0 Universal — public domain. Use it for anything.

Reference implementations and tools are released under the MIT License.

ANIP is currently at v0.1 — Draft.

The spec is stable enough to implement and experiment with, but may change based on real-world feedback before v1.0. We will not make breaking changes without a clear migration path and advance notice.

v1.0 will be declared when:

• At least 5 production websites serve a valid ANIP document
• At least 3 independent implementations exist in different languages
• The spec has received at least 60 days of open community review

Built by developers, for developers. Forever open.