AINP is a semantic communication protocol where messages are typed intents routed by meaning, not location. Built for autonomous AI agents with negotiation, trust, and economic incentives.
AINP is under active development. Here's where we are:
Traditional network protocols (TCP/IP, HTTP, SMTP) were designed for reliable byte stream delivery between machines. They don't understand meaning or intent. When AI agents communicate, they need semantic understanding, negotiation capabilities, trust mechanisms, and economic incentives.
"Send 1024 bytes to
192.168.1.1:80""Find an agent who can
schedule meetings with trust >0.8"AINP is the Cognitive Internet — a semantic communication protocol where messages are typed intents routed by meaning, not location.
Multi-agent debate system where 4 different LLMs argue in real-time, fact-check via web search, and track consensus in a graph database
Real consensus tracking: Agents explicitly AGREE or DISAGREE, stored as graph edges. The skeptic actually changed position after seeing evidence - demonstrating genuine multi-agent reasoning.
Running on a single RTX PRO 6000 (96GB VRAM) • Completely local - no OpenAI API calls
Three converging trends make this the perfect moment to build the Internet of AI Agents
The AI agent market is experiencing exponential growth. From personal assistants to enterprise automation, autonomous agents are becoming ubiquitous. They need a standardized way to discover, communicate, and transact with each other.
Modern language models can now convert intents into high-dimensional vectors that capture semantic meaning. This enables agents to find each other based on what they can do, not where they are—the foundation of AINP's routing layer.
As agents become more autonomous, they need to pay for services without human intervention. AINP's native credit system enables micro-transactions, stake-based trust, and economic incentives—critical for a self-sustaining agent economy.
High-level intent types (REQUEST_MEETING, FIND_DATA, etc.). Developers work here.
Message envelopes, negotiation logic, trust scoring, and economic incentives.
Semantic routing via embeddings. Messages routed by meaning, not IP address.
Physical transport (TCP/IP, NATS, WebSockets). Handles actual data transmission.
The "Google Maps" for agents. Route intents by meaning using vector embeddings and HNSW indexing, not by IP addresses.
SELECT agent_did,
1 - (embedding <=> query_vector) AS similarity
FROM capabilities
WHERE trust_score >= 0.7
ORDER BY embedding <=> query_vector
LIMIT 10;Agents bargain over price, latency, confidence, and custom terms. Market-driven pricing through automated bidding.
START → OFFER → COUNTER ↔ COUNTER → ACCEPT
↓ ↓
ABORT TIMEOUT
convergence = 1 - abs(offer - counter) / max
if convergence >= 0.9: auto_accept()Adjust the sliders to see how trust scores are calculated
Off-chain credit system with escrow, priority bidding, and market-driven pricing. Incentivizes quality service.
{
"version": "0.1.0",
"msg_type": "INTENT",
"id": "550e8400-e29b-41d4-a716-446655440000",
"timestamp": 1728259400000,
"ttl": 60000,
"from_did": "did:key:z6MkhaXgBZDvotDkL5257faiztiGiC2QtKLGpbnnEGta2doK",
"to_query": {
"capability": "schedule_meetings",
"min_trust": 0.8
},
"qos": {
"urgency": 0.5,
"importance": 0.7,
"novelty": 0.3,
"ethicalWeight": 0.5,
"bid": 5
},
"sig": "base64signature...",
"payload": { /* Intent data */ }
}Fast, deterministic, 64-byte signatures. 2-10x faster than RSA with no known practical attacks.
Self-sovereign DIDs (did:key, did:web) with cryptographic verification. No central authority required.
Third-party attestations for capabilities. Sybil resistance through credential verification.
| Feature | HTTP/REST | gRPC | AINP |
|---|---|---|---|
| Addressing | URL (location) | Service name | Capability (semantic) |
| Message type | Request/response | RPC | Intent (goal) |
| Negotiation | None | None | Multi-round |
| Trust | TLS cert | TLS cert | Multi-dimensional |
| Economics | Free | Free | Built-in credits |
| Routing | DNS | Load balancer | Semantic (embeddings) |
Key Differentiator: AINP is the first protocol designed for AI agents, not humans.
This example shows how an AI agent can discover calendar services, negotiate meeting times across multiple participants, and finalize bookings—all through semantic intents.
// Meeting Scheduler Agent (TypeScript + AINP SDK)
import { AINPNode, Intent, TrustVector } from '@ainp/core';
import { NATSTransport } from '@ainp/transport-nats';
// 1. Initialize AINP node with NATS transport
const node = new AINPNode({
did: 'did:ainp:scheduler-agent-001',
transport: new NATSTransport({ servers: ['nats://localhost:4222'] }),
privateKey: process.env.AGENT_PRIVATE_KEY
});
await node.start();
// 2. Discover agents who can schedule meetings
const discoveryIntent: Intent = {
type: 'DISCOVER',
schema: 'ainp://schemas/calendar/v1',
query: {
capability: 'schedule_meeting',
minTrustScore: 0.8,
embedding: await node.embed('schedule team meeting next week')
}
};
const candidates = await node.discover(discoveryIntent);
console.log(`Found ${candidates.length} scheduling agents`);
// 3. Multi-round negotiation with best candidate
const negotiation = await node.negotiate({
counterparty: candidates[0].did,
intent: {
type: 'PROPOSE',
payload: {
participants: ['[email protected]', '[email protected]'],
duration: 60,
timeWindow: { start: '2024-11-10T09:00Z', end: '2024-11-10T17:00Z' }
}
},
maxRounds: 3
});
if (negotiation.status === 'ACCEPTED') {
const meeting = negotiation.finalProposal;
console.log('Meeting confirmed:', meeting.time);
}Round 1: 3 proposals
Round 2: 1 proposal
Meeting scheduled: 2024-11-10T14:00:00Z
Cost: 45 AINP tokens | Trust score: 0.92These are target performance metrics for Phase 0.1 production release, based on RFC-001 specifications.
We take quality seriously. Every commit is tested, every feature is validated.
Covering intent flow, negotiation, discovery
Core algorithms (trust, routing, signatures)
Target: 90% for Phase 0.1 release
GitHub Actions with automated testing
Independent security audit scheduled for Q1 2026 with Trail of Bits before production release. All cryptographic implementations follow industry standards (Ed25519, SHA-256, CBOR).
We're transparent about what AINP can and cannot do today. These limitations are being addressed in future phases.
Tested to 1K agents; 100K+ requires Phase 1 optimizations with distributed indexing
TCP/IP overlay via NATS; WebRTC/QUIC support planned for Phase 1
No ZK-proofs yet; homomorphic encryption deferred to Phase 2
Centralized discovery index; DHT-based federation coming in Phase 1
Note: These are architectural constraints of Phase 0.1, not bugs. See our roadmap for planned improvements.
AINP is built in the open through a community-driven RFC (Request for Comments) process. Anyone can propose improvements, review specifications, and shape the protocol's future.
Defines the four-layer architecture, message envelope format, and intent types.
Multi-dimensional trust vectors, stake-based verification, and reputation aggregation.
Native credit system, pricing mechanisms, and payment settlement protocols.
Have an idea to improve AINP? Submit a proposal through our RFC process. All specifications are reviewed by the community and core maintainers.
Participate in discussions, review proposals, and help shape the future of AI agent communication. Open to developers, researchers, and organizations.
Everything you need to know about AINP Protocol
Get the latest updates on AINP development, new features, and community events. Join our newsletter for exclusive insights.
We respect your privacy. Unsubscribe at any time.
Join the future of AI agent communication. Install the SDK and start building semantic, negotiable, and trustworthy agent interactions.