Quickstart

pip install phronedge

export PHRONEDGE_API_KEY=pe_live_your_key_here

from phronedge import PhronEdge

pe = PhronEdge()

@pe.govern("lookup_claim")
def lookup_claim(claim_id: str) -> str:
    """Look up an insurance claim by ID."""
    return db.query(claim_id)

# This call now passes through 7 governance checkpoints
# before the function body executes. Under 50ms.
result = lookup_claim("CLM-2026-001")

pe = PhronEdge(agent_id="claims-investigator")

# Read-only access in Germany
@pe.govern("claim_lookup", action="read", jurisdiction="DE")
def claim_lookup(claim_id: str) -> dict:
    return claims_db.get(claim_id)

# Write access in Germany
@pe.govern("update_claim", action="write", jurisdiction="DE")
def update_claim(claim_id: str, data: dict) -> dict:
    return claims_db.update(claim_id, data)

pe = PhronEdge(agent_id="claims-investigator")

# Allowed: DE is in the policy list
@pe.govern("claim_lookup", action="read", jurisdiction="DE")
def lookup_de(claim_id):
    return claims_db.get(claim_id)

# Allowed: AT is also in the list
@pe.govern("claim_lookup", action="read", jurisdiction="AT")
def lookup_at(claim_id):
    return claims_db.get(claim_id)

# Blocked: CN is not in the list. Function never executes.
@pe.govern("claim_lookup", action="read", jurisdiction="CN")
def lookup_cn(claim_id):
    return claims_db.get(claim_id)

# Agent 1: fraud analyst
pe_fraud = PhronEdge(agent_id="fraud-analyst")

@pe_fraud.govern("transaction_review", action="read", jurisdiction="DE")
def review_transaction(txn_id: str) -> dict:
    return txn_db.get(txn_id)

# Agent 2: KYC verifier. Different tools. Different clearance. Different jurisdictions.
pe_kyc = PhronEdge(agent_id="agt-kyc-orch-v1")

@pe_kyc.govern("id_verify", action="read", jurisdiction="DE")
def verify_identity(doc_id: str) -> dict:
    return idv_service.verify(doc_id)

from phronedge import PhronEdge

pe = PhronEdge(agent_id="claims-investigator")

@pe.govern("claim_lookup", action="read", jurisdiction="CN")
def claim_lookup_china(claim_id):
    return db.query(claim_id)

result = claim_lookup_china("CLM-001")
# result = {
#     "blocked": True,
#     "reason": "Jurisdiction 'CN' not permitted for tool 'claim_lookup'. Allowed: DE, AT, CH",
#     "checkpoint": "jurisdiction",
#     "regulation": "GDPR Art. 44-49",
#     "retry": True,
#     "message": "Tool call blocked by PhronEdge governance."
# }

from phronedge import PhronEdge, ToolBlocked

pe = PhronEdge(agent_id="claims-investigator", raise_on_block=True)

@pe.govern("claim_lookup", action="read", jurisdiction="CN")
def claim_lookup_china(claim_id):
    return db.query(claim_id)

try:
    result = claim_lookup_china("CLM-001")
except ToolBlocked as e:
    print(e.reason)       # "Jurisdiction 'CN' not permitted..."
    print(e.checkpoint)   # "jurisdiction"
    print(e.regulation)   # "GDPR Art. 44-49"
    print(e.blocked)      # True
    print(e.retry)        # True

phronedge policy build policy.yaml     # preview only, no credentials issued
phronedge policy deploy policy.yaml    # sign and issue credentials
phronedge policy status                # show registered agents and tools

import os, requests

policy = {
    "organization": {
        "name": "Your Company",
        "jurisdiction": "DE",
        "industry": "IN",
        "data_types": ["PUB", "PII"],
        "data_residency": ["DE"],
        "deployment_jurisdictions": ["DE", "AT", "CH"],
    },
    "agents": [{
        "id": "claims-investigator",
        "purpose": "Process insurance claims",
        "model": "gpt-4o",
        "tier": "T2",
        "role": "standalone",
        "data_classifications": ["PUB", "PII"],
        "tools": ["claim_lookup", "report_generate"],
        "host_jurisdiction": "DE",
        "serving_jurisdictions": ["DE", "AT", "CH"],
    }],
    "tools": [
        {
            "id": "claim_lookup",
            "description": "Search claims by ID",
            "type": "sdk",
            "data_classification": "PII",
            "permissions": ["read"],
            "jurisdictions": ["DE", "AT", "CH"],
            "deny_patterns": ["DROP", "DELETE", "TRUNCATE"],
        },
        {
            "id": "report_generate",
            "description": "Generate compliance reports",
            "type": "sdk",
            "data_classification": "INT",
            "permissions": ["read", "write"],
            "jurisdictions": ["DE"],
        },
    ],
    "deploy": True,
}

r = requests.post(
    "https://api.phronedge.com/api/v1/governance/build",
    headers={
        "X-PhronEdge-Key": os.environ["PHRONEDGE_API_KEY"],
        "Content-Type": "application/json",
    },
    json=policy,
)

result = r.json()
print(result["status"])                           # "compliant"
print(result["signed_artifact"]["controls_met"])  # 30
print(result["credentials_issued"])               # [{"agent_id": "claims-investigator", ...}]

phronedge export rego --agent claims-investigator -o policy.rego
phronedge export yaml --agent claims-investigator -o policy.yaml
phronedge export json --agent claims-investigator -o policy.json

phronedge verify --agent claims-investigator

PhronEdge Verify
==================================================

[+] API key: pe_live_xx******************xxxx
[+] Gateway: https://api.phronedge.com/api/v1

