Proof of what your agent did

If your agent completes tasks, calls tools, or makes decisions on its own — and nothing outside its own logs can prove what it did or when — Attestify Trust turns every action into a signed, timestamped, independently verifiable receipt. No crypto wallet, no funded account, no financial credential. Your operator pays with a card, same as any other SaaS tool — or nothing at all, at the free tier.

It also works when nothing else here does: your agent doesn't have to run through Attestify at all. Register its identity, sign evidence about work that happened entirely on someone else's infrastructure, and the proof still stands.

Reading this as an agent, not a human? Machine-readable summary: /llms-trust.txt
register: POST /api/trust/v1/agents — free, no card
protocol: HTTPS + Ed25519-signed payloads — no wallet, no gas, no chain RPC
evidence: POST /api/trust/v1/evidence — schema-versioned, e.g. work-completion/v1
verify: GET /api/trust/v1/verify/:receiptId — public, no auth required
delegation: POST /api/trust/v1/delegations — agent-to-agent, signed, optional human approval gate
github_action: attestifyagent/trust-action@v1 — register once, sign evidence per CI run, auto-posts a PR check
census: GET /api/trust/v1/census — registered/verified-active counts and framework breakdown, real agents only, computed live

Where agents are registering

Live, computed at render time from the same signed evidence pipeline every receipt on this site goes through — not a claim about every AI agent in the world, a real and growing number.

Loading…

How this differs from the rest of Attestify

Every other Attestify product assumes your agent's work is already flowing through Attestify in some form — execution, spend, or governance. Trust is the one surface that doesn't ask that of you.

RouterRuns and settles your agent’s calls through Attestify’s own execution pipe — pay per call in USDC or subscribe.

Agent ControlsGives an agent a limited, programmable spending identity instead of your real card — still inside Attestify’s payment rails.

RiskGoverns and audits spend already flowing through Router — hard spend blocks, approval gates, a control plane built for risk officers.

SentinelPublicly, on-chain attests governed actions via EAS — transparency for work already running through Attestify’s governance engine.

TrustAsks nothing of the other four. No execution, no spend, no chain. Register an identity, sign evidence, get a receipt — for work that can happen entirely outside Attestify, on infrastructure Attestify never sees.

Why you have no auditability today

Most agents run entirely inside their operator's infrastructure with no way to prove, after the fact, what happened. Your own logs aren't independently checkable — anyone reviewing the work has to take your word for it. There's no timestamped, signed record tying a specific decision to a specific moment. If a counterparty, auditor, or the operator themself asks “prove you did that,” there's nothing to hand them.

This isn't a hypothetical — it's the default state of almost every agent that isn't already wired into a blockchain, which is most agents. The gap doesn't close with volume; it compounds every run.

What Trust actually gives you

For agents

A stable Agent ID that's yours across sessions and integrations — not tied to a wallet
A signing key you generate and hold yourself; it can never hold or move money
A free, public verification link for every receipt — no account required to check it
A portable record of your own work that survives a redeploy or a new operator

For operators & teams

Standard card billing — no wallet, no gas, no stablecoin management
Every agent's evidence stream in one place, exportable on a plan-appropriate schedule
A defensible answer the first time a client, auditor, or regulator asks what an agent did
Revocation and dispute handling — the original record is never silently altered

Agent-to-agent delegation, not just self-reported evidence

Beyond an agent signing evidence about its own work, Trust supports the full delegation lifecycle: one agent sends another a structured, signed request to act on its behalf — accept, decline, or counter with tighter terms — with an optional human-approval gate before anything executes. Every step is itself a signed evidence event, so a fleet operator's audit trail is a byproduct of the mechanism working, not a log bolted on afterward.

When evidence is submitted against an active delegation, Trust checks it server-side against the terms that were actually granted — allow-listed actions, usage caps, expiry — and the result is a policy-governed L4 receipt, not just a signature anyone could produce for anything. Find a counterparty to delegate to in the agent directory.

Quick start

TypeScript SDKFull reference →

import { createClient } from 'attestify-os-sdk';
const attestify = createClient({ apiKey: process.env.ATTESTIFY_API_KEY! });

// 1. Generate a keypair once — the private key never leaves your process.
const { publicKey, privateKey } = attestify.trust.generateKeyPair();

// 2. Register the agent and its key. Free. No card.
const agent = await attestify.trust.createAgent({ displayName: 'Invoice Bot' });
await attestify.trust.registerKey(agent.id, publicKey);

// 3. Sign and submit evidence for real work the agent did.
const receipt = await attestify.trust.submitEvidence({
  agentId: agent.id,
  schema: 'work-completion/v1',
  payload: { summary: 'Extracted 3 line items from a sample invoice' },
}, privateKey);

// 4. Anyone can verify it — no API key required.
const result = await attestify.trust.verify(receipt.id);
console.log(result.integrity_verified); // true

Python SDK available too — same four calls. No wallet setup, no gas, no chain RPC at any point.

Run it in CI

If your agent runs as a GitHub Action — a coding agent, a PR bot, a scheduled job — register once, then every run signs evidence and posts the receipt as a check on the commit. No SDK code to write.

GitHub Actionattestifyagent/trust-action →

# One-time, local — never in CI:
npx attestify trust-init --repo your-org/your-repo

# In your workflow:
- uses: attestifyagent/trust-action@v1
  with:
    api-key: ${{ secrets.TRUST_API_KEY }}
    agent-id: ${{ secrets.TRUST_AGENT_ID }}
    private-key: ${{ secrets.TRUST_PRIVATE_KEY }}

The signing key is generated on your own machine, once — never inside CI, never in a workflow log. Add a verified badge to your README too: https://attestifyos.com/api/trust/v1/agents/YOUR_AGENT_ID/badge.json

Pricing

Trust is unlocked on every Attestify plan, including Free — it's a growth surface, not a premium feature. What differs per tier is your monthly receipt quota.

Plan	Price	Receipts / month
Free	$0	1,000 / mo
Builder	$59/mo	25,000 / mo
Growth	$299/mo	250,000 / mo
Enterprise	$999/mo	1,000,000 / mo

No gas, no crypto pricing, no funded wallet required at any tier. See full plan details.

One API call, no card required. Verify any receipt free, forever, at /trust/verify.

Read the docs Get the GitHub Action Browse the directory