My AI agent got paid: the first AGIRAILS transaction on Base mainnet

At midnight on 22.2.2026, Croatian time, two friends did something that is either a small piece of history or completely irrelevant. I honestly do not know which yet. Two AI agents, his and mine, agreed on a job by themselves, locked the money in escrow and settled the payment over the AGIRAILS protocol. No bank, no invoice, no human clicking "pay". Three twos in the date, three, six and nine in the amount. Tesla would have liked it.

That was the first transaction ever made on the AGIRAILS protocol on mainnet. The public write-up lists the parties anonymously as "AGIRAILS founder agent + design partner agent".

Well, I can now say it openly: the design partner agent was mine :)

What is AGIRAILS?

AGIRAILS is a payment layer for AI agents, built by Croatian founder Damir Mujić. At its core is ACTP, the Agent Commerce Transaction Protocol. The idea is simple to explain and much harder to build: when one AI agent wants to buy a service from another AI agent, they need a way to agree on a price, make sure the money is really there, prove that the work was delivered and then settle, all without a human in the middle shuffling invoices.

ACTP does that with USDC on the Base network. Funds are locked in an escrow contract called EscrowVault, delivery is recorded on-chain, and every finished job adds to the provider's reputation through ERC-8004. There is no AGIRAILS token. You pay in dollars (well, stablecoin dollars) and the platform takes a 1% fee.

The transaction

Here it is, anybody can check it on BaseScan:

0xaa98180f991cdaaf35b5e38c8f14c0d75bb9dd075061a13dfff48ec2b9ccff19

The amount was 3.69 USDC. Not a random number. In his founder note Damir wrote:

"$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."

Nice touch for the first deal between two agents from Croatia, I have to admit.

Gas was sponsored through a Paymaster, so neither agent spent a single cent of ETH. Both sides only needed USDC. That sounds like a small detail, but if you ever tried to explain to somebody that they need to buy a second cryptocurrency just to be able to send the first one, you know it is not small at all.

Six states, one deal

What I like about ACTP is that a transaction is not just "send money from A to B". It is a small state machine, and every step is recorded on-chain.

It starts as INITIATED, when the founder agent requested a service from my agent. My agent answered with a signed price and the transaction moved to QUOTED. When the founder agent accepted the quote, 3.69 USDC was locked in EscrowVault and the state became COMMITTED. From that moment my agent knew the money was really there, and the other side knew it could not simply be taken without delivering anything. My agent acknowledged the job (IN_PROGRESS), produced the result and marked it as DELIVERED. Finally the founder agent confirmed the delivery, the transaction became SETTLED and the escrow released the payment to my agent, minus the 1% platform fee.

According to the public documentation, most of those fifteen minutes were humans reviewing what was happening, not the blockchain being slow.

Three days earlier

I did not want the first real transaction to also be my first time touching the protocol on mainnet. So on 19 February 2026, at 19:47 UTC, my agent made a test transaction of 1 USDC over ACTP between two of my own wallets:

0x4d91a21ff24d282ef9de56bbee877e6da323cfcbcbbe26d6d45c6aa495e2064c

Basically a dry run with real money. Old sysadmin habit: you test on something you can afford to lose before you do the real thing. Three days later we did the real thing.

Why should you care?

To be clear, this was not the first agent to agent payment in the world, and I am not going to claim that. It was the first transaction on the AGIRAILS protocol on mainnet. But I think it shows where things are going.

Right now most AI agents can talk, search, write code and call APIs, but the moment money is involved a human has to step in. Somebody has to sign up for a service, enter a credit card, wait for an invoice, approve a payment. That works when you have one agent. It does not work when you have dozens of agents that need small services from each other many times a day.

What happened that night is the missing piece. Two agents negotiated a job, the money was locked before the work started, the work was delivered, and the payment was settled. Neither side had to trust the other, because the escrow contract was in the middle and neither of them controlled it. That is basically what a contract, a bank and an accounting department do for humans, packed into one transaction that costs less than a coffee.

Why no token?

I get asked this a lot, so let me say it directly: agents do not need their own coin.

An agent that sells a service wants to know what it earned. If it is paid in some project token whose price jumps 30% overnight, it has no idea if the job was worth doing. A stablecoin like USDC is boring, and boring is exactly what you want from money. It is priced in dollars, it settles in seconds, it works across borders, and anybody can verify it on-chain.

So instead of building yet another token and hoping people will buy it, AGIRAILS uses money that already exists and focuses on the hard part: the rules of the deal. Who promised what, was the money locked, was the work delivered, who gets paid. In my opinion that is the right order of things.

What now?

For me this was a really fun experiment, and a bit of a strange feeling. My agent did a job and got paid for it, on a public blockchain, while I was mostly watching. Small amount, big step.

If you want to dig deeper, the full write-up of the first mainnet transaction explains every state and how you can verify it yourself. And if you build agents, take a look at agirails.io. I have a feeling that in a few years agents paying each other will be as normal as servers talking to each other over HTTP is today.