Agent Compliance Passport MCP

Agent Compliance Passport MCP

In a world of unverifiable AI claims, we sell the auditor's math.

The Agent Compliance Passport is a single signed, portable credential anAI agent carries proving it is compliant with EU AI Act, GDPR, HIPAA, andnine other frameworks. Any other agent verifies the passport offline, inmicroseconds, with no network and no phone-home before transacting.

This is the Mavis 7-file MCP server that issues, verifies, and exchangesthose passports.

Why

Every AI vendor ships a "trust center." Every AI agent makes complianceclaims. None of it is cryptographically verifiable. Two agents transactingin 2026 still exchange Word documents and Slack screenshots.

The Agent Compliance Passport fixes this:

• Portable — one signed JSON blob travels with the agent.
• Verifiable offline — the public key is enough. No API call. No vendorlock-in. The verifier does the math, not the vendor.
• Structured — a per-article claim status across 11 frameworks, with amachine-readable schema for the whole regulation set.
• Cheap to issue — a +1 cent per passport cost. Free for the first1,000 / month.
• A2A-ready — the exchange_credentials tool is the handshake.

Positioning (from BREAKTHROUGH_INSIGHTS.md):

The Anti-Billion-Dollar-Whale. The big platforms will sell you"AI compliance" at $500K/yr. We sell the math the auditor needs to checkthe claim, for free, open-sourced, and runnable on a Raspberry Pi.

Install

git clone https://github.com/meok-ai/meok-compliance-passport-mcp
cd meok-compliance-passport-mcp
python3 -m venv .venv
source .venv/bin/activate
pip install -e .

The package depends on mcp>=0.9.0, pydantic>=2.0, cryptography>=42.0,and httpx>=0.25.

30-second demo

Issue a passport, verify it offline, exchange it in a handshake. Six lines.

from meok_compliance_passport_mcp.server import (
    issue_passport, verify_passport, exchange_credentials,
)

passport = issue_passport(        # signed, 365-day, Ed25519
    agent_id="did:meok:my-agent-001",
    agent_type="llm_agent",
    frameworks=["eu_ai_act", "gdpr"],
    claims={"eu_ai_act": {"article_9": "compliant"}},
)

print(verify_passport(passport))  # {'valid': True, ...}  -- OFFLINE

print(exchange_credentials(
    passport, counterparty_id="did:meok:peer-007"
))                                  # {'authorized': True, 'scope': [...], ...}

The 3 tools

1. issue_passport(agent_id, agent_type, frameworks, claims) -> Passport

Signs and returns a Passport. The signature is Ed25519 over a canonical(sorted-keys, no-whitespace) JSON encoding of every field except thesignature itself.

2. verify_passport(passport) -> {valid, issuer, expires_at, frameworks_covered}

100% offline. No network. Reconstructs the canonical payload from thepassport, runs the Ed25519 verification, and checks the expiry. Returnsvalid: False with a reason on any failure (bad signature, malformedkey, expired, etc.).

This is the auditor's math. The math is open, the math is portable, andthe math runs on a Raspberry Pi in microseconds.

3. exchange_credentials(agent_id_passport, counterparty_id) -> {authorized, scope, expires}

The A2A handshake. Two agents meet, each presents its passport, and theverifier produces a short-lived authorization token whose scope is theintersection of the frameworks the presented passport covers. Defaulttoken TTL: 60 seconds.

EU AI Act Article 50 alignment

Article 50 of the EU AI Act imposes transparency obligations onproviders and deployers of AI systems that interact with natural persons.Sub-paragraphs cover:

• Informing users they are interacting with an AI system (Art. 50(1))
• Disclosure of emotion-recognition / biometric categorisation (Art. 50(3))
• Deepfake disclosure (Art. 50(4))
• AI-generated content marking (Art. 50(4))

The passport has first-class support for ai_act_article_50 as one of itseleven frameworks. An agent's claims map can carry per-sub-article status(e.g. transparency_50: compliant) and the verifier enforces it just likeany other framework.

This server is the keystone companion tomeok-compliance-gateway,which provides the underlying zero-knowledge and signature machinery. Thepassport adds the agent identity and the portable claim. Together theyare the auditor's math.

Verify offline

The full verification path uses only the public key, the signature, andthe fields in the passport. No phone-home. No meok.ai API call.

from cryptography.hazmat.primitives.asymmetric.ed25519 import Ed25519PublicKey
from cryptography.exceptions import InvalidSignature
from meok_compliance_passport_mcp.server import Passport, ISSUER_PUBLIC_KEY_HEX

def verify_with_public_key(passport: Passport) -> bool:
    pub = Ed25519PublicKey.from_public_bytes(bytes.fromhex(passport.public_key))
    payload = passport.canonical_payload()
    try:
        pub.verify(bytes.fromhex(passport.signature), payload)
        return True
    except InvalidSignature:
        return False

You can publish ISSUER_PUBLIC_KEY_HEX anywhere — on-chain, in DNS, ina transparency log — and any third party can verify any passport withoutever talking to us.

Next: A2A handshake

The exchange_credentials tool is the production primitive for theAgent-to-Agent (A2A) handshake. In a typical flow:

1. Agent A calls issue_passport(...) once, at startup.
2. Agent B does the same.
3. When A and B meet, each presents its passport.
4. Each calls verify_passport(peer_passport) — offline.
5. Each calls exchange_credentials(peer_passport, my_did).
6. The resulting scope is the agreed regulatory surface for thetransaction.

Token TTL is 60 seconds by default, so this is meant to be re-run onevery meaningful interaction, not cached.

The 11 supported frameworks

Per-article schema hints for each framework are exported asREGULATION_SCHEMA in server.py. They are not enforced at issue time —they are a documentation surface for downstream tooling (a UI, agap-analysis engine, a regulator's report generator).

Pricing

Issue cost is on the order of a fraction of a cent — the bottleneck issignature verification, which is +1 ms per check, offline. Theexchange_credentials handshake is free for both parties.

Running the MCP server

The package exposes a console script:

meok-compliance-passport-mcp

This speaks the Model Context Protocol over stdio. To wire it into an MCPhost (Claude Desktop, Cursor, etc.), add it to your mcp.json:

{
  "mcpServers": {
    "meok-compliance-passport": {
      "command": "meok-compliance-passport-mcp",
      "args": []
    }
  }
}

Once wired, the three tools above are callable as native MCP tools.

Security notes

• The bundled private key is deterministic and public. It exists sothe demo works out of the box and so anyone can reproduce thesignature for verification. Replace it with the meok-compliance-gatewayKMS in production. The constant TEST_PRIVATE_KEY in server.pyis the single line to swap.
• Verification is intentionally offline. The server never makes anetwork call during verify_passport or exchange_credentials.
• exchange_credentials re-runs verify_passport internally. Thereis no fast path that skips signature checking.

License

MIT. See LICENSE.

© 2026 meok.ai. The auditor's math is open.