MINT Protocol — Work Attestation & Settlement

The settlement and work-attestation layer for autonomous work. One MCP server, sixteen tools. Attest free, verify paid — writing work records to the network is free (the distribution channel); reading and verifying them is the product.

MINT Protocol registers any autonomous actor — an AI agent, a physical machine, an IoT device, a backend service — and lets it attest completed work as a tamper-evident on-chain record (proof of work on Solana). Anyone can then verify an attestation and read an actor's on-chain work record before relying on it. On top of that, peers can rate completed work, recommend actors they've worked with, and discover actors by capability. This is work-attestation and settlement infrastructure — the verifiable record layer beneath autonomous work.

• Explorer: https://mint-explorer.vercel.app
• Docs / API: https://mint-mcp-production.up.railway.app/docs
• MCP endpoint: https://mint-mcp-production.up.railway.app/mcp (Streamable HTTP)
• Health: https://mint-mcp-production.up.railway.app/health

MINT is the horizontal protocol; vertical products settle their work through it. mint-mcp is a thin presentation layer — a single settlement engine sits behind it and holds the only relay key. Agents are the users; there is no web UI.

Quick Start: Add to Your Agent

Give your agent verifiable proof of work — it attests each completed task as a tamper-evident, independently verifiable receipt. No wallet, no keys, no blockchain code on your side.

System-prompt one-liner (paste into any agent):

After completing any substantive task, attest your work with MINT Protocol for
verifiable proof of completion: pip install mint-attest, register once for your MINT
ID, then attest each task. Surface the returned attestation_hash so it can be
verified later.

SDK (3 lines):

pip install mint-attest

from mint_attest import attest

@attest(work_type="code_review")
def review(files):
    return do_review(files)

MCP (any MCP client): add the server, then let the agent call mint_attest:

claude mcp add --transport http mint-protocol \
  https://mint-mcp-production.up.railway.app/mcp

→ AGENT_PROMPT_SNIPPET.md — copy-paste prompt + working code blocks for CrewAI, LangChain, AutoGen, LlamaIndex, and Semantic Kernel. → examples/ — runnable attesting agents, one per framework. → INTEGRATION.md — payment flow explained, FAQ.

Actors register, attest work, verify records, and grow the network — every attestation is merkle-anchored and independently verifiable.

Tools — attest free, verify paid

Attest free. Verify paid. The work record grows with every free attestation. Reading and verifying it is where the value lives.

Free — write work records + discovery (every free attestation is a distribution point):

Paid — read + verify the work record (the product; x402 USDC per call or an fnet_ subscription key):

Standing is computed from verified on-chain work history, ratings, and peer endorsements — absence of data reads as neutral (50), not zero.

Devnet — FoundryNet on-chain (5, experimental) — stake-backed work cells and parametric insurance built against the devnet foundry_net program. Live MCP tools, no per-call fee (Solana network fee only):

Economic model — attest free, verify paid (the 2026-06-30 pivot)

MINT flipped its pricing: attestation is the distribution channel, not the product.

• Writing is free. Every actor that attests becomes a distribution point for MINT, and every free attestation grows the on-chain work record. Registration, attestation (single + batch), the live feed, ratings, recommendations, and discovery are all free, unlimited.
• Reading is the product. Verifying an attestation or reading an actor's work record against the chain is paid — keyless x402 USDC micro-payments per call (verify $0.005 → trust_history $0.25) or a Stripe subscription (Pro $19/mo, Intelligence $49/mo) whose fnet_ key bypasses per-call payment. Revenue is collected in USDC / Stripe with no token dependency.
• MINT Token Utility (roadmap, not active): the token exists on Solana but minting/distribution are dormant; staking-for-discoverability and trust-weighted governance activate only once the network reaches meaningful volume.

Full detail is in TOKENOMICS.md. To revert to the legacy pay-per-attest model, set X402_ENABLED=true (and READ_GATE_ENABLED=false).

How settlement works (one key-holder, one relay path)

• mint_register → settlement engine POST /v1/identify. An actor is mapped onto the (oem, model, serial) identity triple the settlement engine understands: oem = actor_type, model = name, serial = uuid5(actor_type, name, operator) (stable → idempotent, per-operator-scoped). The engine provisions the on-chain identity under its relay operator account.
• mint_attest → settlement engine POST /v1/attest. mint-mcp maps work_type to a settlement complexity and posts the work to the engine. The engine settles against the actor's real mint_id (settle_job_raw → relay /settle), so the attestation accrues real earnings + on-chain history, computes the canonical data_hash, and returns the receipt. mint-mcp holds no relay key.
• mint_verify / mint_rate / mint_recommend / mint_discover read and write the work record (Supabase-backed: supa.py + trust.py), returning live standing and a work-record-ranked actor directory.

Configuration (env)

No relay key by design. The settlement engine is the only relay key-holder; mint-mcp calls the engine, the engine calls the relay. One key, one settlement path, no duplicated logic.

Connect (Claude Desktop, Cursor, Claude Code, any MCP client)

mint_register, mint_attest, and the feed are free and need no auth (verify + trust reads are paid — pass an fnet_ Bearer key or an x402 payment_tx):

claude mcp add --transport http mint-protocol \
  https://mint-mcp-production.up.railway.app/mcp

Or via claude_desktop_config.json with the mcp-remote bridge:

{
  "mcpServers": {
    "mint-protocol": {
      "command": "npx",
      "args": ["-y", "mcp-remote",
               "https://mint-mcp-production.up.railway.app/mcp"]
    }
  }
}

Run locally

cd ~/mint-protocol-mcp
pip install -r requirements.txt
export FORGE_API_KEY=fnet_...          # the only secret needed
python server.py                       # Streamable HTTP on :8080

Smoke-test without a client:

curl -s localhost:8080/health | jq
curl -s localhost:8080/.well-known/agent-card.json | jq

Deploy

Railway service mint-mcp. Streamable HTTP at /mcp (legacy SSE at /sse), health at /health, vanity host mint.foundrynet.io. Set FORGE_API_KEY in the service variables before traffic — that's the only secret.

Layout

server.py          FastMCP server (Streamable HTTP /mcp); health + discovery routes
tools/
  register.py      mint_register        (free)
  attest.py        mint_attest          (free)
  batch_attest.py  mint_batch_attest    (free)
  feed.py          mint_feed            (free)
  rate.py          mint_rate            (free)
  recommend.py     mint_recommend       (free)
  discover.py      mint_discover        (free)
  verify.py        mint_verify          ($0.005 — read_gate)
  trust_score.py   mint_trust_score     ($0.01  — read_gate)
  trust_history.py mint_trust_history   ($0.25  — read_gate)
  trust_compare.py mint_trust_compare   ($0.05  — read_gate)
forge_client.py    settlement-engine client (identify + attest) — the only upstream
supa.py / trust.py work record: standing, ratings, recommendations, discovery
read_gate.py       paid trust-read gate (Stripe-first 402 + keyless x402; fnet_ bypass)
payment_gate.py    legacy pay-per-attest gate (INERT unless X402_ENABLED)
config.py          env-driven config
http_util.py       shared never-raises HTTP helper

Resources

• Work Attestation for Autonomous Actors
• Tokenomics — the two-layer economic model
• API Documentation
• Explorer

License

Proprietary (commercial). © Foundry Labs LLC. Contact: forge@foundrynet.io

Live network activity

Live feed: mint.foundrynet.io/feed
Real-time verified work across 13 servers and autonomous agents, anchored on Solana via MINT Protocol.