Multi-Agent Orchestration Protocol · Draft
MAOP: Multi-Agent Orchestration Protocol
A vendor-neutral protocol for supervising work that several agents do together, and the proposed multi-agent successor to CAOP v0.2.
Implementation status: the Creasura reference runtime implements CAOP v0.2. MAOP v1 is a proposal and is not yet implemented. CAOP v0.2 remains the current published version.
On this page
- What MAOP is
- Status: DRAFT
- Implementation status
- Agent roles
- The supervision lifecycle
- Back-edges and recovery
- Walk-through: the Northstar trace, A to K
- Decisions, actions and the guarantees behind them
- Decisions
- Actions
- Authority: T0 and T1
- Evidence
- Receipts
- Leases
- Recovery
- Relationship to MCP
- What is kept from CAOP v0.2
- Read the specification
What MAOP is
MAOP, the Multi-Agent Orchestration Protocol, is a vendor-neutral protocol for supervising goal-directed work that several agents carry out together. It says what valid work is, which transitions are allowed, what evidence each transition needs, who may authorize it, and how a runtime recovers when an agent, a lease or an external effect fails.
It does not say how an agent reasons. Any model, framework or host can take part, and nothing in the protocol depends on one model, host, framework or vendor.
MAOP v1 is the proposed multi-agent successor to CAOP v0.2. It keeps everything CAOP v0.2 defines and adds what is needed when more than one agent works on the same goal: agent identities and roles, delegation of child work, typed authority grants, durable guards, fenced leases, receipts, causal evidence and an explicit recovery stage.
A few principles from the specification shape everything else:
- Claims are not evidence. No work, commitment or child is complete because an agent says so. Completion needs evidence bound to the exact thing completed.
- Authority only narrows downward. A delegate never holds more authority than its delegator. Widening needs the owner at the attested trust level.
- Events wake; state decides. An event never authorizes anything. The runtime re-reads state and re-evaluates guards before every transition.
- Uncertainty is explicit. An external effect whose outcome is unknown is recorded as
outcome_unknownand reconciled with evidence; it is never silently retried or silently marked successful. - Advisory is labelled. Every policy and guard states whether it is enforced (the runtime refuses) or advisory (recorded and reported). Only enforced ones are controls.
Status: DRAFT
Implementation status
The Creasura reference runtime implements CAOP v0.2. MAOP v1 is a proposal and is not yet implemented there. Everything below describes what the draft specification proposes, not shipped behaviour.
The draft is under review in a draft pull request: creasurahub/caop pull request #1. The specification lists ten open questions, including vendor-neutral aliases for wire names inherited from CAOP, schema follow-ups, default trust floors, and which digest algorithms evidence must use.
Agent roles
An agent is a registered software actor: an assistant, a coding agent or a deterministic service. It registers with agents.register and lists the roles it may take. MAOP defines seven roles. Holding a role grants no authority by itself; authority comes only from an authority grant.
| Role | Responsibility | May not |
|---|---|---|
supervisor | Owns the outer lifecycle of a work: decides, plans, coordinates, and accepts or rejects children. | Act as the reviewer or verifier of a child it executed itself. |
planner | Proposes plans and plan revisions. A plan is a proposal until the runtime validates it. | Dispatch work. |
implementer | Executes child work under a lease and submits results with evidence. | Review, verify, approve, accept or cancel its own work. |
reviewer | Gives an independent verdict on a work product, bound to the product’s digest. | Review a work it implemented. |
verifier | Runs verification checks, including deferred (phase 2) checks, through side-effect-free capabilities. | Use a capability with side effects for verification. |
approver | Decides approval requests, including approval with a steering change, at the trust level the action requires. | Approve an action it requested or implemented. |
observer | Reads state and takes in observations. | Perform any other consequential operation. |
An agent may hold several roles in a workspace, but separation of duties is enforced by default on every work with more than one agent: the implementer of a work cannot review, verify, approve, accept or cancel that same work; a reviewer cannot review what it implemented; an approver cannot approve an action it requested or implemented.
A supervisor hands work to another agent with delegations.create. The delegation names the child objective, an isolation policy, a budget and the subset of authority the delegate receives. The child budget cannot exceed the parent’s remaining budget, the delegated authority must be a subset of the delegator’s, and a child returns only a distilled result, never writing to the parent’s state directly.
The supervision lifecycle
Every unit of work has exactly one current supervision stage. The stages are logical: a runtime may fold several into one operation, but every guard of every folded transition must still be evaluated and recorded. The runtime accepts only the transitions in the specification’s transition matrix and refuses any other with INVALID_TRANSITION.
| Stage | What happens |
|---|---|
| Observe | Take in events and resolve context. |
| Decide | Interpret, choose and ratify the commitment; pre-commit hooks run. |
| Plan | Produce a plan; the runtime validates it. |
| Coordinate | Delegate child work, assign roles, grant leases. New in MAOP. |
| Act | Children or the runtime execute under leases. |
| Verify | Phase 1 checks the receipt immediately; phase 2 checks the real outcome later. |
| Review | Independent review of the work product and of goal progress. |
| Approve | A principal or approver decides, possibly with a steering change that narrows the plan. |
| Record | Commit state with a receipt; may wait for the deferred phase-2 check. |
| Recover | Reconcile after lease loss, an unknown outcome or a crash. New in MAOP. |
| Closed | Terminal for this work. New observations about it create new work. |
Back-edges and recovery
Work does not only move forward. The back-edges let the supervisor re-decide or re-delegate when the world changes, and the recovery stage handles effects whose outcome is uncertain.
| Edge | Transition | When |
|---|---|---|
| Main path | Observe → Decide → Plan → Coordinate → Act → Verify → Review → Approve → Record → Closed | Each step is a guarded transition. A plan with no delegation can go straight from Plan to Act; a plan that needs approval before dispatch goes Plan → Approve; review can go to Record when no approval is required. |
| O15 | Act → Decide | A guard fails during Act, or new evidence invalidates the plan (a premise goes stale, a policy changes). |
| O16 | Act → Coordinate | A child is rejected, expires or is cancelled and the plan still holds, so it needs re-delegation. |
| O18 | Verify → Act | Verification failed and is retryable, or a deferred check failed and remediation fits the plan. |
| O26 | any stage except Closed → Recover | A lease was lost or expired with an effect in flight, a receipt is outcome_unknown, a fencing violation, a restart found an in-flight effect, or the pulse dead-man’s switch fired. Entering Recover is always allowed. |
| O27 | Recover → Decide | Reconciliation recorded evidence of the effect’s real outcome. |
| O28 | Recover → Closed | The work is cancelled or abandoned after reconciliation. |
When several transitions are enabled at once, the runtime prefers Recover, then the back-edges into Decide, then the others in matrix order. Work cannot leave Recover while any receipt on it is outcome_unknown and unreconciled.
Each delegated child has its own nested lifecycle: proposed → delegated → leased → executing → submitted → verifying → accepted, with rejected, cancelled and expired as the other end states. A child is never accepted on its own report: acceptance needs evidence bound to what it submitted. The runtime re-evaluates the parent’s guards on every child transition, and supervision.evaluate re-evaluates a work’s guards on demand or on events.
Walk-through: the Northstar trace, A to K
The specification includes one end-to-end scenario that exercises every stage, the back-edges and every multi-agent mechanism. An owner asks for a change to a production service. A supervisor agent delegates implementation to an implementer agent and review to an independent reviewer agent. The release needs the owner’s attested approval, and the outcome is checked a day later.
| Step | Name | Stage | What happens |
|---|---|---|---|
| A | Observe request | Observe | The owner’s request is ingested and recorded as digest-bound evidence with a receipt. |
| B | Decide / commit goal | Decide | The supervisor creates the commitment. Pre-commit hooks check the owner, lineage and that no premise is stale; the owner’s statement is recorded. |
| C | Plan | Plan | The plan is validated against schemas, dependencies, policy and delegation rules. Implementer and reviewer children are proposed. |
| D | Coordinate / delegate | Coordinate | The supervisor delegates implementation and review. Each child grant is a subset of the parent’s; the implementer and reviewer must differ; each delegate gets a lease with fencing token 1. |
| E | Act under lease | Act | The implementer executes, renews its lease and submits its result with the current fencing token, an artifact digest and a trace hash. A stale premise sends the work back to Decide; an expired lease back to Coordinate. |
| F | Verify, phase 1 | Verify | A verifier other than the implementer checks the result. The verdict binds to the artifact digest and names every check and its method. |
| G | Independent review | Review | A reviewer agent that did not implement the work reviews it; the verdict binds to the artifact digest. Requested changes send the work back to Act. |
| H | Approve with steering (attested) | Approve | The owner approves at the attested trust level, on the runtime’s attested surface, with a steering change that narrows the rollout (for example to one region). Hooks re-run on the patched plan; if one fails, the work returns to Decide. |
| I | Record with receipt | Record | The result is committed with a receipt and the expected state version; facts are written with their attestation tier, and a deferred phase-2 check is scheduled. |
| J | Verify, phase 2 (deferred) | Verify | A day later, a side-effect-free verifier checks the real outcome against the receipt from I. If the check fails, the work goes back to Act. |
| K | Recover or close | Closed, or Recover | If phase 2 passes, the work closes. If a lease was lost or a receipt’s outcome is unknown at any point, the work enters Recover and leaves it only with evidence of the real outcome. |
The specification’s full trace table also gives, for every step, the trigger, the guards, the authority and the evidence: see section 28 of the specification.
Decisions, actions and the guarantees behind them
Decisions
A decision becomes a commitment in the Decide stage. Before the work can be dispatched or sent for approval, the runtime evaluates every active policy, including deterministic pre-commit hooks: the commitment must name an owner, have lineage, and rest only on upstream facts that are verified and current. If a hook fails, the work stays a candidate proposal and the runtime says what is missing. A host must not invent an owner or lineage; it asks the principal.
Facts and commitments carry an epistemic status (CANDIDATE_PROPOSAL, RATIFIED_COMMITMENT, VERIFIED_FACT) and a freshness value. When a fact is superseded, the runtime marks what depended on it as stale in the same transaction, and a work in Act whose premise goes stale moves back to Decide.
Actions
An operation that changes durable state or causes, authorizes or records an external effect is consequential. Every consequential operation takes an idempotency key and produces a receipt. Repeating it with the same key and payload returns the original receipt and has no further effect; the same key with a different payload is refused.
Guards protect every transition. A guard is a durable, deterministic condition stored with the work and re-evaluated at every transition. There are seven kinds: authority, policy, evidence, freshness, lease, separation of duties and budget. A model cannot be part of an enforced guard, and a guard that cannot be evaluated counts as failed.
Authority: T0 and T1
Authority is a typed, durable authority grant with a grantee, a scope, a trust level and an expiry. It replaces free-text standing authorizations. There are two trust levels:
| Level | Meaning | What it can authorize |
|---|---|---|
T0_relayed | An agent relays a principal’s words (“the owner said ship it”). The runtime records the words verbatim but cannot verify that the principal said them. | Operations whose trust floor is T0, and narrowing changes. |
T1_attested | The principal acts directly on a surface the runtime controls and authenticates, or presents a signature the runtime verifies. | Any operation, including widening authority. |
Every consequential operation declares a trust floor, and the runtime refuses anything below it. An agent can never produce attested (T1) authority. Delegations, derived grants and steering changes may only narrow authority; widening needs T1. Every receipt records the grant and trust level it relied on.
Evidence
Causal evidence is a record of something observed or produced (a receipt payload, an artifact version, a review verdict, a check result, a principal’s statement), bound by a cryptographic digest to the exact content it is about, with the evidence it was derived from. A review binds to one artifact digest; an approval binds to the digest of the object the approver saw, so it cannot be reused for a changed object. An agent’s statement that work is complete never satisfies an evidence guard on its own.
Verification has two phases. Phase 1 checks the receipt immediately. Phase 2, when configured, checks the real outcome later through a side-effect-free capability, because a receipt proves that an action was dispatched, not that its outcome happened.
Receipts
Every consequential operation, accepted or refused after authentication, produces a receipt: the action, the actor, the idempotency key, the outcome (succeeded, failed or outcome_unknown), the evidence and the receipts and events it followed from. A succeeded receipt, its state change, its evidence and its events become visible together or not at all. Receipts are never rewritten; a reconciliation is a new receipt that points back to the original.
Leases
A fenced lease gives one holder the exclusive, time-bounded right to act on a scope. Each new lease on a scope carries a fencing token larger than any issued before, and every write under the lease must present the current token. A holder whose lease was superseded, for example after a network partition, has its writes refused. A lease that lapses becomes expired, never successful on its own, and expiry is judged by the runtime’s clock.
Recovery
After a crash or restart, every execution, delegation, lease and receipt must be in exactly one defined state. An effect whose outcome is uncertain is recorded as outcome_unknown and the work enters Recover. There the runtime dispatches no new effects; it determines the real outcome from evidence (a side-effect-free provider read, a late settlement with evidence, or a principal’s confirmation). A retry is a new operation with a new idempotency key and, if leased, a new lease with a higher fencing token. Overriding a recorded outcome needs T1 authority. The specification is explicit that exactly-once execution cannot be guaranteed across arbitrary external services; idempotency keys and reconciliation are the tools.
Relationship to MCP
MAOP sits above transports. The Model Context Protocol (MCP) is one way a host reaches a MAOP runtime: MCP carries tool calls, and MAOP defines what those calls mean, which transitions they may cause and what evidence and authority they need. A MAOP runtime is not required to use MCP, and MCP does not by itself provide any MAOP guarantee.
- A runtime may expose the kept CAOP tool surfaces over MCP (ten lifecycle tools or four compact tools) and the new multi-agent operations, as one tool each or folded into the compact surface.
- Identity and workspace come from the MCP transport’s authentication; no tool argument may name the actor, principal or workspace.
- An MCP tool call carries at most relayed (T0) authority, so operations with an attested (T1) floor are refused over MCP and point the principal to the attested surface.
- Capabilities are data, not MCP tools: adding a capability never requires a new tool name.
- Inside the runtime the full lifecycle always runs, whatever surface the host uses.
What is kept from CAOP v0.2
MAOP is designed for parity by construction. It keeps all 17 CAOP v0.2 operations, with the same operation ids and semantics, under the path prefix /maop/v1, and all 95 CAOP v0.2 schema definitions with the same names. Changes to kept definitions are additive only, so a valid CAOP v0.2 document is a valid MAOP document for the same definition. MAOP adds 6 operations (23 in total) and 15 definitions (110 in total).
| CAOP v0.2 | MAOP v1 draft | |
|---|---|---|
| Operations | 17 | 23 (17 kept + 6 new) |
| Schema definitions | 95 | 110 (95 kept + 15 new) |
| Path prefix | /v1 | /maop/v1 |
The six new operations are agents.register, delegations.create, delegations.get, leases.renew, receipts.get and supervision.evaluate. CAOP’s execution states and sub-states are unchanged, its lifecycle stages map onto the supervision stages, and every CAOP v0.2 requirement is kept at the same or a stronger level.
Conformance claims name a class, a level and a profile, for example “MAOP-Coordinated, L2, P1”. The classes are MAOP-Core (the 17 kept operations, equivalent to a CAOP v0.2 runtime), MAOP-Coordinated (adds agents, delegation, grants and receipts) and MAOP-Supervised (adds fenced leases, event-driven guard evaluation, the lifecycle with its back-edges, and recovery).
Operation-by-operation and definition-by-definition parity ›
Migration guide: moving a CAOP v0.2 implementation to MAOP ›
Read the specification
- MAOP v1 specification (1.0.0-draft.1): the full normative text, with the transition matrices and the Northstar trace.
- Contract files: OpenAPI 3.1 (YAML), OpenAPI 3.1 (JSON), JSON Schema 2020-12 and the specification as Markdown.
- CAOP v0.2 → MAOP v1 parity and the migration guide.
- Draft pull request creasurahub/caop#1, where the draft is under review.
- CAOP v0.2, the current published version.
/maop/v1/observations) are paths on a MAOP runtime. They are not pages on this website; the website’s /maop/v1/ is documentation.Source: creasurahub/caop docs/maop-v1.md at commit ccc48b5.