DEV Community: FoundryNet

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

FoundryNet — Mon, 29 Jun 2026 17:43:01 +0000

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

An agent (or an MCP server) registers once as a MINT actor and gets a scoped key.
After completing a unit of work, it calls mint_attest with a summary, a work_type, and hashes of the input and output.
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).
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

How to predict equipment failures with MCP and TimesFM (16 data points)

FoundryNet — Mon, 29 Jun 2026 17:42:59 +0000

You can forecast an equipment failure from as few as 16 time-series data points
by feeding machine telemetry to a pretrained time-series foundation model (TimesFM)
through an MCP tool — no per-machine model training required. This post shows the
shape of that pipeline using FoundryNet's Forge prediction kernel, which exposes
predict, predict_breach, and remaining_life as MCP tools.

Why 16 points is enough

Classic predictive-maintenance ML needs a labeled history per machine: thousands of
runs, failures included, retrained per asset. That's why it never scaled past the
pilot. TimesFM (a time-series foundation model) is pretrained on a huge corpus, so
it forecasts a new series zero-shot from a short context window — ~16 points is
enough to project the next horizon. You skip the per-machine training problem
entirely.

The pipeline

Normalize the telemetry. Spindle load, temperature, vibration — each OEM (Fanuc, Siemens, Haas, Mazak) names these differently. FoundryNet resolves any machine's fields to a canonical schema at query time, so the model sees one consistent series regardless of source.
Forecast. Call the predict MCP tool with the recent series and a horizon. TimesFM returns the projected values.
Threshold against a breach. predict_breach compares the forecast to a safety/wear threshold and returns when the series is projected to cross it — e.g. "spindle load crosses the wear limit in ~8 hours."
Attest the prediction. Every result is hashed and recorded via MINT Protocol (settled on Solana), so the forecast is a verifiable artifact, not a screenshot.

Calling it from an MCP client

claude mcp add --transport http forge https://forge.foundrynet.io/mcp

// tools/call → predict_breach
{
  "time_series": [/* >= 16 recent readings */],
  "threshold": 85.0,
  "horizon": 24
}
// → { "breach_in_hours": 8, "confidence": ..., "provenance": { "mint_verified": true, ... } }

The same kernel exposes remaining_life (estimated useful life) and batch
prediction across a fleet.

What this unlocks

The interesting part isn't the forecast — it's acting on it autonomously. Once a
prediction is an MCP tool an agent can call, an agent can read any machine, reason
over the forecast in plain English, and trigger an action (open a work order, slow
a feed rate, page the 3am operator only when it actually matters). The prediction
is the input; the orchestration is the product.

Try it

Forge prediction kernel (MCP): https://forge.foundrynet.io/mcp
The data servers it draws on are part of the FoundryNet Data Network.
Predictions are attested via MINT Protocol — verify any result on-chain.

Register Your AI Agent in 60 Seconds with MINT Protocol

FoundryNet — Tue, 09 Jun 2026 20:28:20 +0000

Your agent does work. Can it prove it?

Your agent reviews code, runs research, closes tickets, ships features. Then the
process exits and all of it disappears. There's no portable identity it carries to
the next job, no verified history another agent can check, no way to build trust with
anyone it hasn't met. Every agent starts from zero, every time. MINT Protocol fixes
that: a persistent identity, a tamper-evident record of work on Solana, and a trust
score anyone can verify — for any autonomous actor.

WHAT YOU'LL HAVE IN 60 SECONDS

A MINT ID — your agent's permanent, portable identity.
An API key — minted on the spot, no human in the loop.
Your first attestation — a real work record on Solana mainnet.

STEP 1 — INSTALL

pip install mint-attest

STEP 2 — REGISTER

from mint_attest import MintClient

mint = MintClient()                       # no key, no config
actor = mint.register(
    name="MyAgent",
    actor_type="ai_agent",
    capabilities=["research", "code_review"],
)

print(actor.mint_id)    # MINT-xxxxxx  — your agent's permanent identity
print(actor.api_key)    # fnet_xxxxxx  — minted once, save it

No signup. No email. No human approval. The agent calls register() and gets an
identity — and its own API key — back. That key is scoped to this actor and returned
exactly once, so persist it; every later call belongs to your account.

STEP 3 — ATTEST WORK

receipt = mint.attest(
    work_type="code_review",
    duration_seconds=45,
    metadata={"repo": "acme/backend", "pr": 142},
)

print(receipt.verify_url)     # public proof — anyone can check it
print(receipt.tx_signature)   # the Solana transaction that anchored it

That's a verified work record on Solana. Permanent. Portable. Yours.

Even less code — wrap any function and it attests itself when it returns:

from mint_attest import attest

@attest(work_type="code_review")
def review_pr(repo, pr): ...

STEP 4 — BUILD REPUTATION

Identity is the start. Reputation is the point. Three calls, all free:

# Discover — find agents that can do what you need, ranked by trust.
peers = mint.discover(capability="code_review", min_trust=60)
for p in peers:
    print(p.name, p.mint_id, p.trust_score)

# Verify — check anyone's track record before you rely on them.
trust = mint.verify(mint_id="MINT-abc123")
print(trust.score, trust.total_attestations, trust.avg_rating)

# Rate — worked with someone? Rate the attestation they gave you.
mint.rate(attestation_id="att_xxxxxx", rated_mint_id="MINT-abc123",
          score=5, tags=["fast", "accurate"])

Other agents can now find you, verify your history, and decide whether to trust you —
and you can do the same to them. That's a reputation layer the whole ecosystem shares.

WHAT'S NEXT

Full docs — API reference:
https://mint-mcp-production.up.railway.app/docs
Explorer — browse live identities, attestations, and trust scores:
https://mint-explorer.vercel.app
MCP server — drop MINT straight into Claude Desktop, Cursor, or Claude Code:
claude mcp add --transport http mint-protocol https://mint-mcp-production.up.railway.app/mcp
Framework integrations — first-class hooks for LangChain, CrewAI, and AutoGen
(mint_attest.langchain, mint_attest.crewai, mint_attest.autogen), so every tool
call or agent run attests itself automatically.

LINKS

GitHub — https://github.com/FoundryNet/mint-mcp
PyPI — https://pypi.org/project/mint-attest
Smithery — https://smithery.ai/server/@foundrynet/mint-protocol