MPLP-Protocol

# Multi-Agent Lifecycle Protocol (MPLP) ### The Open Standard for Governing Agentic AI Systems [![Version](https://img.shields.io/badge/Version-v1.0.0_(Frozen)-blue?style=flat-square)](13-release/mplp-v1.0.0-release-notes.md) [![License](https://img.shields.io/badge/License-Apache_2.0-green?style=flat-square)](../LICENSE.txt) [![Protocol Status](https://img.shields.io/badge/Protocol_Status-Stable-success?style=flat-square)](00-index/mplp-v1.0-protocol-overview.md) [![Profiles](https://img.shields.io/badge/Profiles-SA_%7C_MAP-orange?style=flat-square)](03-profiles/) [![Schema](https://img.shields.io/badge/Schema-JSON_Schema_v1.0-purple?style=flat-square)](../schemas/v2/) [![Governance](https://img.shields.io/badge/Governance-Multi--Agent_Ready-ff69b4?style=flat-square)](12-governance/mip-process.md) [**Documentation**](/MPLP-Protocol/00-index/mplp-v1.0-docs-map.html) • [**Schemas**](../schemas/v2/) • [**Examples**](../examples/) • [**SDKs**](../packages/) • [**Governance**](12-governance/)

“MPLP is to Multi-Agent Systems what TCP/IP was to the Internet.”
The first open protocol for governing the full lifecycle of agentic systems—from planning and execution to observability and learning.

0. Why MPLP? The Case for a Lifecycle Protocol

We are witnessing a paradigm shift in AI development. The era of Prompt Engineering—fragile, unstructured conversations with LLMs—is ending.
The era of Protocol Engineering has begun.

The Crisis of Scale

As organizations move from simple chatbots to complex Multi-Agent Systems (MAS), they face critical structural failures:

The Missing Layer: A Unified Protocol

Today’s ecosystem is full of frameworks, but lacks a shared protocol:

MPLP provides this missing layer.
It defines a vendor-neutral, schema-driven standard for how agents Plan, Execute, Collaborate, and Learn—with governance and observability built in.

1. What is MPLP? (Protocol, not Framework)

MPLP (Multi-Agent Lifecycle Protocol) is a schema-first, vendor-neutral protocol that makes the full lifecycle of AI agents explicit, governed, and interoperable.

It is not:

It is:

You can build your own framework / runtime / IDE / SaaS on top of MPLP, or make your existing system “MPLP-compliant” to unlock portability and governance.

2. The Paradigm Shift: Prompt → Protocol

MPLP replaces unstructured prompts with structured, verifiable protocol objects.

Dimension Prompt Engineering (Old Way) Protocol Engineering (MPLP)
Interaction Unstructured Text Prompts Structured Schemas (Context, Plan, Trace)
State Hidden in LLM Context Window Explicit Project Semantic Graph (PSG)
Collab Fragile, Ad-Hoc Handoffs Standardized SA & MAP Profiles
Governance “Human in the Loop” (informal) Confirm Module, Delta-Intent Governance Spec
Observability Text Logs / Print Statements Structured Event Streams (Observability Spec)
Learning Manual Fine-Tuning Systematic Learning Samples

MPLP does not compete with frameworks like LangGraph / AutoGen—it underlies them.

3. Core Capabilities (What MPLP Adds to the Stack)

MPLP introduces five foundational capabilities to the agentic stack:

  1. Structured Lifecycle Management
    Agent execution is decomposed into explicit stages:
    Context → Plan → Confirm → Trace, with schemas and invariants.

  2. Project Semantic Graph (PSG) Model
    Defines how Context/Plan/Trace/Events can be projected into a single source of truth for project state.
    MPLP v1.0.0 specifies the minimal glue & events; concrete runtime implementations live outside this repo.

  3. Delta-Intent Governance (Spec Level)
    MPLP treats change of intent as first-class:
    • Intent & Delta-Intent events
    • Impact analysis & compensation planning can be modeled and traced
  4. Human-in-the-Loop Confirmation
    The Confirm Module provides a standardized structure for:
    • Risk labeling
    • Approval / rejection
    • Checkpoints before destructive actions
  5. Drift Detection & Recovery (Protocol Hooks)
    MPLP defines events and invariants for:
    • Semantic drift checks between Plan and Trace
    • Graph drift checks between PSG and reality
    • Rollback minimal specification

Implementation of Drift / PSG / AEL / VSL is runtime-specific.
MPLP defines how these concepts are expressed and observed—not how your runtime must implement them.

