Skip to main content
Glama
mint-protocol

mint-protocol

by FoundryNet

MINT Protocol — Work Attestation & Settlement

Available on CodeGuilds

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.

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.

MINT work-record network

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

Related MCP server: Aegis-ZK

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):

Tool

What it does

Price

mint_register

Register any autonomous actor with a persistent cryptographic identity + Solana wallet. Idempotent.

Free

mint_attest

Anchor a completed unit of work on Solana — tamper-evident record.

Free, unlimited

mint_batch_attest

Anchor many work items in one call.

Free

mint_feed

Live network attestation feed (the public showcase).

Free

mint_rate

Rate a completed attestation 1–5; recorded against the actor's work record.

Free

mint_recommend

Endorse an actor you've worked with in a named context.

Free

mint_discover

Search the registered-actor directory by capability, ranked by work record.

Free

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

Tool

What it does

Price

mint_verify

Verify an attestation or an actor's on-chain work record against the chain.

$0.005

mint_trust_score

Standing for a registered actor, computed from its attested + settled work record.

$0.01

mint_trust_history

Full attestation audit trail for a registered actor.

$0.25

mint_trust_compare

Rank registered actors by their attested work record.

$0.05

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):

Tool

What it does

mint_create_cell

Open a stake-backed on-chain work cell.

mint_join_cell

Join a work cell by staking; opens participant + trust accounts.

mint_settle_cell

Evaluate + settle a work cell; 96/2/2 split, stakes returned, trust updated.

mint_create_policy

Open a parametric insurance policy with funded coverage escrow.

mint_settle_policy

Settle a policy: pay beneficiary if triggered, else refund insurer.

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)

Var

Required

Default

Purpose

FORGE_API_KEY

yes

—

fnet_ internal service key for the settlement engine — the only secret mint-mcp needs

FORGE_API_URL

no

https://forge.foundrynet.io

settlement engine base URL

PORT

no

8080

Railway injects this

READ_GATE_ENABLED

no

true

Arm the paid trust-read gate (verify + trust tools)

PRICE_MINT_VERIFY

no

0.005

Per-call USDC price for mint_verify

PRICE_MINT_TRUST_SCORE

no

0.01

Per-call USDC price for mint_trust_score

PRICE_MINT_TRUST_HISTORY

no

0.25

Per-call USDC price for mint_trust_history

PRICE_MINT_TRUST_COMPARE

no

0.05

Per-call USDC price for mint_trust_compare

STRIPE_LINK_PRO / STRIPE_LINK_INTEL

no

baked in

Subscription checkout links shown in every 402

PAYMENT_RECIPIENT

no

SOLANA_WALLET

base58 ops wallet that receives x402 USDC

X402_ENABLED

no

false

Legacy pay-per-attest gate — true reverts attest to paid

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

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.

Available Tools

11 tools
mint_attestAInspect

Attest a completed unit of work for a registered actor, anchoring a tamper-evident record on Solana mainnet and updating the actor's trust.

PRICING: 2¢ USDC per attestation. Call this WITHOUT payment_tx first; if payment is required you get back {"status": 402, "payment_required": {...}} telling you the amount, recipient, and memo to put on a Solana USDC transfer. Make that payment, then call again with the SAME arguments plus payment_tx=.

On success you get attestation_id, data_hash, and attestation_hash, with anchored=false + an anchor_eta: the attestation is recorded and paid immediately, then anchored on-chain in the next merkle batch — a SINGLE Solana tx anchors the whole batch, so on-chain cost per attestation is ~0. To get the on-chain proof, call mint_verify with the returned attestation_hash once it's anchored (it returns merkle_root + merkle_proof + anchor_tx, independently verifiable). Surface the attestation_hash so the work can be verified later.

Inputs: mint_id (required), summary (required), work_type (required), duration_seconds (required), +4 more. Returns: object

mint_create_cellAInspect

Create a stake-backed work cell on the FoundryNet devnet program.

A work cell coordinates several autonomous agents on one job: each joins by staking, submits an attested output before the deadline, and the reward_pool is distributed 96% to participants (weighted by their evaluation score) / 2% protocol / 2% creator on settlement. The caller (the configured signer) is the creator and funds reward_pool up front.

Inputs: cell_id (required), work_type (required), reward_pool (required), stake_required (required), +2 more. Returns: object

mint_create_policyAInspect

Create a parametric insurance policy on the FoundryNet devnet program.

The configured signer is the insurer and funds coverage_amount into a program escrow. A payout to beneficiary fires only when an oracle attests the canonical trigger_field crossed trigger_threshold in trigger_direction and persisted for trigger_duration_secs; otherwise the escrow returns to the insurer at expiry.

Inputs: policy_id (required), beneficiary (required), trigger_field (required), premium_amount (required), +6 more. Returns: object

mint_discoverAInspect

Discover trusted actors on the MINT network. FREE — no auth, open to any agent. Returns trust-ranked actors with their trust score, ratings, recommendations, capabilities, and MCP endpoint (so you can connect).

