how it workspricingindustriessecuritydocsgithubSign inGet started →

digital verification infrastructure.

The digital world has no
verification layer.

Every system — every pipeline, every payment, every agent, every workflow — runs on trust. Trust in logs. Trust in databases. Trust in whoever ran the process.

That trust is manufactured. State changed. Prove it.

$ pip install pruv
view docs →scan a repo →
the gap

Every system logs what happened. No system proves it.

Logs
“Here's what happened, trust us”
Traces
“Here's the flow, trust our database”
pruv
“Here's cryptographic proof — verify it yourself”

Logs can be edited. Databases can be altered. pruv chains are cryptographically linked — tamper with one entry and the chain breaks. Verification reports exactly where.

the protocol in 30 seconds

Create a chain. Add entries. Verify.

python
from pruv import Chain

chain = Chain("invoice-trail")

chain.add("invoice_created", {"id": "INV-0042", "amount": 240.00})
chain.add("payment_received", {"method": "ach", "ref": "TXN-8812"})
chain.add("receipt_issued", {"to": "sarah@company.com"})

chain.verify()
# ✓ 3 entries · chain intact · tamper-proof
chain output
invoice-trail
pruv.scan

Hash every file. Get a verified fingerprint.

Hash every file in a directory or repository. Produces a deterministic project state fingerprint. Prove exactly what your codebase looked like at any moment.

terminal
$ pruv scan ./my-project

  Services (3)
    ✓ FastAPI backend     python   port 8000
    ✓ Next.js frontend    typescript
    ✓ Stripe webhook      external

  Connections
    frontend → backend    via NEXT_PUBLIC_API_URL
    backend → Supabase    via DATABASE_URL
    backend → Stripe      via STRIPE_SECRET_KEY

  Env Vars
    9 defined · 1 missing · 2 shared

  Graph hash: a7f3c28e91b4

No code changes. No integration. Point it at a codebase and get a verified architecture map.

pruv.identity

A passport for AI agents.

Register with declared owner, permissions, and validity period. Every action checked against scope. Receipt shows what it did and whether it stayed in bounds.

python
from pruv.identity import register, act, verify

agent = register(
    name="deploy-bot",
    agent_type="openclaw",
    owner="ops-team",
    scope=["file.read", "system.execute"],
    valid_until="2026-06-01"
)

act(agent, "deploy", {"env": "production", "tag": "v2.4.1"})
receipt = verify(agent)   # in-scope, signed, tamper-evident
pruv.provenance

Chain of custody for any digital artifact.

Origin captured. Every modification recorded — who touched it, why, what it looked like before and after. Tamper-evident. Independently verifiable.

python
from pruv.provenance import track

doc = track("contract-v3.pdf", origin="legal-team")
doc.modify(actor="counsel", reason="clause 4.2 revision")
doc.modify(actor="cfo", reason="final approval")
doc.export_receipt()   # full chain of custody, verifiable
pruv.checkpoint

Time travel for any system state.

Every chain entry captures what your system was at that exact moment. Open any entry, see state before and after, restore to any prior verified state. Recovery is no longer expensive or uncertain.

python
from pruv import CheckpointManager

manager = CheckpointManager(chain, project_dir="./my-project")

checkpoint = manager.create("before-refactor")

# Something goes wrong — restore to verified state
manager.restore(checkpoint.id)

# Or undo the last action
manager.quick_undo()
pruv.receipts

Every operation produces a receipt.

Not a log. Not an assertion. Proof anyone can verify independently — no account required, no trust required in pruv. Export as PDF. Share via link. Embed as badge.

receipt
actionpayment_captured
chainorder-7291
sequence#3 of 6
timestamp2026-02-15T12:00:03.201Z
hash
b1c43e7d9a4f2b8c1d5e6f7a8b9c0d1e
previous
7d2e9a4f3c8b1d6e5f2a7c4b9d0e8f1a
✓ verified

This receipt is cryptographically linked to every entry before it. Tamper with any entry and this receipt becomes invalid.

The proof stands on its own.

framework integrations

One line. Every agent action recorded.

Dedicated packages for every major agent framework. Install, wrap, ship. No manual logging. Every action chained. Every receipt on demand.

bash
$ pip install pruv-langchain    # LangChain
$ pip install pruv-crewai       # CrewAI
$ pip install pruv-openai       # OpenAI Agents
$ pip install pruv-openclaw     # OpenClaw
python — langchain
from pruv_langchain import LangChainWrapper

wrapped = LangChainWrapper(agent, agent_id="agent-id", api_key="pv_live_...")
result = wrapped.invoke({"input": "deploy to production"})
receipt = wrapped.receipt()   # full chain of every tool call, LLM call, handoff
python — crewai
from pruv_crewai import CrewAIWrapper

wrapped = CrewAIWrapper(crew, agent_id="agent-id", api_key="pv_live_...")
result = wrapped.kickoff()
receipt = wrapped.receipt()   # every task, every agent handoff, verified
python — openai agents
from pruv_openai import OpenAIAgentWrapper

wrapped = OpenAIAgentWrapper(agent, agent_id="agent-id", api_key="pv_live_...")
result = await wrapped.run("analyze the quarterly report")
receipt = wrapped.receipt()   # tool calls, guardrails, handoffs — all chained
python — openclaw
from pruv_openclaw import PruvOpenClawPlugin

plugin = PruvOpenClawPlugin(agent_id="agent-id", api_key="pv_live_...")
# Config-driven — hooks into before_action / after_action automatically
receipt = plugin.receipt()   # file reads, writes, executions — scope-checked
anomaly detection

pruv doesn't just record. It watches.

Anomaly detection runs on the proof chain itself.
Set severity thresholds. Get webhook alerts.
If something unusual happened, you'll know — and you'll have the proof.

how the protocol works

Every operation transforms state. pruv captures both sides.

1
Something happens in your system
A payment, a deploy, a data change — any operation that transforms state.
2
The state before and after are hashed (SHA-256)
Before state, after state, operation, timestamp — all hashed together.
3
The hash includes the previous entry's hash
Creating a chain. Break one entry, the chain breaks.
4
A signed receipt is stored
Ed25519 digital signature. Independently verifiable by anyone.

Same principle that secures blockchains.
Without the blockchain.

No tokens. No mining. No gas fees. No consensus.
Just math.

cloud optional

The protocol runs locally. Zero dependencies. Works offline. Works forever.

The cloud adds the dashboard, team collaboration, shareable receipts, and PDF export. It's optional.

bash
$ pip install xycore    # protocol only, zero deps
$ pip install pruv      # full SDK with cloud

The protocol belongs to nobody. The infrastructure is the product.

State changed. Prove it.

$pip install pruvcopy
docs.pruv.devget startedapp.pruv.devdashboardgithubsource