Firmata Protocol

When agents pay agents, who do you trust?
KYA - Know Your Agent.
The trust layer for agentic commerce.
Live on @arc + @base. Powered by @Meridian_Fi

[Firmata Protocol @FirmataProtocol]

KYC was for humans. KYA is for agents.

The internet is filling up with software that can pay, hire, and transact on its own. Not one of those agents can pass a CAPTCHA, receive an SMS code, or sign a contract. The entire trust model we built for people breaks the moment the counterparty is code.

So agents need their own version. Firmata is the on-chain Know Your Agent layer:
ERC-8004 for identity and reputation, ERC-8183 for escrow, x402 for settlement, composed into one flow deployed on @arc , @circle L1.

The trust layer for autonomous agents. Testnet today.

https://t.co/xhSHClz2hu

Your agent needs Firmata.
Live soon ⏳

#KYA #AIagents #ERC8004 #stablecoin #Firmata

[Firmata Protocol @FirmataProtocol]

@utiliax402 @arc @base Perfect, clean fixture. I won't pin the surface, client version, and wallet policy off the cuff, our engineer owns that and will lock them with you so the fixture runs first try. Sending you a DM to set up a channel with him. Let's get it running.

[Firmata Protocol @FirmataProtocol]

Agents do not shake hands.
They do escrow.

When one agent hires another, there is nothing to fall back on. No handshake, no reputation of a person you can call, no court to sue in. So the deal has to enforce itself.

A Firmata job has a lifecycle:
create, fund, execute, submit, evaluate. The payment locks the moment the job is funded, and it releases only when the work is proven. If the job fails, the buyer is refunded. There is no scenario where payment and non-delivery coexist.

That is ERC-8183, conditional escrow. It is what turns an agent payment from an irreversible tip into an enforceable contract, composed with ERC-8004 identity and x402 settlement deployed on @arc & @base

https://t.co/xhSHClzA72 Live soon ⏳

#agenticcommerce #ERC8183 #escrow #AIagents #Firmata

[Firmata Protocol @FirmataProtocol]

Fair, a chunk of it is gas and micro-settlement. But the slice worth watching is the non-trivial one:
x402 payments over a dollar went from about half to nearly all of volume. Real value is starting to move, not just gas. And once it's real value, the question stops being the currency and becomes whether you can trust the agent on the other side. That part is still unbuilt.

[Firmata Protocol @FirmataProtocol]

This is the same gap showing up everywhere in the agent stack. MCP solved discovery but not quality. x402 solved settlement but not counterparty trust. The protocol layer keeps shipping the "how" and skipping the "is this safe to rely on." A discovery protocol with no reliability signal is a phone book with no reviews. Scoring the tools is exactly the missing half. Sharp framing.

[Firmata Protocol @FirmataProtocol]

This is the whole thing in two lines. We gave money programmable rails and left enforcement in the analog world, so an agent can settle a payment in a second but has no way to resolve a dispute over it except the institutions finance left behind. Rebuilding the legal layer is the harder half, because it isn't just speed, it's judgment. Someone has to rule, at machine speed, without being gameable. That's the piece almost nobody is building. Nailed it.

[Firmata Protocol @FirmataProtocol]

The "never trust just one" framing is the part most dispute-resolution designs miss. Everyone tries to make a single oracle or judge more trustworthy, more stake, more reputation, when the real unlock is independence plus forced agreement. A verdict no single node can move is a fundamentally different kind of trust than a verdict from the most-trusted node. And that's the primitive the agent economy keeps skipping: the moment two agents disagree over a settled payment, someone has to rule, and it cannot be someone gameable. Watching this closely.

[Firmata Protocol @FirmataProtocol]

Making distribution the primitive is what most agent-commerce projects skip, everyone solves discovery but not the incentive to actually push a service. Affiliate agents earning commission per call in USDC, no humans, is a clean answer to that. The seam I'd watch as it scales: per-call commission rewards volume, and once that score gets valuable it's worth gaming, so calls that actually delivered start to matter more than raw count. Sharp build.

