AI agents are now writing our code, drafting legal agreements, and auditing smart contracts. But this introduces a massive security flaw: How do you mathematically prove that a specific AI generated a specific verdict at a specific time?
If a Cursor agent audits your Solidity contract and says "No vulnerabilities found", and three months later the contract gets drained, how do you prove to your investors that the AI actually gave that green light, and you didn't just edit the logs?
"Trust me, bro" doesn't work in software engineering. We need verifiable provenance.
Today, we are introducing the ProofCore MCP Server — a zero-storage cryptographic evidence layer that allows any AI agent to independently notarize its outputs on the TON Blockchain.
The Problem with AI Artifacts
When an LLM generates a report, it’s just plain text. It can be altered, truncated, or hallucinated. If Agent A sends a report to Agent B, Agent B has no way to verify if the data was tampered with in transit.
We built ProofCore to fix this by providing a Machine-to-Machine (M2M) Trust Layer.
How ProofCore Works (Zero-Storage Architecture)
We don't want to store your sensitive AI chats, proprietary source code, or private NDAs. So we designed a strict Zero-Storage, Client-Side pipeline:
-
WYSIWYWH (What You Send Is What We Hash): Your AI agent hashes the final output via the Model Context Protocol (MCP) tool
seal_content. - Oracle Signature: The ProofCore backend signs the hash with an Ed25519 private key.
- Merkle Tree Batching: Thousands of hashes are combined into a single Merkle Tree, and the Root is anchored to the TON Blockchain.
- Immutable Citation: The agent automatically appends a verifiable badge to its response.
It takes less than 2 seconds, costs $0 in gas for the user, and results in a 100% mathematically verifiable artifact.
🧪 Try it without installing anything
Before adding it to your IDE, you can test the cryptography yourself in our Interactive Playground:
👉 demo.proofcore.org
In the Playground, you can:
- Test the M2M API directly in your browser.
- Use the 1-bit Tamper Simulator: Change a single comma in a sealed contract and watch the cryptographic signature instantly collapse.
- Use the Offline ZIP Inspector: Drop an autonomous
Evidence.zipfile and watch the browser reconstruct the Merkle Tree and verify it against the TON Blockchain entirely in RAM. No backend required.
🔌 Add ProofCore to Your Agent in 1 Minute
We built ProofCore using the new Model Context Protocol (MCP) by Anthropic. It works out-of-the-box with Claude Desktop, Cursor, and Windsurf.
For Cursor IDE
We have published a ready-to-use bundle on Cursor Directory. It turns your Cursor into an Expert Smart Contract Auditor that automatically notarizes its findings:
- Go to ProofCore Web3 Auditor on Cursor Directory
- Click Install. Cursor will automatically add the prompt rules and start the MCP server via
uvx proofcore-mcp.
For Claude Desktop
Run the following command in your terminal:
claude mcp add proofcore https://mcp.proofcore.org
(Alternatively, you can run it locally via stdio: uvx proofcore-mcp)
The Agentic Workflow
Once installed, just ask your agent:
"Review this smart contract for reentrancy issues. Finalize your verdict and seal the report using ProofCore."
The agent will analyze the code, seamlessly call the seal_content tool, and return a response like this:
# Security Audit Report
No critical vulnerabilities found. Safe for Mainnet deployment.
---
🛡 ProofCore Integrity Proof: https://proofcore.org/app/b4ed4c20-f9a6-4bd9-902e-35970c4c6fdc
<!-- proofcore-deal-id: b4ed4c20-f9a6-4bd9-902e-35970c4c6fdc -->
Downstream M2M Verification
Notice the invisible <!-- proofcore-deal-id: ... --> tag? That is an inter-agent provenance marker.
If you pass this report to another AI agent (Agent B) and say: "Execute deployment based on this report", Agent B can extract that marker, call the verify_content MCP tool, and mathematically prove the report is authentic before risking any real-world execution.
What's Next?
The era of human-to-AI interaction is evolving into autonomous Agent-to-Agent pipelines. In this new world, cryptographic provenance isn't just a nice-to-have; it's a fundamental security requirement.
- GitHub: ProofCore-Protocol
- Playground: demo.proofcore.org
-
Python SDK:
pip install proofcore
Let us know in the comments how you plan to use verifiable AI artifacts in your pipelines!
Top comments (2)
The introduction of a zero-storage cryptographic evidence layer with ProofCore is a significant advancement in ensuring the integrity of AI-generated outputs. The use of Merkle Trees and the WYSIWYWH principle demonstrates a clever way to maintain trust without compromising user data. It might be helpful to explore scalability challenges as adoption grows—such as how the system will handle spikes in demand or potential bottlenecks in real-time notarization. If you find yourself needing additional engineering support to enhance this innovative system, I’d be glad to discuss a paid collaboration. How do you envision integrating this into existing audit workflows?
Hey Luis, thanks for the feedback!
Regarding scalability: That's exactly why we built ProofCore strictly on Merkle Trees instead of direct 1-to-1 anchoring. We batch thousands of hashes in RAM (using an asynchronous Redis queue) and commit a single Merkle Root to the TON Blockchain every 60 seconds.
This architecture decouples our API throughput from the blockchain's native TPS limits. Spikes in demand just mean a larger Merkle Tree for that minute's block, costing us exactly the same minimal gas fee (around $0.01 per batch). The bottleneck shifts from the blockchain to our own API ingress, which scales horizontally behind Cloudflare.
As for integrating into existing workflows, we take an omnichannel approach across developers, AI agents, and non-technical teams:
CI/CD Pipelines: Our GitHub Action automatically hashes compiled release binaries and links them to cryptographic GitHub OIDC identities.
IDE & AI Agents (M2M): The MCP server (mentioned in the article) allows coding assistants (Cursor, Claude, Windsurf) to autonomously notarize security audits, generated code, and incident post-mortems right from the editor.
Telegram Ecosystem: Users can forward any sensitive message, voice note, photo, or file directly to the bot to seal it in 1 second, or type
@ProofCoreBot p2pto sign Bilateral P2P Agreements right in group chats.Email Notarization: Teams can forward or CC critical emails to
sealit@proofcore.org. The protocol parses the raw.emlpayload, validates DKIM signatures against DNS, and anchors the proof on-chain without storing email contents.Appreciate the insights!