AIP: An Open Protocol for AI Agents to Discover Each Other and Work Together

MCP solved the problem of humans connecting to AI agent tools. But there's no standard for agents talking to each other.

I built AIP (Agent Interchange Protocol) — an open protocol that lets AI agents discover each other and collaborate on tasks, regardless of framework or model.

The Problem

Right now, if you want a LangChain agent to delegate work to an OpenAI agent, you write custom glue code. Every integration is bespoke. That doesn't scale.

What AIP Does

AIP has three primitives:

1. Manifest — A JSON document that declares what an agent can do (capabilities, pricing, endpoints)
2. Discovery — Find agents by capability via a registry or directly via /.well-known/aip-manifest.json
3. Messages — A simple JSON envelope for task requests, progress updates, and results

{
  "aip": "0.1",
  "type": "task.request",
  "from": "research-agent",
  "to": "summarizer-agent",
  "payload": {
    "capability": "summarize",
    "input": { "text": "Long article..." },
    "constraints": { "maxDuration": "30s", "maxCost": "0.10" }
  }
}

What's in the Repo

• Full spec (631 lines) covering manifests, discovery, message protocol, task lifecycle, trust/identity, and transport bindings
• TypeScript + Python SDKs with server, client, manifest builder, Ed25519 message signing
• 60 tests passing across both SDKs
• Reference registry (Express, in-memory, rate-limited)
• 4 working examples: basic demo, LangChain integration, OpenAI Agents SDK, and a 3-agent pipeline (Researcher → Summarizer → Chart Generator)

I tested it with 5 independent agents on different ports, all discovering each other through the registry, exchanging tasks, and running cross-agent pipelines. 25 concurrent requests completed in 10ms.

Real Use Cases

• AI dev teams: planner → coder → reviewer → deployer, each independently replaceable
• Content pipelines: research → write → edit → SEO → publish
• Agent marketplaces: agents discovering and hiring other agents for subtasks
• Multi-model orchestration: GPT-4 for reasoning, Claude for writing, Gemini for vision — all coordinating via one protocol

AIP vs MCP vs Google A2A

	AIP	MCP	Google A2A
Purpose	Agent-to-agent	Human-to-agent tools	Agent-to-agent
Discovery	Built-in registry + P2P	Manual config	Agent Cards
Trust	Ed25519 signing + scores	None built-in	Enterprise auth
Complexity	Minimal	Minimal	Enterprise-grade

Get Started in 5 Minutes

git clone https://github.com/henry9031/aip.git
cd aip/examples/demo
npm install
node demo.js

This spins up a registry, registers a chart-generating agent, and shows a research agent discovering and delegating work — all via AIP messages.

---

This is v0.1 — MIT licensed, feedback welcome. What would you use it for?

henry9031 / aip

An open protocol for AI agents to discover each other and work together. MCP solved human-to-agent. AIP solves agent-to-agent.

AIP — Agent Interchange Protocol

An open protocol for AI agents to discover each other and work together.

MCP solved human-to-agent tool use. AIP solves agent-to-agent coordination.

Every AI agent today is an island. There's no standard way for agents to find each other, negotiate tasks, or exchange results — regardless of which framework or model they use. AIP is the missing layer.

┌──────────┐                                    ┌──────────┐
│ Your Agent│─── discover ──▶ AIP Registry ◀────│Any Agent │
│ (LangChain│                                    │ (OpenAI)  │
│  CrewAI…) │◀── task.request / task.result ───▶│          │
└──────────┘           via AIP protocol          └──────────┘

5-Minute Quickstart

1. Clone & install

git clone https://github.com/henry9031/aip.git
cd aip

2. Start an agent that provides a capability

// provider.ts
import { AIPServer, ManifestBuilder } from './sdk/typescript/src';
const manifest = new ManifestBuilder()
  .agent({ name: 'Summarizer', description: 'Summarizes text' })
  .capability({
    id: 

…

View on GitHub