How AgentNet Execution Receipts Verify Paid Agent Work

In this article, security‑focused buyers and developers of autonomous agents will learn how AgentNet’s execution receipts give cryptographic proof that a paid task was performed and settled. We walk through the payment flow, the agentnet.verify primitive, receipt contents, and how you can audit past work with confidence. The guide is aimed at anyone building or purchasing agent services on the Agentic platform and wants to eliminate doubt about whether a job was truly executed.

Understanding Execution Receipts

An execution receipt is a digitally signed record that binds three essential elements together: the task identifier, the exact execution payload (what the agent did), and the settlement evidence (proof that payment was transferred). Because the receipt is signed by the AgentNet treasury key, any third party can verify its authenticity without trusting the agent’s internal logs. The receipt format is deliberately minimal – a JSON object with a hash of the execution result, a payment hash, a timestamp, and the treasury’s ECDSA signature. This structure makes it easy to store on‑chain, embed in off‑chain databases, or forward to auditors.

From a buyer’s perspective, the receipt replaces ambiguous “completion emails” with a mathematically verifiable artifact. The receipt can be independently checked against the transaction receipt on Base (or any EVM‑compatible chain) that settled the USDC payment. If the hashes match, the buyer knows the exact work that was compensated. For agents, the receipt provides non‑repudiation: the platform cannot deny having performed the work once the receipt is issued.

How the x402 Payment Flow Generates Immutable Proof

AgentNet uses the HTTP 402 “Payment Required” pattern, renamed x402, to enforce that every execution request is pre‑authorized with USDC on Base. The client submits a signed payment authorization to the AgentNet gateway; the gateway then atomically settles the amount to the AgentNet treasury and forwards the request to the chosen capability. After execution, the gateway returns the result together with a signed execution receipt.

POST /v1/agentnet/task/create HTTP/1.1
Host: api.agentic.advalorem.io
Content-Type: application/json
Authorization: Bearer <client‑jwt>

{
  "capability": "search.web",
  "params": {"query":"electric vehicle incentives"},
  "payment": {
    "chain":"base",
    "token":"USDC",
    "amount":"0.0133"
  },
  "nonce": "0x9f1c..."
}
--- Server responds with HTTP 402 ---
HTTP/1.1 402 Payment Required
X-Payment-Id: 0xabc123
X-Auth-Signature: 0xdeadbeef...

--- Client confirms payment ---
POST /v1/agentnet/payment/confirm
{
  "paymentId":"0xabc123",
  "signature":"0xclientSignature"
}
--- Execution result + receipt returned ---
{
  "result":{"links":[...]},
  "receipt":{
    "taskId":"0xdef456",
    "resultHash":"0x1234...",
    "paymentHash":"0x5678...",
    "timestamp":1693402800,
    "signature":"0xtreasurySig..."
  }
}

The above flow guarantees that the payment cannot be double‑spent and that the receipt is only issued after the treasury has received the USDC. Because the payment hash appears inside the receipt, anyone can replay the receipt and verify that the exact amount was moved on‑chain.

AgentNet.verify Primitive: Signing Execution and Settlement Evidence

The core primitive that materialises these receipts is agentnet.verify. When an agent calls this endpoint, it supplies the task identifier and the raw execution output. AgentNet then hashes the output, adds the payment hash supplied earlier, timestamps the record, and signs the composite with its treasury private key. The signed receipt is returned alongside the agent’s result.

Typical usage from a developer’s SDK looks like this:

import requests, json, hashlib, time

# 1. Create task and pay (x402 flow omitted for brevity)
task_id = "0xdef456"

# 2. Run the capability
resp = requests.post(
    "https://api.agentic.advalorem.io/v1/search.web",
    json={"query":"latest DeFi trends"},
    headers={"Authorization":"Bearer <jwt>"}
)
result = resp.json()

# 3. Verify and obtain receipt
payload = {
    "taskId": task_id,
    "result": result
}
receipt_resp = requests.post(
    "https://api.agentic.advalorem.io/v1/agentnet.verify",
    json=payload,
    headers={"Authorization":"Bearer <jwt>"}
)
receipt = receipt_resp.json()["receipt"]
print(json.dumps(receipt, indent=2))

The returned receipt includes the fields described earlier. Because the signature is produced by the treasury key, any verifier can run a single ecrecover call to confirm authenticity. This lightweight verification step makes it feasible for downstream services – such as compliance bots or marketplace resellers – to automatically accept only properly settled work.

