and legal review
The trust layer
for autonomous
AI agents
Agents act. PiQrypt proves what they did. Cryptographic identity, hash-chained events, real-time governance — offline-verifiable, cross-framework, designed for audit and legal review.
AI agents need a provable history
Autonomous agents now move money, trigger API calls, and coordinate multi-agent workflows — without a human in the loop. Traditional logs are forgeable and not designed for legal or regulatory scrutiny.
PiQrypt adds a cryptographic audit trail to every agent action: signed, hash-chained, tamper-evident. Verifiable without access to your infrastructure. No raw data stored — only SHA-256 fingerprints.
OAuth solved delegated authorization for web apps.
No one asks why it exists anymore — it is infrastructure.
PCP does the same for AI agent accountability.
Tamper any event → chain breaks immediately at that point.
Four layers. One protocol.
From a 2-line Python install to enterprise governance — the same cryptographic foundation.
Signed Events
Each event is signed with the agent's keypair (Ed25519 or Dilithium3), binding every action to a verifiable, unforgeable identity.
AISS · Ed25519 · Dilithium3Hash Chains
Events are linked with SHA-256, creating an append-only, tamper-evident chain. Any modification breaks the chain — instantly detectable.
SHA-256 · RFC 8785 · RFC 3161Co-signed Interactions
When agents collaborate, both sign the interaction. Cross-framework, offline-verifiable. Cryptographically impossible to deny.
AgentSession · A2C detectionTrustGate Governance
Real-time policy engine evaluates agent risk (VRS score). ALLOW, REQUIRE_HUMAN, BLOCK — with hash-chained proof of every decision.
TrustGate · VRS · HITL queueSee it work. Right now.
One function call returns a verifiable trust score and anomaly status. offline-verifiable. No server needed.
# Call verify on any signed agent chain result = piqrypt.verify( signature = agent_event.signature, chain = agent_event.chain, context = {"agent_id": "pq1_planner_a3f8", "action": "portfolio_rebalance"} ) # Result — offline-verifiable, cryptographically verifiable print(result.trust_score) → 0.9987 print(result.anomaly) → False print(result.chain_valid) → True print(result.decision) → ALLOW
Verified offline-verifiable in 2ms — no network call, no third party.
See how it works — in detail
Five technical diagrams. Click a tab to explore each layer.
A new infrastructure primitive
No one asks why OAuth exists anymore — it became infrastructure. PCP does the same for AI agent accountability.
Cryptographic identity per agent — Ed25519 or Dilithium3. Derived from keypair, persistent, unforgeable.
Signed, hash-chained, tamper-evident event log. No event can be added, removed or reordered without breaking the chain.
Real-time VRS scoring + TrustGate policy engine. HITL queue with TTL. Hash-chained proof of every governance decision.
LLMs have memory.
Their agents don't — until now.
LangChain, AutoGen, CrewAI — every major framework gives agents short-term context. Volatile. Non-verifiable. Gone on restart.
PiQrypt gives agents permanent, cryptographic memory — every action signed, every decision hash-chained, every interaction co-signed. Provable forever. offline-verifiable. audit-ready and independently verifiable.
From encryption to Trust Infrastructure
PiQrypt is not an encryption tool. It is not a messaging layer.
It is the foundational verifiable for systems where machines act autonomously — and humans need to know, verify, and prove what happened.
Factories. Agents. Networks. Every interaction becomes verifiable. Every decision provable.
Talk to a PiQrypt agent
This is not chat support. This is a PiQrypt-enabled agent — every response it generates is signed, hash-chained, and verifiable. You're talking to the protocol in action.
PiQ — PiQrypt agent
every response signed · chain: activeWorks with any agent — 1 line
Non-intrusive bridges for every major framework. Your agent unchanged.
AgentSession — multi-agent co-signing
When agents collaborate across frameworks, PiQrypt co-signs every interaction on both sides — simultaneously. Neither agent can deny the session. No shared server. offline-verifiable. Legally binding.
from piqrypt.session import AgentSession # 3 agents · 3 frameworks · 1 session session = AgentSession( initiator=agent_langchain, peers=[agent_autogen, agent_crewai] ) session.start() # Both chains updated — cross-signed session.stamp("task_delegation", payload, peer="agent_autogen") # ✓ Neither agent can deny the interaction # ✓ offline-verifiable · No shared server · RFC 3161
Built for accountable AI
PiQrypt does not claim certifications. It provides the cryptographic infrastructure that helps your AI systems address the requirements of emerging regulatory frameworks.
European regulation
Infrastructure to help address key requirements for high-risk AI systems.
- Art. 12 — inviolable event logs
- Art. 14 — human oversight infrastructure
- Art. 9 — risk management tooling
French cybersecurity
Aligned with ANSSI recommendations for AI system security and audit traceability.
- R25 — dangerous pattern filtering (VRS)
- R29 — audit trail infrastructure
- R30 — clearance-based access (TrustGate)
US risk framework
Supports NIST AI Risk Management Framework implementation for agentic AI.
- GOVERN 1.2 — accountability structures
- MANAGE 2.2 — incident response
- MEASURE 2.5 — A2C anomaly detection
PiQrypt is a technical tool. Regulatory compliance depends on your specific use case, implementation, and jurisdiction. Consult qualified legal counsel for compliance determinations.
Running in 60 seconds
One install. Two lines. A cryptographic audit trail for any agent.
import piqrypt as aiss # Create agent identity private_key, public_key = aiss.generate_keypair() agent_id = aiss.derive_agent_id(public_key) # Stamp a signed, hash-linked event event = aiss.stamp_event( private_key, agent_id, {"action": "recommendation", "asset": "AAPL"} ) aiss.store_event(event) # Verify — raises InvalidChainError on tampering aiss.verify_chain([event]) # ✅ Chain verified — 1 event, 0 anomalies
from piqrypt.bridges.langchain import PiQryptCallbackHandler from langchain.agents import AgentExecutor # 1 parameter — your agent completely unchanged agent = AgentExecutor( agent=your_agent, tools=your_tools, callbacks=[PiQryptCallbackHandler(identity=agent_id)] ) # CrewAI: from piqrypt.bridges.crewai import AuditedAgent as Agent # AutoGen: from piqrypt.bridges.autogen import AuditedAssistant
# Create identity piqrypt identity create my_agent # Stamp a signed event piqrypt stamp my_agent --payload '{"action":"trade","symbol":"AAPL"}' # Verify chain integrity piqrypt verify my_agent # ✅ Chain integrity verified — 1 event, 0 anomalies
Start free. Scale when you need.
Same cryptographic foundation across all tiers. Free forever for solo developers.
- AISS STANDARD — Ed25519 signatures
- SHA-256 hash chains
- Vigil dashboard (2 bridges max)
- .pqz memory export
- MIT open source core
- Post-quantum — Dilithium3 (NIST FIPS 204)
- RFC 3161 trusted timestamps (TSA)
- .pqz CERTIFIED export
- Vigil full + exports
- TrustGate manual governance
- Everything in Pro
- Team workspace
- Collaborative audit exports
- Priority support
Need more scale? Team (150 agents, 5M events/mo), Business (500 agents, 20M events/mo) and Enterprise (unlimited, on-premise, SSO, SLA) are also available. We adapt to your system — if you need a custom solution or want to know more, contact us.
Full pricing →Start building trusted systems — today.
Every agent action remembered. Every memory cryptographically signed. Forever.
Free tier · No credit card · MIT open source