Open System of Record for AI Agents

AI agents are becoming a new class of “user” on the internet. They browse, negotiate, pay, retrieve, transform, and act. They do it fast, at scale, and increasingly without a human watching each step.

That is not just a product shift. It is an infrastructure shift.

In the agent era, the core question stops being “Can the agent do the action?” and becomes:

• 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?

If we cannot answer those questions with durable evidence, the agent web either centralizes behind gatekeepers or collapses into disputes, fraud, and regulatory dead-ends.

What we need is an open system of record for agent interactions. Originary exists to build and steward that layer.

PEAC Protocol (Programmable Environment for Agent Coordination) is designed to sit above payment rails and alongside provenance and preference standards. It does not compete with x402/L402 or any single vendor's stack; it standardizes the evidence object that can reference those systems.

PEAC complements payment rails like HTTP 402 patterns and x402/L402, and works alongside standards like C2PA for provenance and AIPREF for AI preferences. The protocol provides the binding layer that creates verifiable proof across these systems.

In classic enterprise software, a system of record is where “truth” lives: customer data, transactions, inventories, ledgers.

In the agent era, the unit of truth is different.

It is not “a row in a database.” It is a verifiable interaction:

• what was requested
• what policy applied
• what consent preferences were active
• what was paid (if anything), via which rail
• what was returned
• what attribution/provenance obligations were asserted
• what identities were involved (without leaking private identity)

This is a system of record for decisions and actions, not just data.

And it must be interoperable across:

• different agent frameworks
• different payment rails (HTTP 402, x402/L402, Stripe-like flows, etc.)
• different network surfaces (origin, CDN, gateway, edge workers)
• different storage backends (centralized logs, SIEMs, data lakes, internal ledgers)

If it only works in one vendor's stack, it is not a system of record. It is a product feature.

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.

A credible system of record for AI agents must meet requirements that are easy to say and hard to ship.

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 cryptographic receipt returned with responses that proves what happened.

That is the heart of the PEAC Protocol (Programmable Environment for Agent Coordination), stewarded by Originary.

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

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

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.

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.

Closed systems of record exist today: proprietary logs, proprietary billing dashboards, proprietary bot management platforms.

They work until they don't.

In the agent era, three things make openness mandatory:

If the record layer is proprietary, the internet fragments into walled gardens. That is not the future we want, and it is not the future that wins long-term.

PEAC is an open protocol. Originary stewards the spec and builds tools and services, but any team can implement and verify PEAC receipts independently.

Originary builds and stewards the open standard layer, and also ships production-grade tooling so teams can adopt it without reinventing crypto and policy enforcement.

The protocol stays open. Teams choose whether they want to self-host, use Originary, or use any other provider.

That is what “open system of record” means in practice.

This layer is not just for “AI companies.” It is for anyone who will be interacted with by agents.

If you are building for the agent economy, you will need a proof layer. The question is whether it is proprietary and fragile, or open and durable.

The agent era will force a new baseline:

• Receipts can become a default expectation for high-trust agent interactions, similar to how TLS became baseline for secure transport.
• Policy will be machine-readable, not buried in documents.
• Verification will be a standard enterprise requirement, not a niche security feature.
• Disputes will be resolved with evidence objects, not screenshots and vendor dashboards.

The system of record for AI agents will not be the company with the most traffic. It will be the layer that makes interactions provable across everyone's traffic.

That is the layer Originary is building.

If you operate an endpoint that agents will touch, you can begin now:

1. Publish a policy file (peac.txt) that expresses access terms in a machine-readable way.
2. Start returning cryptographic receipts (PEAC-Receipt) for agent interactions.
3. Verify receipts inside your own systems, and export them to the places you already trust (SIEM, warehouse, compliance pipelines).

Originary can help you adopt the open standard quickly, whether you self-host or use managed verification.

The agent web is arriving. We should build it so it can be trusted.

Originary is building the open system of record for AI agents.