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.

DRAFTVersion 1.0.0-draft.1Successor to CAOP v0.2November 22, 2026

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
  1. What MAOP is
  2. Status: DRAFT
  3. Implementation status
  4. Agent roles
  5. The supervision lifecycle
  6. Back-edges and recovery
  7. Walk-through: the Northstar trace, A to K
  8. Decisions, actions and the guarantees behind them
  9. Decisions
  10. Actions
  11. Authority: T0 and T1
  12. Evidence
  13. Receipts
  14. Leases
  15. Recovery
  16. Relationship to MCP
  17. What is kept from CAOP v0.2
  18. 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:

Status: DRAFT

DRAFT · 1.0.0-draft.1. MAOP v1 is published for review and is not stable: names, fields and requirements can change before 1.0.0. Implementations should not claim MAOP conformance in production until a non-draft version exists. CAOP v0.2 remains the current published version; nothing in this draft changes or withdraws it.

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.

RoleResponsibilityMay not
supervisorOwns 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.
plannerProposes plans and plan revisions. A plan is a proposal until the runtime validates it.Dispatch work.
implementerExecutes child work under a lease and submits results with evidence.Review, verify, approve, accept or cancel its own work.
reviewerGives an independent verdict on a work product, bound to the product’s digest.Review a work it implemented.
verifierRuns verification checks, including deferred (phase 2) checks, through side-effect-free capabilities.Use a capability with side effects for verification.
approverDecides approval requests, including approval with a steering change, at the trust level the action requires.Approve an action it requested or implemented.
observerReads 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.

MAOP outer supervision lifecycle The stages run in order: Observe, Decide, Plan, Coordinate, Act, Verify, Review, Approve, Record, then Closed. Back-edges: Act to Decide (O15), Act to Coordinate (O16) and Verify to Act (O18). Recover can be entered from any stage except Closed (O26) and leads to Decide (O27) or Closed (O28). Stages can be skipped only where the transition matrix allows it; the table below lists every edge shown. Observe Decide Plan Coordinate Act Verify Review Approve Record Closed Act → DecideO15 Act → CoordinateO16 Verify → ActO18 Recoverentered from any stage · O26 Recover →Decide · O27 Recover →Closed · O28
The outer supervision lifecycle of one unit of work. Solid arrows are the main path; dashed purple arrows are back-edges; the amber box is recovery. Edge ids (O15 and so on) refer to the normative transition matrix in section 10.2 of the specification.
StageWhat happens
ObserveTake in events and resolve context.
DecideInterpret, choose and ratify the commitment; pre-commit hooks run.
PlanProduce a plan; the runtime validates it.
CoordinateDelegate child work, assign roles, grant leases. New in MAOP.
ActChildren or the runtime execute under leases.
VerifyPhase 1 checks the receipt immediately; phase 2 checks the real outcome later.
ReviewIndependent review of the work product and of goal progress.
ApproveA principal or approver decides, possibly with a steering change that narrows the plan.
RecordCommit state with a receipt; may wait for the deferred phase-2 check.
RecoverReconcile after lease loss, an unknown outcome or a crash. New in MAOP.
ClosedTerminal 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.

EdgeTransitionWhen
Main pathObserve → Decide → Plan → Coordinate → Act → Verify → Review → Approve → Record → ClosedEach 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.
O15Act → DecideA guard fails during Act, or new evidence invalidates the plan (a premise goes stale, a policy changes).
O16Act → CoordinateA child is rejected, expires or is cancelled and the plan still holds, so it needs re-delegation.
O18Verify → ActVerification failed and is retryable, or a deferred check failed and remediation fits the plan.
O26any stage except Closed → RecoverA 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.
O27Recover → DecideReconciliation recorded evidence of the effect’s real outcome.
O28Recover → ClosedThe 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.

StepNameStageWhat happens
AObserve requestObserveThe owner’s request is ingested and recorded as digest-bound evidence with a receipt.
BDecide / commit goalDecideThe supervisor creates the commitment. Pre-commit hooks check the owner, lineage and that no premise is stale; the owner’s statement is recorded.
CPlanPlanThe plan is validated against schemas, dependencies, policy and delegation rules. Implementer and reviewer children are proposed.
DCoordinate / delegateCoordinateThe 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.
EAct under leaseActThe 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.
FVerify, phase 1VerifyA verifier other than the implementer checks the result. The verdict binds to the artifact digest and names every check and its method.
GIndependent reviewReviewA 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.
HApprove with steering (attested)ApproveThe 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.
IRecord with receiptRecordThe 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.
JVerify, phase 2 (deferred)VerifyA 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.
KRecover or closeClosed, or RecoverIf 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:

LevelMeaningWhat it can authorize
T0_relayedAn 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_attestedThe 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.

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.2MAOP v1 draft
Operations1723 (17 kept + 6 new)
Schema definitions95110 (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

The API paths in the contract (for example /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.