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

> Source: <https://github.com/shivanshmah14/anip>
> Published: 2026-06-16 08:09:01+00:00

**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.

```
# https://yoursite.com/.well-known/anip.yaml

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

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

# Find a capability matching the agent's goal
for cap in doc["capabilities"]:
    if any("search" in intent for intent in cap["intents"]):
        # Call it — the schema tells the agent exactly what to send
        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](/shivanshmah14/anip/blob/main/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 agents*want 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:
        # Discover
        resp = await client.get(f"https://{site}/.well-known/anip.yaml")
        doc = yaml.safe_load(resp.text)

        # Search by intent
        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']}")
                # Call it using the schema
                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

# Generate a starter anip.yaml for your site
python tools/cli/anip.py scaffold

# Validate a local file
python tools/cli/anip.py validate ./anip.yaml

# Check if a live site has ANIP support
python tools/cli/anip.py check open-meteo.com

# Fetch and display a live ANIP document
python tools/cli/anip.py fetch open-meteo.com
```

| Standard | Relationship |
|---|---|
MCP |
Complementary. ANIP is the discovery layer; MCP is a transport. Set `endpoint.type: mcp` in your ANIP document to point to an MCP server. |
OpenAPI |
Complementary. ANIP is simpler and intent-focused. An ANIP capability can link to a full OpenAPI spec in its `docs` field. |
robots.txt |
Analogous pattern. `robots.txt` says what crawlers can't do. ANIP says what agents can do. |
sitemap.xml |
Analogous purpose. Sitemaps are for search engines. ANIP is for agents. |
JSON-LD |
Different goal. JSON-LD describes entities. ANIP describes actions. |

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

See [CONTRIBUTING.md](/shivanshmah14/anip/blob/main/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](https://creativecommons.org/publicdomain/zero/1.0/) — public domain. Use it for anything.

Reference implementations and tools are released under the [MIT License](/shivanshmah14/anip/blob/main/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.*