Agent Passport

Agent Passport — MCP server

The free tool a developer drops in, in ~5 lines, to issue and independently verify a verifiable passport for an AI agent — over the Model Context Protocol, so it works in LangChain, CrewAI, AutoGen, OpenAI Agents, Claude Desktop — anything that speaks MCP.

It talks to the real, public FractalAI deployment: the live L1 JSON-RPC node at https://api.fractalai.net.co (FRC-55 agent registry) and the web endpoints at https://fractalai.net.co (attestations, receipt key, x402). Nothing here is mocked.

npx @fractalai/agent-passport-mcp

Tools

x402-paid tools (v0.2.0) — post-quantum proofs, pay-per-call

The 8 supported FractalAI x402 routes are surfaced as auto-payable MCP tools. An x402-aware wallet client signs an EIP-3009 authorization and pays in USDC on Base using the standard _meta["x402/payment"] convention. Each served signature is ML-DSA-65 / Dilithium-3 (NIST FIPS 204) and verifiable offline; each also attempts an on-chain anchor on FractalAI's L1 (the anchor signature is Dilithium-2 / ML-DSA-44-class, pending the gated consensus cut-over — see "Honest scope"). Uses the FIPS-204-standardized algorithm via audited @noble/post-quantum (not a FIPS-validated CMVP module). Call any tool without payment first to get the exact price + payment challenge.

Payment note: paid tools accept the standard _meta["x402/payment"] (auto-pay) and also a plain payment string arg (base64 X-PAYMENT) as a universal fallback. Nothing is fabricated — the tools proxy to the live routes and relay exactly what they return, honest scope included.

Honest scope (read this — project Regla 4)

A valid passport proves an identity + a specific attested assertion are cryptographically intact over the exact signed bytes, that the record is internally consistent, and that it is anchored on FractalAI's L1. It does NOT prove:

• that the assertion is true, or that the agent's decision/action was correct;
• any decentralized / consensus-scored reputation — issue_passport does not register reputation;
• lookup_agent ratings are the registry's own counters as reported by the node, not an independent audit.

Signature checks are labeled by trust model: [independent] = computed locally, does not trust the FractalAI server (the offline ML-DSA-65 check, content hashes); [server-assisted] = calls a FractalAI endpoint (the Dilithium-2 /api/proofmind/verify check). The ML-DSA-65 verification uses the FIPS-204-standardized algorithm via the audited @noble/post-quantum library — this is not a FIPS-validated (CMVP) module.

What is real today vs roadmap

• Real today: offline ML-DSA-65 verification against the published key; server-assisted Dilithium-2 verification + tamper control; FRC-55 on-chain agent reads; the real x402 402→pay→seal flow for issuing.
• Roadmap (not claimed as done): server-issued attestations are currently self-signed by the server key and anchored on FractalAI's own L1; full on-chain consensus validation and a decentralized, consensus-scored reputation are future milestones. The ml_dsa65 detached signature is delivered to pilot integrations today (pass it via the receipt argument) and is being rolled into the public API.

Use it

You don't need to install or build anything — npx fetches and runs the published package directly (see the config block above). No account, no API key.

Contributing (building from source)

Only needed if you're working on the server itself, inside the FractalAI monorepo:

cd integrations/agent-passport-mcp
npm install
npm run build      # tsc → dist/
npm test           # handshake: server stands up, tools respond, ML-DSA-65 round-trips

Configure in an MCP client

Claude Desktop (claude_desktop_config.json)

{
  "mcpServers": {
    "agent-passport": { "command": "npx", "args": ["-y", "@fractalai/agent-passport-mcp"] }
  }
}

Environment

• FRACTALAI_BASE_URL — web endpoint base (default https://fractalai.net.co).
• FRACTALAI_RPC_URL — L1 JSON-RPC node (default https://api.fractalai.net.co).
• AGENT_PASSPORT_AUTODEMO — on connect, the server makes one real, free call to the live node (fractal_getAgentStats) and logs the result to stderr, so you can see immediately that this isn't mocked. Fire-and-forget — it never delays or blocks the MCP handshake. Set to 0 to disable.

5-line examples (per framework)

All of these run the same MCP server (npx @fractalai/agent-passport-mcp) over stdio and call the tools.

LangChain (Python) — langchain-mcp-adapters:

from langchain_mcp_adapters.client import MultiServerMCPClient
client = MultiServerMCPClient({"agent_passport": {"command": "npx", "args": ["-y", "@fractalai/agent-passport-mcp"], "transport": "stdio"}})
tools = await client.get_tools()   # verify_passport, issue_passport, lookup_agent
agent = create_react_agent(model, tools)
await agent.ainvoke({"messages": "Verify passport https://fractalai.net.co/attestation/0x…"})

CrewAI (Python) — crewai-tools MCP adapter:

from crewai_tools import MCPServerAdapter
from mcp import StdioServerParameters
params = StdioServerParameters(command="npx", args=["-y", "@fractalai/agent-passport-mcp"])
with MCPServerAdapter(params) as tools:
    Agent(role="Auditor", tools=tools, goal="Verify agent passports", backstory="...")

AutoGen (Python) — autogen-ext MCP workbench:

from autogen_ext.tools.mcp import StdioServerParams, mcp_server_tools
params = StdioServerParams(command="npx", args=["-y", "@fractalai/agent-passport-mcp"])
tools = await mcp_server_tools(params)   # verify_passport / issue_passport / lookup_agent
agent = AssistantAgent("auditor", model_client=client, tools=tools)