MPL: Meaning Protocol Layer

Contracts, quality measurement, and audit trails for AI agent communication.

MPL sits between your agents and their tools. It makes every interaction typed, measurable, and provable — so you can move from prototype to production without rewriting your stack.

┌─────────────────────────────────────────────────────────┐
│                    Your Agent Logic                      │
├─────────────────────────────────────────────────────────┤
│                    MPL (this layer)                      │
│   Contracts  ·  Quality Metrics  ·  Policies  ·  Proofs │
├─────────────────────────────────────────────────────────┤
│            MCP (client-server)  |  A2A (peer-to-peer)   │
└─────────────────────────────────────────────────────────┘

Get Running in 2 Minutes

cargo install mplx
mpl proxy http://your-mcp-server:8080

Your agents keep working exactly as before — MPL observes, validates, and records everything passing through. Open http://localhost:9080 for the dashboard.

When you're ready to enforce:

mpl schemas generate        # Learn contracts from live traffic
mpl schemas approve --all   # Lock them in
mpl proxy http://your-mcp-server:8080 --mode production

Now malformed requests get blocked before they reach your server.

What This Does For You

This Is Not a Guardrail

Guardrails are reactive safety nets — they block bad outputs after generation. MPL is different:

MPL doesn't ask "is this safe?" — it asks "did this meet the contract, and can you prove it?"

Adapt It To Your Domain

Define Your Own Contracts

Create a schema for any message type your agents handle:

{
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "title": "Support Ticket",
  "type": "object",
  "required": ["title", "priority", "description"],
  "properties": {
    "title": { "type": "string", "minLength": 1 },
    "priority": { "enum": ["low", "medium", "high", "critical"] },
    "description": { "type": "string", "minLength": 10 },
    "assignee": { "type": "string" }
  }
}

Save it as registry/stypes/org/support/Ticket/v1/schema.json — done. Your agents now validate against it.

Set Your Own Quality Thresholds

Pick which metrics matter for your use case:

# qom-my-profile.json
name: "my-production-profile"
metrics:
  schema_fidelity: { min: 1.0 }          # Must match contract perfectly
  instruction_compliance: { min: 0.95 }   # Must follow constraints
  groundedness: { min: 0.90 }             # Claims must cite sources

Write Your Own Policies

Enforce organizational rules at the protocol layer:

policies:
  - name: "require-provenance"
    match: { stypes: ["org.finance.*"] }
    rules:
      - deny_if_missing: ["provenance.agent_id"]
      - require_profile: "my-production-profile"

25+ Contracts Ship Out of the Box

Get started without defining anything — use the pre-built types and extend from there:

SDK Examples

Python

pip install mpl-sdk

from mpl_sdk import Client, Mode

async with Client("http://localhost:9443", mode=Mode.PRODUCTION) as client:
    result = await client.call("calendar.create", {
        "title": "Quarterly Review",
        "start": "2025-03-15T14:00:00Z",
        "end": "2025-03-15T15:00:00Z"
    })

    result.valid       # True  — matched the contract
    result.qom_passed  # True  — met quality thresholds
    result.data        # The response payload

TypeScript

npm install @mpl/sdk

import { MplClient, Mode } from '@mpl/sdk';

const client = new MplClient('http://localhost:9443', { mode: Mode.Production });

const result = await client.call('calendar.create', {
  title: 'Quarterly Review',
  start: '2025-03-15T14:00:00Z',
  end: '2025-03-15T15:00:00Z',
});

result.valid;     // true  — matched the contract
result.qomPassed; // true  — met quality thresholds

Docker

git clone https://github.com/Skelf-Research/mpl.git && cd mpl
docker compose up -d
curl http://localhost:9443/health  # {"status": "healthy"}

How It Works

1. Contracts

Every message declares what it is — a versioned identifier backed by a JSON Schema:

{
  "stype": "org.calendar.Event.v1",
  "payload": { "title": "Meeting", "start": "2025-01-15T10:00:00Z", "end": "..." },
  "sem_hash": "blake3:7f2a...",
  "provenance": { "agent_id": "scheduler", "intent": "create-event" }
}

If the payload doesn't match the contract, it's rejected before reaching the server.

2. Quality Measurement

Six metrics you can mix and match into profiles:

Use qom-basic while developing. Switch to qom-strict-argcheck for production. Or define your own.

3. No Code Changes Required

MPL runs as a proxy alongside your existing setup:

Agent  ──▶  MPL Proxy  ──▶  MCP/A2A Server
              │
              ├── Validates contracts
              ├── Measures quality
              ├── Applies policies
              └── Records everything

Start in transparent mode (observe only), graduate to strict (enforce) when you're ready.

4. Compliance You Can Point To

Every message through MPL carries a BLAKE3 hash (tamper detection), provenance metadata (who did what), and a quality report (did it meet thresholds). These map to:

Documentation

Full docs at skelf-research.github.io/mpl

Status

Repository

crates/mpl-protocol/    Core protocol (Rust)
crates/mpl-proxy/       Sidecar proxy
crates/mplx/            CLI tooling
python/                 Python SDK
typescript/             TypeScript SDK
registry/stypes/        Pre-built contract definitions
helm/mpl-proxy/         Kubernetes Helm chart
examples/               Tutorials and demos
documentation/          Documentation site (MkDocs)

Contributing

See the Contributing Guide for development setup and workflow.

License

MIT — Open an issue if you have questions.