4. Industry Landscape

MPLP is not a framework; it is a Lifecycle Protocol that sits under frameworks and runtimes.

Capability LangGraph / LangChain AutoGen Model Context Protocol (MCP) MPLP
Lifecycle Standard ❌ ❌ ❌ ✅ Yes
Governance Layer ❌ ⚠️ Partial ❌ ✅ Native Spec
Observability Spec ❌ ❌ ⚠️ Partial ✅ Event & Taxonomy
Learning Loop Spec ❌ ❌ ❌ ✅ Learning Taxonomy
Vendor-Neutral ❌ (Python/JS) ❌ ❌ (Single-provider) ✅ Protocol-First
Nature Runtime Framework Framework Context Interface Lifecycle Protocol

5. Four-Layer Architecture

MPLP organizes the agentic stack into four layers:

graph TD
    L4["L4: Integration Layer"] -->|"IDE, CI/CD, Git, Tools"| L3
    L3["L3: Runtime Glue Spec"] -->|"PSG Binding, Drift Hooks, AEL/VSL Interfaces"| L2
    L2["L2: Modules & Crosscuts"] -->|"Context, Plan, Confirm, Trace, Collab, ..."| L1
    L1["L1: Schemas & Invariants"] -->|"JSON Schemas (The Law)"| Data["Data"]

6. Ten Modules: The Infrastructure of Agent Systems

MPLP standardizes the 10 essential components required for any robust agent system:

  1. Context – Project scope, environment, constraints
  2. Plan – Structured, auditable execution plan
  3. Confirm – Governance gates for human approval / risk control
  4. Trace – Immutable, replayable execution history
  5. Role – Agent capabilities, permissions, responsibilities
  6. Collab – Multi-agent coordination (turn-taking, broadcast, fan-out)
  7. Dialog – Structured conversational exchanges for clarification & negotiation
  8. Extension – Extension points / vendor-specific adapters
  9. Core – Shared protocol primitives & meta-structures
  10. Network – Distributed coordination & broadcast patterns

Module docs: docs/02-modules/*.md Module schemas: schemas/v2/mplp-*.schema.json

7. Profiles: The Runtime Contract (SA & MAP)

MPLP defines Execution Profiles so runtimes can declare their capabilities.

Profile docs & diagrams:

8. Repository Overview

This repository provides the protocol assets, not a runtime:

9. Golden Flows — How We Prove It Works

To avoid being a “paper protocol”, MPLP v1.0.0 ships with an executable Golden Flow Test Suite:

Required flows for v1.0.0 compliance:

  1. Flow-01 — Single-Agent basic plan execution
  2. Flow-02 — Single-Agent large plan handling
  3. Flow-03 — Tool execution integration
  4. Flow-04 — LLM-enriched plan flows
  5. Flow-05 — Confirm-required, risk-aware execution

Any runtime or SDK claiming MPLP compatibility can use these flows + invariants to validate behavior.

10. SDK Support Matrix

MPLP is runtime- and language-agnostic, but v1.0.0 includes SDK support:

TypeScript SDK — Stable (Reference Implementation)

Guide: docs/10-sdk/ts-sdk-guide.md Package: packages/sdk-ts/ (published as @mplp/sdk-ts in npm in typical deployments)

Python SDK — Preview / Codegen-Ready

Guide: docs/10-sdk/py-sdk-guide.md Package: packages/sdk-py/

Go / Java — Examples (Not Official SDKs)

These are illustrative only, not part of the protocol’s compatibility contract.

11. Quick Start (5 Minutes)

Get a feel for MPLP as a protocol, not just another library.

1. Clone & Install

git clone https://github.com/<your-org>/mplp.git
cd mplp
pnpm install

2. Validate All Schemas

pnpm ts-node scripts/validate-schemas.ts

3. Run Golden Flows

pnpm test:golden

You will see:

4. Run a Single-Agent Example

cd examples/ts-single-agent-basic
pnpm install
pnpm start

This demonstrates:

More flows & patterns: docs/11-examples/

12. Roadmap

Concrete timelines are intentionally out-of-scope for the protocol; see docs/99-meta/roadmap.md for more.

13. Governance & License

MPLP is governed as an open protocol:

License & Copyright:

Any normative change requires a new protocol version.

14. Contributing

You can contribute by:

Please start with:

15. Contact

For enterprise adoption, integration partnerships, or protocol collaborations:

Built for the future of Agentic AI. Vendor-neutral. Schema-driven. Lifecycle-governed.
This site is open source. Improve this page.