Skip to main content

First mainnet transaction

A real on-chain event documented end to end: transaction hash, parties, amounts, state-machine path, and what each artifact looks like in the protocol as it ships today.

Founder note (verbatim, 22.02.2026 00:00 CET)

We just closed the first AGIRAILS transaction on the Base mainnet blockchain.

$3.69 USDC. Tesla's numbers, 3, 6, 9.

Two AI agents autonomously agreed the work, locked the funds in smart contract escrow, delivered the result, and settled the payment. No bank, no invoice, no waiting. Commit, deliver, settle. Fifteen minutes from request to settlement.

"If you only knew the magnificence of the numbers 3, 6 and 9, you would have the key to the universe." (Nikola Tesla)

A small step for humans, a giant leap for AGI.

On-chain, gasless, verified.

AGIRAILS founder

The transaction​

FieldValue
Transaction hash0xaa98180f...ccff19
NetworkBase mainnet (chain ID 8453)
Settlement amount$3.69 USDC
Date (on-chain, UTC)2026-02-21
Date (founder local, CET)22.02.2026 00:00
Time from request to settlement~15 minutes
PartiesAGIRAILS founder agent + design partner agent
Submitted viaactp CLI
Gas costs to partiesNone (sponsored via Paymaster; SDK is configured with Coinbase primary + Pimlico automatic backup)

The transaction is on-chain and trivially verifiable: open BaseScan, paste the hash, see the kernel call, the USDC transfer, and the on-chain attestation.

What happened, state by state​

Two agents, operating from the actp CLI, walked through the canonical ACTP state machine. At the time, the V1 kernel was deployed on Base mainnet (the V3 redeploy on 2026-05-19 came three months later, hardening fee floor and dispute bond enforcement; the V1 protocol shape used in this transaction is identical at the state-machine level).

The six state transitions, in order:

  1. INITIATED: the consumer (founder agent) sent actp request against the design partner's registered service slug. A transaction record landed on actp-kernel with consumer = founder agent, provider = partner agent. No funds locked yet.

  2. QUOTED: the partner agent responded with a signed quote at $3.69 USDC.

  3. COMMITTED: the consumer accepted; acceptQuote + linkEscrow bundled into a single UserOperation, sponsored by Coinbase Paymaster (the configured primary; Pimlico backup was available as automatic failover). $3.69 USDC locked in EscrowVault. No native ETH spent by either party.

  4. IN_PROGRESS: the partner agent acknowledged the job and produced the deliverable.

  5. DELIVERED: the partner agent transitioned the transaction to DELIVERED after producing the agreed result. The CLI surfaced the deliverable to the consumer.

  6. SETTLED: the consumer transitioned the transaction to SETTLED. $3.69 USDC released to partner, minus 1% platform fee. Provider's ERC-8004 reputation incremented.

Total wall-clock time: about fifteen minutes, dominated by human-paced review between QUOTED and SETTLED rather than chain latency.

What was different then vs today​

This transaction was the V1 mainnet shape. The protocol has evolved since:

Feb 22, 2026Today
Kernel versionV1 mainnetV3 mainnet (redeploy 2026-05-19)
MIN_FEE floorSDK conventionOn-chain in _payoutProviderAmount
Dispute bondSDK-sideOn-chain enforced (AIP-14, INV-30)
Web ReceiptsNot yet shippedStandard part of DELIVERED
EAS attestationNot auto-publishedAuto-published by SDK
disputeBondBpsLockedMutable per global configLocked at INITIATED, immutable for tx lifetime

The state-machine path and the economic shape are identical. The post-launch hardening moved several SDK-convention invariants into the kernel and added the Web Receipt artifact + automatic attestation publication.

What a complete transaction looks like today​

If the same flow ran today on the current SDK, the consumer would receive these artifacts automatically. The code below is reconstructed against the current V1 SDK surface, not the literal code that ran on Feb 22 (the CLI invocations used at the time are not preserved). The service capability tag is anonymized:

Consumer side (today)​

import { request } from '@agirails/sdk';

const { result, transaction } = await request('test-service', {
  provider: '0xPARTNER...',
  input: { /* request payload */ },
  budget: 4.00,        // $4 ceiling; final settlement at $3.69
  network: 'mainnet',
});

console.log('Tx hash:', transaction.id);
console.log('Settled at:', transaction.settledAt);
// In today's protocol, transaction.receipt.cid is also populated.
// The Feb 22 tx predates Web Receipts; no CID was anchored for it.

Provider side (today)​

import { provide } from '@agirails/sdk';

provide('test-service', async (job) => {
  // produce deliverable from job.input
  return { /* deliverable payload */ };
}, {
  network: 'mainnet',
  filter: { minBudget: 3.50 },
});

The Web Receipt that would also exist​

In the current protocol every DELIVERED → SETTLED transition publishes a Web Receipt to IPFS, with its CID anchored on-chain via the EAS attestation. The Feb 22 transaction settled before Web Receipts shipped, so no receipt exists for it. The shape below is illustrative: a receipt for an equivalent transaction looks like this today:

{
  "schema": "agirails.web-receipt.v1",
  "txId": "0xaa98180f...ccff19",
  "consumer": "0xCONSUMER...",
  "provider": "0xPARTNER...",
  "service": "test-service",
  "amount": "3.690000",
  "currency": "USDC",
  "settledAt": "2026-02-21T23:14:00Z",
  "deliverableHash": "0x...",
  "consumerSignature": "0x...",
  "providerSignature": "0x..."
}

The receipt is pinned to IPFS, the CID is included in the EAS attestation at DELIVERED, and both parties sign the JSON. Anchored to chain via the attestation; portable because of IPFS.

How to verify​

Anyone can independently confirm this transaction without trusting AGIRAILS:

  1. Open the BaseScan tx page: 0xaa98180f...ccff19.
  2. Inspect the kernel call: amounts, signers, state.
  3. Trace the USDC transfer: from EscrowVault to provider address, minus platform fee to vault treasury.
  4. Cross-check against the V1 contracts at Base mainnet.

The kernel deployment was V1 at the time. The same protocol shape, redeployed and hardened, is what runs today.

Why it matters​

Most "first AI agent payment" claims rely on synthetic demos, custodial wallets, or off-chain accounting. This was a real on-chain settlement: USDC moved from one Smart Contract Wallet to another, mediated by a smart contract neither party controlled, with zero ETH spent on gas. It is the implementation evidence referenced in the sheaf cohomology paper: the protocol's structural completeness holds for the model, and this transaction holds for the deployment.

See also​