ANIP — Agent-Native Internet Protocol
An open standard for websites to speak directly to AI agents.
The idea
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.
How it works
1. A website publishes its capabilities
# 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]
2. An AI agent discovers and calls it
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 standard
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 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.
What's in this repository
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
Getting started
Add ANIP to your website
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.
Use ANIP in your agent (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:
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
Use ANIP in your agent (TypeScript)
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
Use ANIP in your agent (Go)
go get github.com/anip-protocol/anip-go
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
CLI tool
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
Relationship to other standards
| 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. |
Contributing
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.
Why open source? Why no company?
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.
Spec license
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.
Status
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.