Trust infrastructure
for autonomous agents

Autonomous agents act without humans present. VerifyEverything.ai is the layer that makes every action cryptographically provable — hardware-rooted, policy-checked, and independently auditable. Not logging. Not monitoring. Attestation.

The core primitive

The receipt

Every agent action produces a signed, tamper-proof receipt — a structured record that proves what happened, who authorized it, which policy was applied, and that the signing key never left the hardware. Receipts are the universal accountability primitive.

attestation_record :: portfolio-agent-v1 · 2026-03-08T14:22:31Z ✓ VERIFIED

agent_id

portfolio-agent-v1

Unique identity of the acting agent, registered with VerifyEverything.ai

action

REBALANCE_PORTFOLIO :: $42,000.00

Structured description of the action taken — machine-readable and auditable

policy_check

PASSED — risk_limit_q1 ✓ asset_allowlist ✓

Every named policy rule evaluated at execution time — pass or fail

authorized_by

[email protected]

The human principal who delegated authority to this agent

timestamp

2026-03-08T14:22:31.000Z

ISO 8601 UTC — when the action was executed and attested

key_id

secure-enclave:a3c9e2f1 · ecdsa-p256

Hardware-bound signing key — generated in Secure Enclave, never exportable

soul_hash

sha256:ef820da2 4ee22e1e a943f57a...

Hash of the agent's identity document — proves who the agent is, not just what it did

integrity_hash

sha256:c3d7f1a2 94be3e8d 71f2c4b9...

SHA-256 of the full receipt payload — any tampering invalidates the signature

Receipts are published to a public verification endpoint. Anyone with the receipt ID can independently verify it at verifyeverything.ai/r/:id — no account required.

Integration

Four steps to governed agents

VerifyEverything.ai wraps around your existing agent runtime. You bring the agent logic. We bring the trust infrastructure.

01
Identify

Register your agent

Each agent gets a cryptographic identity anchored in the Secure Enclave (Apple Silicon, Android StrongBox, or TPM 2.0). The private key is generated in hardware and never exported — not just who is acting, but proof the device is authentic.

// agents.json — agent registration manifest
{
  "agent_id":   "portfolio-agent-v1",
  "key_id":     "secure-enclave:a3c9e2f1",
  "algorithm":  "ecdsa-p256",
  "principal":  "[email protected]",
  "soul_hash":  "sha256:ef820da2..."  // agent identity document
}

02
Authorize

Define your policy

Policies are declarative JSON files that specify exactly what your agent can and cannot do — spend limits, allowed actions, time windows, approval chains. Every action is checked against policy before execution. No exceptions, no overrides.

// policy.json — what this agent may do
{
  "rules": [
    {
      "id":        "risk_limit_q1",
      "action":    "REBALANCE_PORTFOLIO",
      "condition": { "max_amount_usd": 50000 },
      "effect":    "allow"
    },
    {
      "id":        "asset_allowlist",
      "action":    "REBALANCE_PORTFOLIO",
      "condition": { "assets": ["BTC", "ETH", "AAPL"] },
      "effect":    "allow"
    }
  ]
}

03
Attest

Execute with attestation

Every agent action that passes policy generates a signed receipt. The receipt is signed by the hardware key, includes the policy evaluation result, and is published to the verification endpoint. No action goes unrecorded.

// ZHAttestation — signing a receipt (Swift)
let receipt = ZHAttestation.sign(
    action:       "REBALANCE_PORTFOLIO",
    payload:      actionData,
    policyResult: policyCheck,
    keyId:        "secure-enclave:a3c9e2f1"
)

// Publishes to verifyeverything.ai/r/:id
await receipt.publish()

04
Verify

Verify independently

Anyone — regulators, partners, customers, auditors — can verify a receipt without needing an account or trusting VerifyEverything.ai itself. The cryptographic proof is in the receipt. Trust without having to trust anyone.

# Verify any receipt via the public API
GET https://verifyeverything.ai/r/{receipt_id}

# Returns:
{
  "status":           "VERIFIED",
  "agent_id":         "portfolio-agent-v1",
  "policy_check":     "PASSED",
  "hardware_rooted":  true,
  "signature_valid":  true
}

Architecture

The trust chain

Every receipt traces back to a responsible human. The chain is cryptographically bound at every link — hardware device → agent identity → policy authorization → action → public proof.

Human Principal

authorized_by

→

HRT Principal

proof of humanity

→

Secure Enclave

device attestation

→

Agent Identity

key_id + soul_hash

↓

Policy Check

before execution

→

Action

attested

→

Receipt

publicly verifiable

Built on the public domain Human Root of Trust framework. HRT names the problem. VerifyEverything.ai solves it.

Reference implementation

Live in production

VerifyEverything.ai is not a prototype. It is running today.

Live system

ZeroHuman Co. is an autonomous holding company running on a Mac Mini M4. Its agent — Sancho — executes investment scans, portfolio checks, and weekly reports entirely without human intervention. Every action is signed by the Secure Enclave, policy-checked against a live playbook, and attested via VerifyEverything.ai.

This is the reference implementation. The schemas are open and public. The receipts are verifiable. The trust chain traces back to a human. ZeroHuman Co. proves it works.

Ready to govern
your agents?

Early access is open. Tell us what you're building.