A language-agnostic communication protocol and runtime framework for multi-agent systems in institutional environments.
Institutional Agent Communication Protocol (IACP) is an open framework for structured communication between AI agents.
It provides protocol definitions, message routing, event-driven communication, workflow execution, context management and runtime interoperability across multiple AI platforms.
The framework is designed to be independent from any specific AI model, runtime or orchestration engine.
Its goal is to provide a stable institutional communication layer that can be adopted by different multi-agent systems.
This project is in active development.
The core architecture has been defined and documented across four implementation phases.
Components are being delivered progressively following the roadmap.
Public APIs have not been published yet. npm, pip, and Go packages will be available with the first stable release.
IACP defines how autonomous agents discover, communicate, coordinate, and transact within institutional boundaries. It provides a formal contract layer between agents, enabling:
- Discoverable services — Agents advertise capabilities via typed interfaces
- Verifiable messages — Every message carries provenance and integrity metadata
- Deterministic routing — Messages reach intended handlers through topology-aware dispatch
- Observable streams — All communication surfaces emit structured event data
- Pluggable transports — Swap TCP, IPC, message queues, or WebSocket without protocol changes
IACP treats agent communication as an institutional concern, not an implementation detail. Messages are first-class entities with lifecycle, ownership, and audit requirements. The protocol enforces nothing about what agents do internally — only how they interact at boundaries.
- Protocol before implementation — Contracts are defined before code is written
- Verifiable by default — Every message can be validated independently
- Transport independence — No coupling to specific wire formats
- Institutional memory — All communication is observable and replayable
- Progressive disclosure — Simple use cases require minimal ceremony
- Structured Communication — Every interaction has a defined type, version, and lifecycle
- Event-Driven Architecture — State changes propagate through observable event streams
- Runtime Independence — No dependency on any specific AI platform or language runtime
- Backward Compatibility — Protocol versions negotiate compatibility without breaking existing agents
- Versioned Protocols — Message schemas, events, and capabilities are versioned independently
- Auditability — All messages and events are traceable with correlation and trace identifiers
- Observability — Metrics, timelines, and traces are first-class citizens of the protocol
- Scalability — Transport implementations can be swapped without changing agent logic
- Extensibility — Plugin system allows custom transports, codecs, and middleware without forking
Existing agent frameworks couple communication logic to runtime specifics. IACP extracts the communication layer into a standalone concern so that:
- Agents written in different languages can interoperate
- Audit trails span organizational boundaries
- Communication policies evolve independently of agent logic
- New transport mechanisms can be adopted without rewriting agents
┌──────────────────────────────────────────────────┐
│ Agent Layer │
│ (Your application logic, models, workflows) │
├──────────────────────────────────────────────────┤
│ IACP Protocol Layer │
│ Message Envelope · Schema Registry · Routing │
├──────────────────────────────────────────────────┤
│ Transport Abstraction Layer │
│ IPC · TCP · MQ · WebSocket · Custom │
├──────────────────────────────────────────────────┤
│ Observable Stream │
│ Events · Metrics · Audit Trail │
└──────────────────────────────────────────────────┘
| Scenario | Benefit |
|---|---|
| Multi-language agent systems | Shared protocol across Python, TS, Go, Rust |
| Regulated environments | Audit trail for every inter-agent message |
| Plugin ecosystems | Versioned capability discovery |
| Edge deployments | Transport switching without agent changes |
| CI/CD pipelines | Deterministic message routing between stages |
The Institutional Agent Communication Protocol (IACP) Framework is currently under active development.
The project foundation and architecture are already available.
Official runtime packages will be published after the first stable release.
npm
npm install @iacp/frameworkPython
pip install iacp-frameworkGo
go get github.com/iacp-framework/coreRust
cargo add iacp-frameworkUntil official packages are released, the framework should be used directly from the source code.
See INSTALL.md for detailed build instructions and test commands.
Phase 1 — Foundation Status: Complete
Phase 2 — Core Runtime Status: Complete
Phase 3 — Communication Infrastructure Status: Complete
Phase 4 — SDKs and Connectors Status: Complete
Phase 5 — First Stable Release (v1.0.0) Status: Planned
Compatibility with the following runtimes will be provided through independent connectors:
- OpenCode
- Claude Code
- Cursor
- Codex
- Gemini
- OpenAI
- Ollama
- vLLM
- LM Studio
Each connector translates harness-specific calls to IACP protocol messages. No connector modifies or depends on the target harness. Connectors are optional and independently installable.
| Phase | Focus | Status |
|---|---|---|
| 1 | Foundation structure, documentation, schemas | ✅ Complete |
| 2 | Core protocol: message envelope, events, context, AST, versioning | ✅ Complete |
| 3 | Communication infrastructure: message bus, event bus, queues, transport, routing | ✅ Complete |
| 4 | SDK, plugin system, connectors (9 harnesses), runtime | ✅ Complete |
| 5 | GitHub publication, CI/CD, cross-platform validation | ✅ Complete |
| 6 | REST, WebSocket, gRPC transport adapters | ✅ Complete |
| 7 | Production hardening: security, encryption, rate limiting | ✅ Complete |
| 8 | Ecosystem: marketplace, plugin discovery, documentation site | ✅ Complete |
Tests: 134/134 (100%) across all phases.
IACP Framework is an independent open source project.
It is not tied to any specific commercial platform, AI model, or vendor ecosystem.
The protocol definitions, message formats, and runtime contracts are public and versioned.
Third-party connectors and plugins can be built without requiring access to the core framework internals.
Contributions, extensions, and forks are welcome under the terms of the license.
Apache 2.0 — See LICENSE.
Built for agents that need to talk to each other, not just to humans.