Typed, measurable, and provable
agent communication
mpl — the Meaning Protocol Layer — is a sidecar proxy that sits between your agents and their tools. Every message is validated against a contract, scored against a quality profile, and hashed into an audit trail you can hand to a regulator.
cargo install mplx // one hop through the proxy, recorded
{
"stype": "org.calendar.Event.v1",
"valid": true,
"qom_passed": true,
"sem_hash": "blake3:9f2c…a41e",
"provenance": { "agent_id": "scheduler-1", "intent": "book_meeting" }
}What is mpl?
mpl is a protocol layer for trustworthy AI agent communication, written in Rust. It runs as a sidecar proxy between your agents and their tools, on top of the transports you already use — MCP for client–server, A2A for peer–peer, or plain HTTP. At every hop it validates a contract, scores quality, applies policy, and writes a tamper-evident record.
A guardrail asks…
“Is this safe?”
Guardrails filter harmful content after generation. Useful — and a different layer of the stack. mpl runs alongside them, not instead of them.
mpl asks…
“Did this meet the contract, and can you prove it?”
Before, during, and after every hop: a typed contract, a quality score, and a BLAKE3-hashed record with provenance. Correctness you can demonstrate, not just hope for.
The problems mpl solves
These aren’t model problems. They’re protocol problems — and they show up the moment a chain of agents has to be trusted in production.
Untyped JSON over the wire
The problem
Agent-to-agent and agent-to-tool calls are usually a JSON blob. The receiver hopes the shape is right, the values are sane, and that someone wrote it down.
What mpl does
Every payload declares a versioned stype backed by a JSON Schema in a shared registry. Malformed messages are rejected at the boundary, not deep in a handler.
Pass/fail is not quality
The problem
“The tool returned a value or it raised” tells you nothing about whether the message was grounded, deterministic, or compliant with upstream instructions.
What mpl does
Six QoM metrics score every message. Compose them into profiles and enforce a threshold per stype glob — drift shows up before it becomes an outage.
No proof for the auditor
The problem
When a regulator asks “show me what the agent did and prove it wasn’t tampered with,” application logs are not tamper-evident and rarely carry provenance.
What mpl does
Each envelope gets a BLAKE3 content hash, a provenance block, and its QoM report, written to an append-only record. Point the auditor at that.
Validation scattered per receiver
The problem
If every tool server implements its own checks, contracts drift, coverage is uneven, and a new agent can quietly skip validation altogether.
What mpl does
A sidecar proxy enforces one contract and one policy language across the whole fabric. Agents don’t change; they point at the proxy and it forwards.
One line at the boundary
Your agents keep their logic. The mpl SDK returns valid,
qom_passed, and the payload — and every call is recorded.
// agent calls a tool, hopes for the best
const res = await mcp.call("create_event", payload);
// is the shape right? ¯\_(ツ)_/¯
// is it grounded? unknown
// who asked for it? not recorded
// can you prove it later? no// same agent, pointed at the mpl proxy
from mpl_sdk import Client
client = Client("http://localhost:9080")
result = client.send(
stype="org.calendar.Event.v1",
payload=event,
profile="qom-strict-argcheck",
)
assert result.valid # contract met
assert result.qom_passed # quality threshold met
# + a BLAKE3-hashed audit record, written
Python: pip install mpl-sdk · TypeScript: npm install @mpl/sdk
Where mpl sits
A thin layer between your agent logic and the transport. The proxy speaks MCP, A2A, or HTTP on the wire; the contracts and quality measurement happen in the layer above.
Agents don’t change — they point at the proxy address and the proxy forwards. See the full flow →
Four jobs at every hop
Contracts, quality, audit, and operations — the primitives that turn agent traffic into something you can validate, measure, and prove.
Contracts
Versioned semantic types backed by JSON Schema in a shared registry
Typed contracts (stypes)
Every payload declares a versioned semantic type such as org.calendar.Event.v1, backed by a Draft 2020-12 JSON Schema in a shared registry. Mismatches are rejected at the protocol layer, not in your handler.
Learn more →Shared schema registry
Pre-built stypes ship under org.*, data.*, eval.*, and ai.* namespaces. Drop your own at registry/stypes/<ns>/<Type>/v<n>/schema.json — the same envelope shape works across every tool and agent.
Learn more →Quality
Measure every message against composable quality-of-message profiles
Six quality metrics
schema_fidelity, instruction_compliance, groundedness, determinism, ontology_adherence, and tool_outcome. Compose them into profiles and score every message that crosses the boundary.
Learn more →Composable QoM profiles
Ship with qom-basic (schema fidelity only) and qom-strict-argcheck (production-grade), or author your own JSON profiles under registry/profiles/ and require them per stype glob.
Learn more →Audit & provenance
Tamper-evident records with BLAKE3 hashes and provenance on every hop
BLAKE3 audit trails
Each envelope carries a content hash (sem_hash), a provenance block (agent_id, intent), and its QoM report. The record is what you hand to an auditor — tamper-evident by construction.
Learn more →Provenance on every hop
Who emitted this message, and why? Provenance travels with the payload, paired with the content hash, so a chain of agent calls stays attributable end to end.
Learn more →Operations
Sidecar deployment, boundary policies, and language SDKs
Sidecar proxy
The Rust proxy runs in front of your existing MCP or A2A server. Agents point at the proxy address; nothing in the agent changes. Start transparent, graduate to strict.
Learn more →Glob-pattern policies
Require a specific QoM profile, mandatory provenance fields, or namespace allowlists for stypes matching a glob (e.g. org.finance.*). Policy is enforced at the boundary, not scattered across handlers.
Learn more →Python & TypeScript SDKs
pip install mpl-sdk or npm install @mpl/sdk. Both return valid, qom_passed (or qomPassed), and the response payload — no extra wiring to read the verdict.
Learn more →Phase 1 & 2 complete (core protocol, SDKs, proxy, registry API, Helm chart, policy engine). Phase 3 in progress.
Explore mpl
Everything about the Meaning Protocol Layer — from the two-minute start to the deep reference.
Features
Contracts, registry, six QoM metrics, profiles, audit, provenance, policies, and SDKs.
Explore →Quickstart
Install mplx, run the proxy transparent, learn and approve schemas, then switch to strict.
Explore →How it works
The stack, the six-step per-hop flow, and the repository layout.
Explore →Use cases
Regulated agent ops, multi-agent fabric, quality regression tracking, MCP tool hardening.
Explore →Compare
How mpl relates to MCP and A2A — what each layer does and where mpl sits.
Explore →FAQ
What mpl is and isn’t, transports, SDKs, compliance, and project status.
Explore →Glossary
Definitions: stype, envelope, sem_hash, provenance, QoM, registry, policy, and modes.
Explore →Blog
Notes on contracts, quality measurement, and audit-trail forensics.
Explore →About
The premise, what’s in the repo, project status, and who mpl is for.
Explore →Put mpl in front of your agents
mpl is open source (MIT). Install the proxy, start in transparent mode, learn your schemas from live traffic, then lock them in. Your agents don’t change.