WITHOUT PiQrypt                          WITH PiQrypt
──────────────────────────────           ──────────────────────────────────────────
agent.execute(action)                    event = aiss.stamp_event(priv, agent_id, {
                                             "action": "portfolio_rebalance",
What happened?                               "confidence": 0.94
  UNKNOWN                                })
                                         aiss.store_event(event)
Who authorized it?
  UNKNOWN                                # Who acted?      ✅ agent_id: PIQR1a3f8...
                                         # What happened?  ✅ signed · hash-chained
Can we prove it?                         # Authorized?     ✅ TrustGate: ALLOW
  NO                                     # Provable?       ✅ .pqz · offline

What is PiQrypt?

PiQrypt is the cryptographic identity, memory and governance layer for autonomous AI agents.

It answers three questions regulators and auditors are asking today: who acted, what happened, should it have? — with signed, hash-chained records, offline-verifiable, cross-framework, portable in a self-contained .pqz archive readable without PiQrypt installed.

Just as OAuth solved delegated authorization without sharing credentials — PCP (Proof of Continuity Protocol) does the same for AI agent accountability. The infrastructure primitive that was missing.

Why now

Autonomous agents execute financial transactions, generate legally relevant content, and coordinate without human review — in production, today. Three regulatory frameworks are converging simultaneously:

These references say what each text asks for. PiQrypt supports event logging and human decisions; it does not make a system compliant. See docs/LIMITS_AND_POSTURE.md.

Traditional logs are forgeable. Traditional monitoring is session-scoped. PiQrypt signs and hash-chains each event, so that a later change to a stamped event is detectable.

Quick Start

pip install piqrypt

Launch the full stack:

piqrypt start                              # interactive tier selection
piqrypt start --tier free                  # Vigil dashboard · port 8421
piqrypt start --tier business --manual     # + TrustGate human approval queue

Python API — two lines to get started:

import piqrypt as aiss

private_key, public_key = aiss.generate_keypair()
agent_id = aiss.derive_agent_id(public_key)

event = aiss.stamp_event(
    private_key, agent_id,
    {"action": "recommendation", "asset": "AAPL", "confidence": 0.94}
)
aiss.store_event(event)
aiss.verify_chain([event])  # ✅ Chain verified — 1 event, 0 anomalies

LangChain — one parameter, agent unchanged:

from piqrypt.bridges.langchain import PiQryptCallbackHandler
from langchain.agents import AgentExecutor

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
# MCP:     from piqrypt.bridges.mcp import AuditedMCPClient

CLI:

piqrypt identity create my_agent
piqrypt stamp my_agent --payload '{"action":"trade","symbol":"AAPL"}'
piqrypt verify my_agent
# ✅ Chain integrity verified — 12 events · trust_score: 0.94 · TrustGate: ALLOW

Architecture — 4 layers

Your agents (LangChain · CrewAI · AutoGen · MCP · Ollama · ROS2 · RPi · …)
│
│  2 lines of code
│
┌───────────────────────────▼─────────────────────────────────────────┐
│  TrustGate — Policy engine                             port 8422     │
│  ALLOW · REQUIRE_HUMAN · BLOCK · QUARANTINE                          │
├─────────────────────────────────────────────────────────────────────┤
│  Vigil — Real-time behavioral monitoring               port 8421     │
│  VRS risk score · A2C anomaly detection · TSI                        │
├─────────────────────────────────────────────────────────────────────┤
│  PiQrypt Core — Continuity engine                                    │
│  .pqz portable archives · RFC 3161 TSA · ML-DSA-65                  │
├─────────────────────────────────────────────────────────────────────┤
│  AISS — Agent Identity Signing Standard                MIT ©2026     │
│  Ed25519 identity · SHA-256 hash chains · PCP                        │
└─────────────────────────────────────────────────────────────────────┘

AISS — Open Standard

AISS (Agent Identity and Signature Standard) is an open, MIT-licensed protocol, usable without PiQrypt.

pip install aiss-standard   # MIT · no quotas · no accounts

→ Spec: aiss-standard.org
→ GitHub: github.com/PiQrypt/aiss-standard

PiQrypt is the reference implementation — adds Vigil, TrustGate, 9 bridges, certified exports, and Doorkeeper on top of AISS.

Framework Bridges

9 bridges. Zero code change on your agent.

pip install piqrypt[all-bridges]   # install all at once

Privacy by design: raw prompts, model responses, and tool outputs are never stored — only their SHA-256 fingerprints. Structural, not configurable.

Offline by default: no third-party server receives any data. A .pqz archive can be verified offline, without access to the original infrastructure.

Cross-framework trust — AgentSession

When agents from different frameworks collaborate, AgentSession records the full interaction as co-signed chain entries, each verifiable by every party — without a shared server.

from bridges.session import AgentSession
import piqrypt as aiss

planner_key,  planner_pub  = aiss.generate_keypair()
executor_key, executor_pub = aiss.generate_keypair()
reviewer_key, reviewer_pub = aiss.generate_keypair()

session = AgentSession(agents=[
    {"name": "planner",  "agent_id": aiss.derive_agent_id(planner_pub),
     "private_key": planner_key,  "public_key": planner_pub},
    {"name": "executor", "agent_id": aiss.derive_agent_id(executor_pub),
     "private_key": executor_key, "public_key": executor_pub},
    {"name": "reviewer", "agent_id": aiss.derive_agent_id(reviewer_pub),
     "private_key": reviewer_key, "public_key": reviewer_pub},
])
session.start()
# → 3 co-signed handshakes recorded (N*(N-1)/2 pairs), one in each agent's chain

session.stamp("planner",  "task_delegation", {"task": "analyze_portfolio"}, peer="executor")
session.stamp("executor", "task_completed",  {"result_hash": "…"},          peer="reviewer")
session.stamp("reviewer", "review_signed",   {"approved": True},            peer="planner")

→ A2A Session Guide

Project Status

v1.10.0 · Python 3.9–3.12 · Linux · macOS · Windows

Standards implemented

Threat model

PiQrypt helps detect after-the-fact modification, reordering or removal of events inside a hash chain, shows which key signed an event, and can show that an event existed before a given time when a timestamp token has been verified against a trust root you configure. Vigil flags statistical anomalies, and TrustGate can require a human decision before critical actions.

PiQrypt does not protect against compromised private keys, malicious logic before stamping, or fully compromised hosts. Removing the last events of a chain is not detectable without an external anchor. See SECURITY.md for the complete threat model.

Pricing

→ Full pricing & feature comparison → Certification pricing (.pqz CERTIFIED)

Scope and limits

PiQrypt signs events, chains them by hash and verifies them offline. It is not an audit, a certification, a legal service or a compliance programme. A .pqz CERTIFIED export carries an attestation signed by the issuer; piqrypt certify-verify checks the format version and that signature, and does not check the audit data inside the file. Cryptographic labels such as ML-DSA-65 name the algorithm being implemented, not a validation. See docs/LIMITS_AND_POSTURE.md for what each output means and does not mean.

Documentation

⭐ If PiQrypt is useful to you, a star helps others find it — star on GitHub

License

IP: e-Soleau DSO2026006483 (19/02/2026) · DSO2026009143 (12/03/2026) Contact: contact@piqrypt.com ·