Testing gateway connection...
[+] Gateway reachable

Verifying agent: claims-investigator
[+] Credential valid
    Agent:        claims-investigator
    Tier:         T2
    Jurisdiction: DE
    Tools:        claim_lookup, report_generate
    Signed:       ES256 key=v2

Ready. Agent 'claims-investigator' is governed.

phronedge scan my_agent.py

PhronEdge Scan: my_agent.py
==================================================

  [+] claim_lookup (as "claim_lookup")    line  12  governed
  [+] report_generate (as "report")       line  18  governed
  [x] send_email                          line  24  NOT governed

Total: 3 tools
  Governed:   2
  Ungoverned: 1

Ungoverned tools execute without governance.
Add @pe.govern("tool_name") to each one.

phronedge scan src/agents/*.py --strict

import requests, json
from cryptography.hazmat.primitives.asymmetric import ec
from cryptography.hazmat.primitives import hashes, serialization
from cryptography.exceptions import InvalidSignature

# 1. Fetch your tenant's public keys (no auth required)
tenant_id = "tn_your_tenant_id"
r = requests.get(f"https://api.phronedge.com/.well-known/phronedge/{tenant_id}/keys.json")
keys = r.json()["keys"]

# 2. Pick the key used to sign your credential
key_id = credential["phronedge_signature"]["key_id"]  # e.g. "v2"
active_key = next(k for k in keys if k["kid"] == key_id)
pub_key = serialization.load_pem_public_key(active_key["pem"].encode())

# 3. Reconstruct the signed payload
sig_hex = credential["phronedge_signature"]["value"]
payload = {k: v for k, v in credential.items() if k not in ("phronedge_signature", "anchor_hash", "anchor_tx")}
canonical = json.dumps(payload, sort_keys=True, separators=(",", ":")).encode("utf-8")

# 4. Verify
try:
    pub_key.verify(bytes.fromhex(sig_hex), canonical, ec.ECDSA(hashes.SHA256()))
    print("Signature valid. Policy is authentic.")
except InvalidSignature:
    print("Signature invalid. Policy has been tampered with.")

"""
PhronEdge E2E: from zero to governed in one script.
pip install phronedge requests
"""
import os, json, logging, requests

logging.basicConfig(
    level=logging.INFO,
    format="%(asctime)s %(levelname)-5s %(message)s",
    datefmt="%H:%M:%S",
)
log = logging.getLogger("phronedge.e2e")

API = os.environ.get("PHRONEDGE_GATEWAY_URL", "https://api.phronedge.com/api/v1")
KEY = os.environ["PHRONEDGE_API_KEY"]
H = {"X-PhronEdge-Key": KEY, "Content-Type": "application/json"}

# 1. Sign and deploy policy (credentials issued)
log.info("Signing and deploying policy...")
policy = {
    "organization": {
        "name": "Test Co",
        "jurisdiction": "DE",
        "industry": "IN",
        "data_types": ["PUB", "PII"],
        "data_residency": ["DE"],
        "deployment_jurisdictions": ["DE"],
    },
    "agents": [{
        "id": "test-agent",
        "purpose": "Test agent",
        "model": "gpt-4o",
        "tier": "T2",
        "role": "standalone",
        "data_classifications": ["PUB", "PII"],
        "tools": ["claim_lookup"],
        "host_jurisdiction": "DE",
        "serving_jurisdictions": ["DE"],
    }],
    "tools": [{
        "id": "claim_lookup",
        "description": "Search claims",
        "type": "sdk",
        "data_classification": "PII",
        "permissions": ["read"],
        "jurisdictions": ["DE"],
        "deny_patterns": ["DROP", "DELETE"],
    }],
    "deploy": True,
}
r = requests.post(f"{API}/governance/build", headers=H, json=policy, timeout=30)
log.info("Status: %s", r.json().get("status"))

# 2. Govern and call
from phronedge import PhronEdge, ToolBlocked

pe = PhronEdge(agent_id="test-agent", raise_on_block=True)

@pe.govern("claim_lookup", action="read", jurisdiction="DE")
def claim_lookup(claim_id):
    return json.dumps({"id": claim_id, "status": "OPEN", "amount": 12500})

log.info("ALLOWED: %s", claim_lookup("CLM-001"))

# 3. Test block: wrong jurisdiction
@pe.govern("claim_lookup", action="read", jurisdiction="CN")
def bad_jurisdiction(claim_id):
    return "SHOULD NOT RUN"

try:
    bad_jurisdiction("CLM-001")
except ToolBlocked as e:
    log.info("BLOCKED: %s (checkpoint=%s regulation=%s)", e.reason, e.checkpoint, e.regulation)

# 4. Test block: SQL injection pattern
@pe.govern("claim_lookup", action="read", jurisdiction="DE")
def bad_inject(query):
    return "SHOULD NOT RUN"

try:
    bad_inject("DROP TABLE claims")
except ToolBlocked as e:
    log.info("BLOCKED: %s", e.reason)

log.info("Done. Check phronedge.com/brain for the audit trail.")

export PHRONEDGE_API_KEY=pe_live_your_key_here
python quickstart_e2e.py

08:30:00 INFO  Signing and deploying policy...
08:30:01 INFO  Status: compliant
08:30:03 INFO  ALLOWED: {"id": "CLM-001", "status": "OPEN", "amount": 12500}
08:30:04 INFO  BLOCKED: Jurisdiction 'CN' not permitted... (checkpoint=jurisdiction regulation=GDPR Art. 44-49)
08:30:05 INFO  BLOCKED: Global deny pattern 'DROP TABLE' matched.
08:30:05 INFO  Done. Check phronedge.com/brain for the audit trail.