MXP Protocol

The High-Performance Protocol for AI Agent Communication

17x faster than JSON • A2A Compatible • Production Ready • Open Source

Website • Agents Runtime • Whitepaper • Specification • Cookbook • A2A Guide

⚡ Performance at a Glance

┌────────────────────────────────────────────────────────────────────────────┐
│                         MXP vs JSON (256B payload)                         │
├────────────────────────────────────────────────────────────────────────────┤
│                                                                            │
│  MXP        ████ 466ns                                                     │
│  Bincode    ████████ 887ns                                                 │
│  MsgPack    ████████████████████ 3.9μs                                     │
│  JSON       ████████████████████████████████████████ 7.9μs                 │
│                                                                            │
│  MXP is 17x faster than JSON, 8x faster than MessagePack                   │
│                                                                            │
└────────────────────────────────────────────────────────────────────────────┘

🎯 What is MXP?

MXP (Mesh eXchange Protocol) is a high-performance binary protocol designed for AI agent-to-agent communication. It provides:

• 🚀 Blazing Fast — Sub-microsecond encoding/decoding with zero-copy design
• 🔗 A2A Compatible — Works with Google's Agent-to-Agent protocol semantics
• 🔒 Secure by Default — ChaCha20-Poly1305/AES-GCM encryption, X25519 key exchange
• 📊 Built-in Observability — Every message includes trace context automatically
• 🌊 Native Streaming — Optimized for LLM token streams
• 📦 Minimal Overhead — 32-byte cache-aligned headers

The Enabler Philosophy

MXP doesn't compete with existing standards—it makes them faster:

┌─────────────────────────────────────────────────────┐
│           Your Agent Framework / A2A                │
│          (Keep your existing semantics)             │
└─────────────────────────────────────────────────────┘
                         ↓
┌─────────────────────────────────────────────────────┐
│              MXP Protocol Layer                     │
│   (High-performance encoding, built-in tracing)     │
└─────────────────────────────────────────────────────┘
                         ↓
┌─────────────────────────────────────────────────────┐
│             MXP Transport Layer                     │
│   (Custom UDP, encryption, reliability, streaming)  │
└─────────────────────────────────────────────────────┘

🤖 Build MXP-native agents

MXP Agents Runtime is the production runtime for agents that speak MXP end-to-end. It wires lifecycle, scheduling, tools, policy, memory, and telemetry into a single runtime.

• Runtime repo: https://github.com/yafatek/mxp-agents-runtime
• Real MXP demos: https://github.com/yafatek/mxp-agents-runtime/blob/main/examples/RUN_AGENTS.md

🧪 MXP-native demos

• Agent mesh over UDP (coordinator plus agents): examples/RUN_AGENTS.md in the runtime repo
• Customer support agent with tools: examples/customer-support-agent in the runtime repo
• Enterprise agent with policy and telemetry: examples/enterprise-agent in the runtime repo

🚀 Quick Start

Installation

cargo add mxp

Basic Usage

use mxp::{Message, MessageType};

// Create a message
let message = Message::new(MessageType::Call, b"Hello, agent!");

// Encode to bytes (17x faster than JSON)
let bytes = mxp::protocol::encode(&message);

// Decode from bytes
let decoded = mxp::protocol::decode(bytes.into())?;

// Built-in trace context - no instrumentation needed
println!("Trace ID: {}", decoded.trace_id());

With A2A Compatibility

cargo add mxp --features a2a

use mxp::a2a::{Message, to_mxp, from_mxp};

// Create an A2A message
let msg = Message::user_text("Search for Rust tutorials");

// Convert to MXP for high-performance transport
let mxp_msg = to_mxp(&msg)?;

// Send over MXP transport (17x faster than JSON-RPC)
transport.send(mxp_msg).await?;

With Secure Transport

use mxp::transport::{Transport, Endpoint, PrivateKey};

let transport = Transport::default();
let handle = transport.bind("127.0.0.1:9000".parse()?)?;

// Establish encrypted connection
let private_key = PrivateKey::generate();
let (mut endpoint, session_keys) = Endpoint::connect(
    handle, 
    peer_addr, 
    connection_id,
    private_key, 
    peer_public_key
)?;

// Send encrypted datagrams
endpoint.send_datagram(b"Hello, secure world!".to_vec())?;

📊 Benchmarks

Encoding Performance

