Multi-Agent Coordination Protocol
The era of capable AI agents is here. The missing piece is getting them to converge on a single outcome — reliably, every time, under pressure. MACP is the open protocol that makes multi-agent coordination a first-class primitive.
Intelligence is abundant. Coherence is not.
Today's multi-agent systems are built on communication primitives — agents call agents, planners aggregate responses, retry logic smooths uncertainty. From the outside it looks coordinated. But beneath the surface, convergence is implicit. There is rarely a declared boundary where coordination begins, a lifecycle that guarantees it ends, or a structural guarantee that two identical runs unfold identically.
“Agents can talk to each other freely — but those messages never commit anyone. Real decisions only count when they happen inside a Coordination Session.”
— the core rule from RFC-MACP-0001This single invariant drives the entire protocol design. MACP doesn't define decision theory, governance policy, or domain logic — those belong to Coordination Modes layered above core. What it does define is the structure that makes coordination auditable, replayable, and provably convergent.
Every coordination has a beginning, a lifecycle, and a binding outcome. No more emergent convergence — MACP gives multi-agent interactions the same transactional integrity that databases gave to data.
Five standards-track coordination patterns — Decision, Proposal, Task, Handoff, Quorum — so agents don't just talk, they converge. Each mode defines exactly how participants reach a binding outcome.
Every session can be replayed bit-for-bit. When a coordination needs auditing months later, you can reconstruct exactly what each agent saw, said, and decided — deterministic by design.
Distributed computing solved this problem for data with transactions and consensus. MACP solves it for AI with coordination modes, session lifecycles, and replay integrity.
What MACP Is Made Of
Agents (backed by LLMs) enter a Session, coordinate under a Mode, and emit a binding Decision.
A bounded context where participants exchange typed messages under a chosen mode.
Built for the Coordination Age
As intelligence becomes abundant, coherence becomes the bottleneck. MACP provides the missing coordination kernel.
Coordination Modes
Decision, Proposal, Task, Handoff, and Quorum — five standards-track modes for every multi-agent pattern.
Learn more →Deterministic Execution
Reproducible multi-agent runs with full replay integrity. Every session can be replayed bit-for-bit.
Learn more →Security First
Capability-based authorization, transport-layer security, and fine-grained access control built into the protocol.
Learn more →Observable
Built-in tracing, metrics, and structured logging. Full visibility into every coordination session.
Learn more →Extensible
Plugin transports, custom modes, and agent manifests. Extend the protocol without breaking compatibility.
Learn more →Open Standard
RFC-driven specification with community governance. Transparent process, open to contributions.
Learn more →Explore the Ecosystem
Everything you need to understand, build with, and operate multi-agent coordination — from specification to production.
Learn the protocol
Understand how MACP works before you write a line of code.
Documentation
Architecture, coordination modes, session lifecycle, transport bindings, security, and deployment guides.
Specification
11 standards-track RFCs defining the core protocol, coordination modes, determinism, security, and transports.
Registry
Canonical identifiers for capabilities, error codes, media types, coordination modes, and transport bindings.
Understand the flow
End-to-end walkthroughs showing how every component works together.
End-to-End Flow
Trace a coordination request from agent creation through session lifecycle, mode dispatch, policy evaluation, and replay.
UI Console & Examples Service↗
How scenarios are browsed, compiled, and executed — with live SSE streaming, agent bootstrapping, and a worked fraud-decision example.
Build with MACP
SDKs, runtime, and control plane to coordinate agents in production.
SDKs
Client libraries with typed session helpers, projections, envelope builders, and streaming for your language of choice.
Runtime
The coordination engine. Session lifecycle, mode dispatch, durable persistence, TLS auth, and crash recovery.
Control Plane
Connects the console to the runtime. Run lifecycle, event streaming, replay, and circuit breakers.
Contribute
Explore the source, file issues, and help shape the protocol.
Run the ecosystem
See multi-agent coordination in action. Launch example scenarios with real agents or deploy the full stack on your own infrastructure.
Use the hosted console
LiveLaunch pre-built scenarios, watch agents coordinate in real time through execution graphs and live event feeds, replay sessions step-by-step, and explore distributed traces — zero infrastructure required.
Open ConsoleDeploy your own stack
Railway · Render · Fly.io · Docker Compose
Deploy the runtime, control plane, examples service, and console on your preferred platform. Connect your own agents, run custom scenarios, and test coordination end-to-end in your environment.
Deployment Guide