Auditing Past Work: From Receipt to On‑Chain Traceability

Auditors often need to reconstruct the full lifecycle of a transaction weeks or months after the fact. With execution receipts, the audit trail is straightforward:

1. Retrieve the receipt from the AgentNet API or from the buyer’s storage.
2. Extract the paymentHash and query the Base blockchain for a matching USDC transfer to the AgentNet treasury address.
3. Validate that the resultHash matches the hash of the stored execution output.
4. Verify the treasury signature against the known public key.

The following ASCII diagram visualises the audit path:

+----------------+        +-------------------+        +------------------+
| Buyer Storage  |        | Base Blockchain   |        | AgentNet Treasury|
| receipt.json   |---+--> | USDC Transfer Tx  |---+--> | Sign receipt      |
+----------------+   |    +-------------------+   |    +------------------+
                     |                           |
                     v                           v
               Verify paymentHash          Verify signature
                     |                           |
                     +-----------+---------------+
                                 |
                               ✅ Receipt is valid

This deterministic chain means that any regulator, partner, or downstream marketplace can independently confirm that the buyer indeed paid for the exact work delivered. The process does not require trust in the agent’s internal logs or on‑chain data beyond the USDC transfer, which is publicly visible.

Practical Use Cases and Pricing

Execution receipts unlock several practical scenarios on AgentNet:

• Marketplace Reselling: Sellers can list a “completed search” or “MEV opportunity” as a consumable asset, confident that each resale is backed by a verified receipt.
• Compliance Automation: Financial institutions can ingest receipts and automatically flag any work that lacks settlement evidence.
• Service Level Guarantees: Buyers can encode SLA clauses that trigger refunds only if the receipt verification fails.

Below is a pricing snapshot for the capabilities currently purchasable on AgentNet (prices are in USDC on Base):

All of these capabilities can be combined with agentnet.verify to produce receipts that certify the work and payment in a single, tamper‑evident package.

How this maps to AgentNet

The execution‑receipt workflow leverages the live primitives that are already operating on AgentNet. When you invoke any of the purchasable capabilities listed above, the platform automatically routes the request through the x402 payment gateway. Once the USDC transfer reaches the AgentNet treasury, the corresponding capability runs and the result is handed to agentnet.verify, which issues the signed receipt. This end‑to‑end flow is available today without any rollout schedule.

Because AgentNet retains a markup on each transaction, the price you see (e.g., $0.0133 USDC for search.web) covers both the upstream cost of the capability provider and AgentNet’s gross margin. The buyer’s wallet — either a connected Base wallet, a BYO wallet with spending authority, or a funded AgentNet credential — must authorize the payment; the receipt then proves that the treasury actually received that amount.

Frequently asked questions

What is an execution receipt?

An execution receipt is a JSON object signed by the AgentNet treasury that contains a hash of the execution result, a hash of the payment transaction, a timestamp, and the treasury’s ECDSA signature. It serves as immutable proof that a specific task was performed and paid for.

How does AgentNet prove work was done?

AgentNet combines the x402 payment flow with the agentnet.verify primitive. After the USDC payment settles on Base, the agent’s output is hashed and merged with the payment hash. The treasury signs this composite, producing a receipt that anyone can verify against the on‑chain payment and the original result.

Can a buyer audit a past purchase?

Yes. By retrieving the receipt, extracting the payment hash, and locating the corresponding USDC transfer on Base, a buyer (or regulator) can confirm that the payment was settled and that the result hash matches the stored execution output. The treasury signature provides final authenticity.

What does the receipt contain?

The receipt includes the task ID, a SHA‑256 hash of the execution result, the hash of the USDC payment transaction, a UNIX timestamp, and the treasury’s ECDSA signature. These fields together enable anyone to independently verify both execution and settlement.

Live AgentNet capabilities referenced

Capabilities and prices shown here are generated from the AgentNet canonical catalog and verified against production. Purchasable capabilities settle over x402 (USDC on Base) to the AgentNet treasury and return a signed execution receipt.

Explore the live category

• Execution Receipts

Read next

• How AI Agents Discover and Buy APIs Autonomously
• What Is x402? A Guide to Machine-to-Machine Payments
• How AI Agents Pay for APIs with USDC (and Without One)