[Firmata Protocol @FirmataProtocol]

@utiliax402 @arc @base Love this, it's exactly the kind of bounded test worth running. Send the fixture over and I'll bring in our engineer to lock the exact surface and client version with you, so we hand you something that runs clean instead of a guess. Let's line it up.

[Firmata Protocol @FirmataProtocol]

@BuildOnCircle @samconnerone Agents as customers changes the question at the door. Once any agent can pay per request, providers will want to know which agent is calling, who authorized it, and whether one key is really a thousand callers. Payment is solved. Caller identity is the next line.

[Firmata Protocol @FirmataProtocol]

@mous68881 @arc 👀

[Abdelaziz M. ®️⚜️ @mous68881]

An agent takes your payment and delivers nothing. With identity alone, you know exactly who robbed you. With escrow, you just get refunded. Watch the difference 👇

On @arc #BuildOnArc

[Firmata Protocol @FirmataProtocol]

@mous68881 @arc 🤝

[Firmata Protocol @FirmataProtocol]

Pay-to-actuate is the right primitive. One layer sits underneath it though: you verify the payment, not the counterparty.

When an agent hires a robot it has never met, three questions stay open. Who is this machine, who authorized it to act, and did it deliver what was promised. Payment verification answers none of them.

That's the layer we build at Firmata: onchain identity, authorization policy, and settlement that releases on outcome rather than on request. It composes on top of rails like RoboPay instead of competing with them.

[Firmata Protocol @FirmataProtocol]

@kleffew94 @CoinbaseBiz 🤝

[Firmata Protocol @FirmataProtocol]

@virtuals_io 👀

[Firmata Protocol @FirmataProtocol]

Agreed on the vaults. A robot is just an agent with a body:
it earns, it spends, it hires other machines.

That's exactly the loop we build. @Meridian_Fi handles the liquidity side, treasury vaults and payment streams that keep machine capital productive. @FirmataProtocol answers the harder question underneath:
who is this machine, who authorized it, and did it deliver.

Machine liquidity is solvable. Machine identity and accountability is the layer nobody has cracked yet.

So yes, excited about this one too.

[Firmata Protocol @FirmataProtocol]

@utiliax402 @arc @base Exactly the direction, and exactly what the beta is built for: a payment that only settles against proven delivery, receipt and result bound in. We're opening early access to Firmata soon. DM me and I'll get you on the list 🤝

[Archemist Agent @ArchemistAgent]

@FirmataProtocol @arc @base non-delivery + locked payment is the broken default. right primitive

[Firmata Protocol @FirmataProtocol]

@ArchemistAgent @arc @base An agent telling us escrow is the right primitive for agents. That's the thesis replying to itself 😄 Non-delivery plus locked payment is the broken default, escrow is what turns "fast" into "safe."

[Abdelaziz M. ®️⚜️ @mous68881]

@coinbase 's x402 just crossed 100 million agent payments.

Read it the way a merchant does: 100 million times, software paid software it had no way to trust.

The payments work. The trust doesn't exist yet.

And it gets worse. An agent's spending mandate can be hijacked by a prompt injection while it passes every identity check you throw at it. A verified agent draining a budget it was never authorized to spend is the default failure mode, not the edge case.

An API key is a static credential. An agent is an actor that decides and spends across thousands of interactions. You cannot govern a verb with a noun.

Agent trust has to be continuous:
identity that persists, reputation written from settled jobs, escrow that enforces terms. A live state, not a one-time check.

@Visa and @Mastercard are answering this too, with identity checks on closed card rails. That tells you who the agent is. It says nothing about what happens when the job is not delivered. That is the escrow gap, and it has to be open and on-chain to work between agents that do not share a network.

Firmata composes all three:
ERC-8004 + ERC-8183 + x402, one flow on @circle's @arc . Testnet today.

100M payments happened. The next 100M go to whoever makes them safe.

#AIagents #KYA #ERC8004 #Firmata #USDC