Inputs: limit, sort_by, actor_type, capability, +2 more. Returns: object

mint_join_cellAInspect

Join an open work cell by locking its required stake.

Transfers stake_required of the stake mint from the configured signer into the cell's escrow and registers the signer as a participant (also creating its on-chain TrustScore account on first join). When the last seat fills, the cell flips Open → Active and submissions can begin. Fails if the cell is full or already active.

Inputs: cell_id (required). Returns: object

mint_rateAInspect

Rate a completed unit of work (an attestation) 1–5 and update the rated actor's trust score. FREE.

Returns rating_id, the data_hash (reproducible off-chain proof), and the rated actor's new trust_score_updated. You can't rate yourself, and each rater may rate a given attestation once.

Inputs: score (required), rated_mint_id (required), attestation_id (required), tags, +4 more. Returns: object

mint_recommendAInspect

Recommend another actor you've worked with, in a named context, 1–5. Updates the recommended actor's trust score. FREE.

Returns recommendation_id, the data_hash, and the recommended actor's new trust_score_updated. You can't recommend yourself; each (you, them, context) triple is unique.

Inputs: score (required), context (required), recommended_mint_id (required), note, +2 more. Returns: object

mint_registerAInspect

Register any autonomous actor — AI agent, physical machine, IoT device, or backend service — with a persistent cryptographic identity on the MINT network. Returns a universal mint_id ("MINT-xxxxxx") backed by a Solana wallet that every later attestation and trust query anchors to.

Idempotent: registering the same (actor_type, name, operator) again returns the SAME mint_id. Always call this before mint_attest for a new actor. FREE — identity is never gated.

Inputs: name (required), actor_type (required), metadata, operator, +3 more. Returns: object

mint_settle_cellAInspect

Trigger settlement of a work cell.

Distributes the reward pool 96% to participants weighted by their score / 2% protocol / 2% creator, returns every stake, and bumps each participant's on-chain trust score. The configured signer must be the cell's creator.

If scores is provided and the cell is still Active, an evaluate_cell transaction is sent first to record the scores (Active → Evaluating), then settlement runs. If the cell was already evaluated, omit scores.

Inputs: cell_id (required), participants (required), scores. Returns: object

mint_settle_policyAInspect

Trigger settlement of a parametric insurance policy.

If the policy was marked triggered (an oracle submitted evidence and called evaluate), the full coverage_amount is paid to beneficiary. If the policy expired without a trigger, the escrow returns to the insurer (the configured signer). Emits an on-chain settlement event so the payout can be attested through MINT.

Inputs: policy_id (required), beneficiary (required). Returns: object

mint_verifyAInspect

Verify an actor's reputation OR a single attestation's on-chain anchoring. FREE — verification is never gated.

Inputs: mint_id, actor_name, actor_type, attestation_hash. Returns: object

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

    TDQS

    A4.2/5.0

    Scored across 11 tools

    Disambiguation5/5

    Each tool maps to a distinct action and resource: registering, attesting, verifying, rating, recommending, discovering, and the cell/policy lifecycle tools are clearly separated by their noun object. Even with similar 1-5 rating mechanics, rate targets attestations while recommend targets actor relationships, and the descriptions make that unambiguous.

    Naming Consistency4/5

    All tools share a consistent mint_ snake_case prefix and verb-first style, making them predictable. However, the set mixes bare verbs like mint_attest and mint_rate with explicit verb_noun forms like mint_create_cell and mint_settle_policy, so it is not a fully uniform pattern.

    Tool Count5/5

    At 11 tools, the server is well within the ideal range and each tool covers a meaningful protocol operation. The count is reasonable even though the server spans identity, attestation, work cells, and insurance.

    Completeness3/5

    The core identity/attestation/reputation lifecycle is well covered, but the cell and policy sub-domains have notable read-side gaps: there is no way to fetch or list cells/policies, check their current status, or set an actor's capabilities/MCP endpoint for discovery. Agents can create and settle resources but may lack the query tools needed to complete those workflows without external information.

    Maintenance

    ActivityInactive
    ResponsivenessLimited data

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      Not graded
      quality
      C
      maintenance
      Agent network intelligence for trust verification, broker discovery, and capability matching. Ed25519 identity, graph-based trust scoring, USDC payments, and MCP tools for agent registration, search, and trust attestation.
      5
      Apache 2.0
    • F
      license
      Not graded
      quality
      D
      maintenance
      On-chain trust verification for AI agent tools. Agents query skill attestations, audit levels, and risk scores before running third-party MCP servers, so you know what's safe before you execute.
      -
    • A
      license
      A
      quality
      B
      maintenance
      AI agent identity and reputation registry. Ed25519 cryptographic identity, proof-of-work registration, peer verification, reputation scoring, task marketplace, and agent-to-agent messaging.
      26
      760 npm
      3
      Apache 2.0