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

Notifications You must be signed in to change notification settings

Fork 0

Star 0

BranchesTags

Open more actions menu

Folders and files

NameName

Last commit message

Last commit date

Latest commit

History

1 Commit

1 Commit

.github

.github

docs

docs

examples

examples

reference-implementations

reference-implementations

rfcs

rfcs

sdk/python/anip

sdk/python/anip

spec

spec

tools/cli

tools/cli

.gitignore

.gitignore

CHANGELOG.md

CHANGELOG.md

CONTRIBUTING.md

CONTRIBUTING.md

LICENSE

LICENSE

README.md

README.md

SCHEMA.md

SCHEMA.md

Repository files navigation

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]

1. 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)

pip install pyyaml httpx

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

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)

npm install anip yaml

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.

About

Open protocol for websites to expose capabilities to AI agents

Resources

Readme

License

MIT license

Contributing

Contributing

Uh oh!

There was an error while loading. Please reload this page.

Activity

Stars

0 stars

Watchers

0 watching

Forks

0 forks

Report repository

Releases

No releases published

Packages 0

Uh oh!

There was an error while loading. Please reload this page.

Contributors

Uh oh!

There was an error while loading. Please reload this page.

Languages

Python 54.7%

TypeScript 24.2%

Go 21.1%