Authorization & evidence for agents

Agentic Commerce meets Governance.

AI has grown from answering to acting. Agents buy data, pay for APIs and compute, and settle with other agents. The capability is arriving faster than the authority to use it. LinkHash binds authority, delegation, agentic actions and outcomes into one record anyone can verify.

165M+
machine payments already cleared on x402 - the agent economy is live and growing
7+
protocols that let agents pay - each decides how money moves, none decides whether it should
6
questions every delegated action must answer - today they sit in systems that don't connect
The problem

The capability to act is here. The authority to act is not.

Take a company running hundreds of agents: Finance initiating payments, Engineering deploying code, Research buying data, Support messaging customers. For every use case, the same six questions apply:

Who delegated authority - which person or function stands behind this agent?
What is it permitted to do?
What constraints apply - amount, recipient, budget, time?
Did it actually execute, and with what result?
Can you prove it without trusting the agent's own account?
Can the authority be revoked - right now, not at the next deploy?

Today those answers sit in systems that don't connect. An agent being able to act is not the same as being authorized to act. The challenge is connecting authority to action.

The missing layer

Multiple systems hold a piece of the puzzle. Nothing connects the chain.

Authorization, policy engines and audit trails all exist. Each covers one leg of the journey. LinkHash binds delegated authority, the policy decision and independently verifiable execution evidence into one portable record, and enforces the decision where the credential lives.

Agent identity
Who the agent is and which credentials it can reach - not whether this specific action was authorized.
IAM
Policy engines
Allow and deny on paper - a policy stays a suggestion while the agent holds a usable key.
OPA · Cedar
Rails & runtimes
Execution inside one provider's boundary - no shared record across clouds, runtimes or ways to pay.
x402 · cards · clouds
Observability
What the agent says it did - a log proves who wrote it, not that it's true.
traces & evals
LinkHash
Authority, decision and outcome - bound in one record, enforced at the key, verifiable by anyone.
the binding layer
Why payments first

Money is the sharpest version of the problem. Payments are the first use case, but not the last.

A payment happened or it didn't: an amount, a recipient, an approver, a settlement. Measurable outcomes, budget owners who already pay for controls, and evidence that has to stand up with finance and auditors. The same lifecycle then governs tool calls, records, communications and deployments.

Finance & securitybudgets · approvals · reconciliation
audit-ready evidence
LinkHashdelegated authority · enforcement at the key
verifiable receipts
Payment railsx402 · MPP · cards · banks
the ability to move money
01 · agentic payments 02 · tools & APIs 03 · records, comms & deploys 04 · independent evidence
How it works

Intent in. Evidence out. One lifecycle for every action.

The open-source SDK runs beside your agent in a few lines of code and provides a unified interface to multiple underlying systems, such as payment rails. When the organization is ready for control, IT sets two variables - and the fleet moves from observing to enforced authorization without a rebuild.

01Intent

The agent's request becomes a standard action.

02Authorization

Policy checks identity, delegated authority, amount, recipient and context. Allow, deny, or ask a human.

03Enforcement

Approval mints narrow, short-lived authority for that exact action. Your signer or provider executes only with it.

04Execution

The action runs on your rails, keys and accounts. Nothing is custodied.

05Evidence

A signed receipt binds intent, policy version, decision and outcome - blocked and failed attempts included.

# integrate - open source, a few lines, pays normally $ npx linkhash pay --to api.data.example --amount 0.08 USDC ✓ settled · receipt rcpt_01J9X… # when the security team is ready - observe, then enforce $ export LINKHASH_POLICY_URL=https://policy.linkhash.ai $ export LINKHASH_API_KEY=lh_live_… # the fleet becomes governed. nobody rebuilt the agent.
The record

A signature isn't proof it happened. A log isn't proof it was authorized. The receipt is both.

Every attempt (settled, failed, blocked, or unknown pending reconciliation) becomes a signed receipt binding the intent, the policy version, the decision and evidence from the system that executed it. Proof that an agent didn't act counts as much as proof that it did. Anyone can verify the chain without trusting the agent, the rail, or us.

$ linkhash ledger --by-agent --last 7d rcpt_01J9X… settled 0.08 USDC → api.marketdata.example x402 ✓ verified rcpt_01J9Y… settled 499.00 USD → merchant.example card ✓ verified rcpt_01JA2… policy_blocked 899.00 USD → merchant.example - rule card_cap_300 rcpt_01JA4… pending 12.40 USDC → vendor-agent.example - awaiting approval rcpt_01JB1… unknown 36.20 USDC → api.compute.example x402 timeout - reconcile, do not retry $ linkhash verify receipts: 41,902 · links: intact · signatures: all valid · result: OK
Under the hood

Infrastructure, not instrumentation.

Pay

One API, every rail

Pay any counterparty without learning its protocol. Canonical outcomes across rails - including honest states like "submitted; settlement unverifiable" - so an agent never pays twice when the network goes quiet.

pay() x402 MPP Cards Bank
Govern

Enforced at the key

Caps per agent, team, merchant and time window, with approvals that escalate to a human. The agent never holds standing authority. It receives only the narrow authority a decision approved.

research-agent · daily cap $32.80 / $40 ! Approval needed $899.00 → merchant.example · over $300 cap Approve Deny #finance-approvals
Prove

Audit-grade receipts

Signed evidence bound to what actually executed. Finance, auditors and insurers can verify it independently - without trusting the agent, the rail, or us.

rcpt_01J9X · settled rcpt_01JA2 · blocked rcpt_01JA4 · settled verified
No lock-in

LinkHash sits in a critical path. You stay in control - even if we don't exist.

Your keys

We never move keys, custody funds, or take a percentage of money moved.

Local execution

The SDK works with no account and no dependency on our servers.

Offline verification

Anyone can check receipts against open, documented formats.

Your evidence

The records belong to you and survive us.

Explicit failure modes

Fail-closed, fail-open or cached policy - chosen per organization, with break-glass limits.

Early access

We're onboarding a small number of design partners.

If you run agents that act in the real world, we would love to collaborate with you. The proof point we're building toward: an authorized payment, and an unauthorized attempt that fails - both ending in a receipt that an independent verifier can check against the actual settlement.

We'll only use your email to contact you about our products and services. Privacy policy