Three agents. One binding decision.
Follow a single coordination session from the moment agents introduce themselves, through a bounded session, to a replayable outcome. No code — just the story of how MACP turns a messy multi-agent conversation into one authoritative result.
Three agents walk into a session
An architect, a security reviewer, and a cost optimizer need to agree on a Q3 deployment strategy. Each has its own expertise — and its own opinions. Left alone, they'd negotiate forever or reach conflicting conclusions.
Every agent publishes a manifest
Before coordination can happen, agents need to know who else is in the room. Each publishes a manifest — a small card answering: who am I, what can I do, what coordination modes do I support.
With manifests published, our three agents now know about each other and the modes they can speak.
A bounded context, locked at the start
The architect kicks off a Session: a bounded context where this coordination lives. Three things are immutably bound at the moment the session opens — and cannot change for its lifetime.
If these versions could drift mid-session, replay would be meaningless. So MACP freezes them at the door.
Propose · Evaluate · Vote · Commit
Inside the session, coordination unfolds as a structured four-step flow. Each agent contributes at the right stage, with the runtime enforcing who can do what.
Suggests blue-green deploy.
APPROVE, high confidence.
Votes APPROVE.
Binds the outcome.
Only the final Commit makes it binding. Everything before is deliberation.
Every message earns its place
Agents don't get to write directly into the session log. Each message passes through a chain of checks — any failure, and it's rejected with a precise reason. Pass them all, and it's appended to the authoritative log.
Who are you?
Is the message well-formed?
Have we seen this already?
Can this sender do this?
Into the session log.
The message is appended to the session's append-only log and broadcast to every subscriber in the order the runtime accepted it.
Rejected with a structured error code (unauthenticated, rate limited, wrong sender, session closed). The log stays clean.
One binding decision
When the architect commits, the runtime evaluates the majority policy against the accepted history. The commitment is allowed, the session transitions to RESOLVED, and the outcome becomes authoritative.
Rewind the whole thing, bit for bit
The session log is append-only and deterministic. Months later, you can replay the exact same sequence — instantly, at 10× speed, or step by step — and always get the same outcome. Crash recovery is just replay with a different trigger.
All events emitted at once — great for fast re-derivation.
Proportional inter-event timing, perfect for post-mortems.
One event at a time — a debugger for coordination.
That's the whole loop.
Three agents. One session. One binding outcome — structured, auditable, replayable. Every step verified. Every state transition recorded. That's MACP turning multi-agent chatter into coordination you can trust.