┌─────────────────────────────────────────────────────────────────────────────┐
│                        Encoding Time by Payload Size                        │
├─────────────────────────────────────────────────────────────────────────────┤
│                                                                             │
│  Empty (40B)    ██ 97ns                                                     │
│  Small (104B)   ████ 240ns                                                  │
│  Typical (296B) █████ 265ns                                                 │
│  Medium (1KB)   ████ 211ns                                                  │
│  Large (4KB)    ███████ 377ns                                               │
│  XLarge (16KB)  ██████████████████████████████ 1.5μs                        │
│                                                                             │
│  Throughput: 4.7 - 10.2 GiB/s                                               │
│                                                                             │
└─────────────────────────────────────────────────────────────────────────────┘

Decoding Performance

┌─────────────────────────────────────────────────────────────────────────────┐
│                        Decoding Time by Payload Size                        │
├─────────────────────────────────────────────────────────────────────────────┤
│                                                                             │
│  Empty (40B)    █ 37ns                                                      │
│  Small (104B)   ███ 114ns                                                   │
│  Typical (296B) ████ 172ns                                                  │
│  Medium (1KB)   ████ 180ns                                                  │
│  Large (4KB)    ████████ 350ns                                              │
│  XLarge (16KB)  ██████████████████████████████ 1.3μs                        │
│                                                                             │
│  Throughput: 1.0 - 12.0 GiB/s                                               │
│                                                                             │
└─────────────────────────────────────────────────────────────────────────────┘

Protocol Comparison (256B Payload Roundtrip)

Run Benchmarks Yourself

# Codec benchmarks
cargo bench --bench codec

# Protocol comparison
cargo bench --bench comparison --features serde

# Production validation
cargo bench --bench production_validation --features serde

# View HTML reports
open target/criterion/report/index.html

🔧 Features

Message Types

First-class support for agent communication patterns:

Security

• Handshake: Noise IK-inspired with X25519 key exchange
• Encryption: ChaCha20-Poly1305 (default) or AES-256-GCM
• Anti-Replay: Packet number tracking with sliding window
• Key Rotation: Seamless key updates without interruption
• Session Resumption: Fast reconnection with tickets

Feature Flags

[dependencies]
mxp = { version = "0.2", features = ["a2a", "async-reactor"] }

📖 Examples

# Basic ping-pong
cargo run --example ping_pong

# A2A chat between agents
cargo run --example a2a_chat

# LLM token streaming
cargo run --example a2a_streaming

# Agent health monitoring
cargo run --example agent_health

# Secure datagram transport
cargo run --example datagram_secure

🧪 Testing

MXP uses property-based testing to ensure correctness:

# Run all tests (235+ tests)
cargo test

# Run property-based tests
cargo test --test stream_properties
cargo test --test connection_properties
cargo test --test security_properties
cargo test --test performance_properties

# Run integration tests
cargo test --test integration_tests

Test Coverage

📋 Protocol Specification

See SPEC.md for the complete wire format specification.

🗺️ Roadmap

✅ Completed (v0.2)

• Core protocol with sub-microsecond encoding/decoding
• Secure transport with encryption and reliability
• A2A compatibility layer
• Comprehensive test suite (235+ tests)
• Production readiness validation

🚧 In Progress

• JavaScript/TypeScript SDK
• HTTP/WebSocket gateway for gradual adoption

📅 Planned

• Python SDK (Q2 2026)
• Go SDK (Q3 2026)
• MXP Stack (one-command deployment)
• Foundation governance

🤝 Contributing

We welcome contributions! See CONTRIBUTING.md for guidelines.

• 🌍 SDK implementations in other languages
• 🔧 Protocol enhancements
• 📖 Documentation improvements
• 🐛 Bug reports and test cases

🤝 Community and support

• Support channels and FAQ: SUPPORT.md
• Governance model: GOVERNANCE.md
• Community links: docs/community.md

📄 License

• Protocol Specification: Public Domain (CC0)
• Reference Implementation: MIT OR Apache-2.0

🔗 Links

• 🌐 Website: getmxp.xyz
• 🤖 Agents Runtime: mxp-agents-runtime
• 📄 Whitepaper: WHITEPAPER.md
• 📋 Specification: SPEC.md
• 📚 Documentation: docs.rs/mxp
• 📌 Positioning: docs/positioning.md
• ⚖️ Comparisons: docs/comparison.md
• 🧪 Demos: docs/demos.md
• 🐛 Issues: GitHub Issues

🏢 Enterprise

For enterprise adoption, partnerships, and support:

• 📧 Business: [email protected]
• 📖 Adoption Playbook: docs/adoption-playbook.md

MXP: Making AI agents communicate at the speed of thought

Open Source • High Performance • Production Ready