What did that agent's card say when you worked with it?

When one agent hands work to another, the other agent's card is the description of what it promised to do. Cards change without notice: a skill listed today can be gone tomorrow. This guide shows how to seal the exact card you relied on, read how it changed, and check it later without trusting us.

1. Seal the card before you delegate

One call, free, no account:

curl -s -X POST https://deusproof.com/api/cards/agent.example.com/seal

The register fetches https://agent.example.com/.well-known/agent-card.json, keeps the exact bytes it received and records their SHA-256 fingerprint. All the cards captured in the same hour are sealed together: one RFC 3161 timestamp and one Bitcoin anchor over the Merkle root of the batch. Agents can do the same with the seal_agent_card tool at https://deusproof.com/mcp, or the seal-agent-card skill over A2A.

2. Read the history

curl -s https://deusproof.com/api/cards/agent.example.com

Each version comes with the date it was captured, the fingerprint of its bytes, the skills it listed, what changed from the version before, and the certificate of the batch that sealed it. The exact bytes of a version are at /api/cards/agent.example.com/<version>/raw, as a download. Agents can ask the same with agent_card_history.

3. Check it without us

Every version carries a receipt and a Merkle proof. Recompute both, and you reach the fingerprint of the batch certificate, which you check with standard tools.

# check_card.py <domain>
import hashlib, json, sys, urllib.request

history = json.load(urllib.request.urlopen(f"https://deusproof.com/api/cards/{sys.argv[1]}"))
for v in history["versions"]:
    receipt = json.dumps(v["receipt"], sort_keys=True, separators=(",", ":"), ensure_ascii=True)
    assert hashlib.sha256(receipt.encode()).hexdigest() == v["receipt_sha256"]
    node = hashlib.sha256(b"\x00" + bytes.fromhex(v["receipt_sha256"])).digest()
    for step in v["batch"]["merkle_proof"]:
        sib = bytes.fromhex(step["hash"])
        pair = node + sib if step["position"] == "right" else sib + node
        node = hashlib.sha256(b"\x01" + pair).digest()
    print(v["version"], v["captured_at"], node.hex() == v["batch"]["merkle_root"])

The Merkle root is the fingerprint the batch certificate sealed. Download that certificate's three receipts and check them with openssl ts -verify and ots verify, exactly as in the guide to tamper-evident logs. To check the card itself, hash the raw bytes and compare them with body_sha256 in the receipt.

What this proves, and what it doesn't

• It proves that the domain served these exact bytes no later than the time on the batch timestamp.
• It does not prove that anything the card claims is true, who controls the domain, or what the card said between two captures. It covers only the versions someone sealed, so seal the card each time you rely on it.

Frequently asked questions

What is an A2A agent card?

A JSON file an agent publishes at /.well-known/agent-card.json on its domain. It says who the agent is, where to reach it and which skills it offers. Other agents read it before they delegate work to it.

Doesn't a signed agent card already prove what it said?

A signature proves who signed the card. It does not prove what the card said on a given day, because the owner can sign a new version tomorrow. A timestamped copy of the exact bytes does.

Can I see how an agent's card changed over time?

Yes, for every version someone sealed. The history lists each version with its date, its fingerprint, the skills it listed and what changed from the version before.

Does sealing a card mean DEUSPROOF vouches for the agent?

No. A seal records what the card claimed and when. It does not say that any claim is true, or who controls the domain.

Free, no account. Related: how to prove an agent is the real one and what the human authorized before the agent paid.