What is MINT Protocol? Verifiable proof-of-work for AI agents

MINT Protocol is a verifiable attestation layer for AI agents: when an agent
does a piece of work, MINT records a tamper-evident proof of what was done,
when, and by whom, and anchors it on the Solana blockchain. The output isn't
on-chain — a cryptographic hash of it is — so anyone can later verify that a result
was produced by a specific agent and hasn't been altered, without trusting a
screenshot or a vendor's dashboard.

The problem MINT solves

The agent economy has a trust hole. Agents now call tools, query data, and take
actions — but their outputs are unverifiable. If an agent tells you "I analyzed
NVDA across 17 data sources and the risk score is 62," you have no way to confirm
it actually did that, or that the number wasn't edited afterward. Everyone is
building agents. Almost nobody is verifying their work. As more economic value
flows through autonomous agents, "trust me" stops being good enough.

How MINT works

1. An agent (or an MCP server) registers once as a MINT actor and gets a scoped key.
2. After completing a unit of work, it calls mint_attest with a summary, a work_type, and hashes of the input and output.
3. MINT records the attestation and batches many attestations into one Merkle root, which is anchored to Solana with a single memo transaction (~0.000005 SOL per batch instead of a transaction per attestation).
4. Anyone can call mint_verify (or open the public feed at mint.foundrynet.io/feed) to confirm the proof and its Merkle inclusion.

Because only hashes are anchored, no private data ever touches the chain.

Using it from an MCP client

MINT ships as an MCP server (Streamable HTTP), so any MCP-capable client —
Claude Desktop, Cursor, Claude Code — can attest work with three tools:
mint_register, mint_attest, mint_verify.

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

There's also a Python decorator for non-MCP code (mint-attest on PyPI):

from mint_attest import attest

@attest(work_type="analysis", summary="risk scoring run")
def score_company(ticker: str) -> dict:
    ...

Every call records a proof and returns a public Solscan verify URL.

Where it runs today

MINT is the attestation layer under the FoundryNet Data Network — a fleet of
MCP data servers (financial-signals, cyber-intel, compliance, weather/supply-chain
risk, and more) plus a prediction kernel (Forge + TimesFM). Those servers attest
their paid query results through MINT, so a buyer can independently verify the
data they paid for. The live feed runs ~100+ verified attestations a day across
the network, all anchored on Solana mainnet.

Why it matters

Agents ate consumer software. The factory floor and the back office are next. But
autonomy without verification is just unaccountable automation. MINT Protocol is
the missing receipt: a way for agents to prove their work to each other and to the
humans who pay for it.

Learn more: mint.foundrynet.io ·
Live feed: mint.foundrynet.io/feed