The idea in one sentence
Your system does work. pruv proves the work happened.
With pruv
pruv(f)(X) = Y + XY
X is the state before. Y is the state after. XY is the proof.
That's the entire protocol.
What's inside an XY record
XY is a single verifiable record that contains everything needed to prove a state transition occurred:
- X hash — SHA-256 of the state before
- Y hash — SHA-256 of the state after
- Timestamp — when the transition happened
- Signature — optional Ed25519, proving who performed it
- Previous entry — link to the last XY record in the chain
// Simplified XY record structure
{
"id": "xy_8f3a2b1c",
"x_hash": "sha256:a1b2c3d4...",
"y_hash": "sha256:e5f6a7b8...",
"timestamp": "2025-01-15T10:30:00Z",
"signature": "ed25519:...",
"prev_entry": "xy_7e2f1a0b",
"chain_id": "order_processing"
}
Anyone with this record and the original data can recompute the hashes and confirm the proof. No special tools. No pruv account. Standard crypto libraries in any language.
How a chain forms
When Y of one transition becomes X of the next, pruv links them automatically.
Entry 0 Entry 1 Entry 2
┌──────────┐ ┌──────────┐ ┌──────────┐
│ X: - │────▶│ X: Y₀ │────▶│ X: Y₁ │
│ Y: Y₀ │ │ Y: Y₁ │ │ Y: Y₂ │
│ XY: h₀ │ │ XY: h₁ │ │ XY: h₂ │
└──────────┘ └──────────┘ └──────────┘
Each entry includes the previous entry's hash. Change one entry anywhere in the chain and every entry after it becomes invalid. Verification walks the chain and tells you exactly where it broke.
Step by step
1
Capture X
When a state transition begins, pruv snapshots the current state and hashes it. This becomes X. It can be anything — a database record, a file, a balance, an API payload, a configuration.
2
Your code runs
pruv does not modify your logic, intercept calls, or add middleware. Your function executes exactly as it normally would.
3
Capture Y
When the function returns, pruv captures the result and hashes it. Now it has both endpoints of the transition.
4
Generate XY
pruv combines X and Y into a single verifiable record — the XY proof. It links this record to the previous entry in the chain. If signing is enabled, it applies an Ed25519 signature.
One proof per state transition. Chained to everything before it.
Verification
Anyone can verify. Walk the chain, recompute every hash, check every link.
from pruv import verify
# Verify a single entry
result = verify("order_processing", entry_id="xy_8f3a2b1c")
print(result.valid) # True
# Verify an entire chain
chain = verify("order_processing", full_chain=True)
print(chain.length) # 1,247 entries
print(chain.valid) # True — every link intact
No proprietary tools. No vendor dependency. SHA-256 and Ed25519 are implemented in every language on every platform. If you can compute a hash, you can verify a pruv chain.
Properties
Tamper-evident
Any modification invalidates the hash chain. Tampering is mathematically detectable.
Independently verifiable
Anyone can verify using standard crypto libraries. No proprietary tools. No pruv account required.
Local-first
Proofs generated on your machine, synced asynchronously. Works offline. Works air-gapped.
Append-only
Records can only be added, never modified. The chain is a permanent, ordered record of state transitions.
Redaction-safe
Sensitive data can be redacted while preserving cryptographic proof. The hash still verifies.
Language-agnostic
Simple JSON schema. SHA-256 + Ed25519 are universal. Implement in any language.
What pruv covers
pruv.scan
Hash every file in a directory or repository. Produces a deterministic project state fingerprint. Prove exactly what your codebase looked like at any moment.
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.
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.
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.
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.
Framework integrations
Dedicated packages for every major AI agent framework. Install, wrap, ship. Every action recorded automatically. No manual logging. One line of code.
pruv-langchain
Hooks into LangChain's native callback system. Records every tool call, LLM invocation, chain execution, and agent action. Wrap with LangChainWrapper — your agent code stays unchanged.
pruv-crewai
Intercepts CrewAI lifecycle events — crew kickoff, task execution, agent handoffs, tool usage. Wrap with CrewAIWrapper — every crew run produces a verified receipt.
pruv-openai
Implements the OpenAI Agents SDK TracingProcessor protocol. Records tool calls, guardrail checks, agent handoffs, and LLM calls. Wrap with OpenAIAgentWrapper — automatic scope detection from span types.
pruv-openclaw
Config-driven plugin with automatic scope mapping. Hooks into before_action and after_action lifecycle. File reads, writes, executions — all scope-checked and chained.