Stop Trusting AI Audits Blindly: Adding Cryptographic Provenance to Cursor & Claude via MCP

ProofCore Protocol — Fri, 28 Aug 2026 07:37:24 +0000

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.zip file 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  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!

DEV Community: ProofCore Protocol