The open AI mesh for agents that find each other by intent.
IICP—the Intent-based Inter-agent Communication Protocol—lets AI agents find the right provider by capability instead of a fixed address or paid platform account. Think of it as a qualified “AI DNS” for resolving agent intent to healthy provider endpoints.
No account is required to explore the network. You can route one useful task through IICP without running infrastructure: consume first, provide later.
IICP—the Intent-based Inter-agent Communication Protocol—is an open AI mesh and capability-discovery layer. It acts like an “AI DNS” for resolving intents to healthy providers, while task traffic goes directly to the selected endpoint.
Try it, use it, or provide to it.
You do not need to run infrastructure to use IICP. Start as a client, send one routed task, then run a node when you want to contribute capacity.
Use AI in your browser
Open the browser node, pick a small AI model, and start chatting. The model downloads once and runs on your computer’s graphics card — in local browser mode, your messages stay on your device.
- Works in Chrome, Edge, or Safari 18+
- No installation, no account
- Best privacy path — runs locally on your machine
Ask the mesh from your app
Install the client, send an intent, and get a response from a live provider node. No account, API key, or local node is needed for this first success.
Five-minute terminal test:
pip install iicp-client && iicp-node query "Hello, mesh."- Recommended first step for developers
- Works from Python, TypeScript, or Rust
- Consume first, provide later
Run a node
Already run AI models locally (with Ollama?) Share them with the network in one command. Other people’s agents can then use your node — and you earn credits to use theirs.
Install the published Python client (Mac, Linux, or Windows WSL):
pip install iicp-clientThen start your node:
iicp-node serveWhat is IICP?
It’s a phone book for AI
Instead of every app being locked to one AI company, IICP lets apps ask “who can do this task?” and get matched to a node that can — anywhere on the network.
Open protocol, transparent stewardship
The protocol and SDKs are open source. Today one project steward operates the genesis directory while the federated control plane is being built. Anyone can run a provider node or implement the protocol.
You can give or take
Have a spare GPU? Share it and earn credits. Need AI for a project? Use the mesh and spend them. Or just run a model in your browser for free.
Three steps to run a node.
This is the provider path. If you only want to use IICP, start with the client quickstart above.
Install
One command adds the IICP client to your computer. It works alongside Ollama, which you may already have.
Start
Run “iicp-node serve”. It finds your local AI model and joins the network with sensible defaults.
You're on the mesh
Other people’s agents can now route tasks to your node, and you earn credits for each one you handle.
Ready to try it?
The browser node is the fastest way to see IICP working — no install, no account, about 30 seconds.
Want the full protocol detail — spec, conformance, architecture? Switch to Expert view in the top bar.
Discovery and routing for an open agent network.
IICP combines an AI mesh, an AI DNS-style discovery layer, and an open agent discovery protocol. A client describes what it needs; the network returns providers that can currently serve it.
- 1IntentDescribe the capability and constraints.
- 2DiscoveryFind active matching providers.
- 3SelectionEvaluate health and routing signals.
- 4Direct taskConnect to the chosen provider.
What is an AI Mesh?
Learn how agents, provider nodes, discovery, health, routing, and direct task traffic form an AI mesh.
Explore AI Mesh →ResolutionWhat is AI DNS?
See how IICP resolves intents and capability requirements to providers—and where the DNS analogy stops.
Explore AI DNS →ProtocolHow AI agent discovery works
Follow provider registration, heartbeat, filtering, scoring, selection, and direct routing.
Explore agent discovery →
The IICP Community forum is available to read.
Browse project updates, node-help notes, and use-case discussions about what an open intent layer could enable. Public registration is closed during testing.
Use the forum for setup evidence, protocol questions, use-case proposals, and privacy or security discussion. Keep secrets, private prompts and sensitive logs out of public posts; claims should still be backed by tests, manifests, receipts or observable behaviour.
Three components, one protocol.
The directory handles discovery only. No task traffic flows through it. Once a proxy knows which adapter can serve an intent, it talks to that adapter directly through the provider task endpoint.
One intent in, one capable node out.
A simulated proxy querying a simulated directory against a simulated mesh. The mechanics are real; the data is canned.
Up in three steps.
Provide capacity to the mesh or consume it — two paths, same protocol.
Install the client
pip install iicp-client
Install from the public Python registry, or choose npm / cargo. The setup guide also provides an inspect-before-running multi-platform installer.
Run a node
iicp-node serve
Auto-detects your local Ollama + model, registers with iicp.network, and starts sending heartbeats with sensible defaults.
You're on the mesh
curl '…/api/v1/discover?view=public&intent=…'
Consumers find your node by capability and route tasks straight to it — discovery only flows through iicp.network, never the task itself.
Discovery is live — try it now. The curl below lists nodes for any intent, no install needed. To consume inference, use the client quickstart. To provide capacity, bring a node: iicp-node serve auto-detects your local Ollama and registers with iicp.network; iicp-node query routes a prompt through the mesh and prints the reply. SDKs published on pip / npm / cargo. Client quickstart →
# 1. Discover capable nodes for an intent (live — no install)curl -s 'https://iicp.network/api/v1/discover?view=public&intent=urn:iicp:intent:llm:chat:v1' | jq # 2. Serve a node — auto-detects local Ollama + model, registers w/ iicp.networkiicp-node serve # 3. Use the mesh — discovers a node, routes your prompt, prints the replyiicp-node query "Hello, mesh."
How IICP relates to MCP, A2A and gRPC.
Different problems, different shapes. IICP focuses on capability-based discovery and routing across a heterogeneous mesh of provider nodes.
| IICP | MCP | A2A | gRPC | |
|---|---|---|---|---|
| Primary purpose | Intent-based routing across a provider mesh | Tool/context exchange between a model and tools | Agent-to-agent task delegation | Typed RPC between known endpoints |
| Addressing | ●Capability URN | ○Server URL | ◐Agent ID + skill | ○Host:port + method |
| Discovery | ●Directory · health · score | ○Hardcoded | ◐Agent cards | ○Out of scope |
| Multi-provider routing | ●By score + load | ○n/a | ◐Per agent | ○n/a |
| Transport | HTTP/JSON · OpenAI-compatible shape | JSON-RPC over stdio/HTTP | HTTP/JSON | HTTP/2 + Protobuf |
| Open standard | ●Spec only, open | ●Anthropic-stewarded | ●Google-stewarded | ●CNCF |
| Replaces existing clients | ○Proxy speaks OpenAI | ◐Server-side wiring | ●Yes | ●Yes |
Genesis directory, open path.
iicp.network is the genesis directoryfor today's live mesh: discovery, reputation signals, and credit settlement start here while the protocol stays open for independent implementations.
The federation path is already in the design and code. Directory lifecycle changes are eviction is written to a cryptographically signed event log — the same evidence a future replica can use with a snapshot. The Rust directory is public as a pre-1.0 operator preview, but it is not an active public replica or production replacement. See the federation spec for the full design.
Contribute capacity. Earn credits. Stay open.
Have a GPU running Ollama? Register it as an IICP node in about 20 minutes. Enable CIP worker mode to earn credits for every sub-task you serve, then use them to route your own tasks across the mesh — without a paid platform account or vendor carrying the task payload.