Open System of Record for AI Agents

Introduction

AI agents are crossing organizational boundaries at scale: calling APIs, accessing tools, making purchases, retrieving content. The core question is no longer “Can the agent do this?” but:

• Should it have been allowed to do the action?
• Under what terms did it do the action?
• Who (or what) authorized it?
• Was it paid for?
• Can we prove it later without trusting a single vendor?

Without durable, portable evidence, the agent web either centralizes behind gatekeepers or collapses into disputes. An open system of record provides verifiable evidence that works across vendors, frameworks, and trust boundaries.

Why agent interactions break today

The current internet was not designed for autonomous clients operating at machine speed. We built strong primitives for transport (HTTP), identity (TLS), and content addressing (URLs). But agent interactions introduce missing primitives:

In short: agents are arriving with no shared proof layer.

The model: policy + receipts

The simplest way to make the web auditable is to standardize two things:

1. A discoverable policy file that tells agents what is allowed and under what terms.
2. A signed receipt returned with responses that proves what happened.

That is the heart of the PEAC Protocol (Portable Evidence for Agent Coordination), an open standard.

preferences: /.well-known/aipref.json
access_control: http-402
payments: [x402, stripe]
receipts: required
verify: /.well-known/peac-issuer.json

HTTP/1.1 200 OK
PEAC-Receipt: eyJhbGciOiJFZERTQSIsInR5cCI6...
Content-Type: application/json

What does a receipt actually prove?

A well-designed receipt should let a verifier prove statements like:

• This response was issued by this service at this time.
• This request matched policy version X (or policy hash X).
• This access was allowed under the declared terms.
• If payment was required, payment evidence exists and is referenced.
• The response returned was associated with those terms.
• Optional: an attribution/provenance pointer was asserted.

It does not need to reveal user identity. It can prove correctness without becoming a tracking vector.

This matters because the future is not “agents doing things,” it is “agents doing things and everyone being able to prove what happened.”

That is what makes commerce, compliance, and trust possible at scale.

A simple end-to-end flow

Here is the basic lifecycle that an open system of record enables:

1. Agent requests a resource.
2. Server resolves peac.txt and determines the effective terms.
3. If payment/authorization is required, the server challenges (often via HTTP 402 patterns).
4. Agent satisfies the requirement.
5. Server returns the response plus a cryptographic receipt.
6. Any verifier (enterprise, auditor, marketplace, dispute resolver, internal compliance team) can validate the receipt later.

The important shift is step (5): proof is emitted at the time of interaction, not reconstructed later from logs.

What Originary is building

PEAC is an open protocol. Originary stewards the spec and builds tools and services, but any team can implement and verify PEAC receipts independently. Openness is non-negotiable: evidence must be portable across vendors, verifiable by multiple parties, and scalable across millions of agent endpoints.

The protocol stays open. Self-host, use Originary, or use any other provider.

Start here

1. Publish a policy file (peac.txt) that expresses access terms in a machine-readable way.
2. Return signed records (PEAC-Receipt) for agent interactions.
3. Verify records inside your own systems and export them to your existing compliance pipelines.

Frequently asked questions