State Channels and Agentic Payments
I’ve spent almost a decade obsessed with one idea: software paying software. Back in 2017, a bunch of us poured years into building state channels on Ethereum, infrastructure for machines to stream micropayments to each other. The tech worked really well, but nobody needed it yet. People used blockchains to trade tokens, not to make payments. AI agents changed that. They’re exactly the software we were waiting for, so we built the Machine Payments Protocol with Stripe to give them a way to pay.
State channels on Ethereum
When I started working on Ethereum in 2016, the thing that pulled me in was payments. The idea that two pieces of software could transfer value to each other without a bank or a payment processor in between. Ethereum showed the promise of this, but the problem for years was that it was too slow and too expensive for payments to take off. A single transaction cost a few dollars in gas and took minutes to confirm.
So, in 2017, Jeff Coleman and I started working on state channels. The core insight was that you don’t need to put every transaction onchain. Instead, two parties could lock funds into a multisig contract, exchange signed transactions offchain at whatever speed they want, and only settle the net result back to the blockchain.
And it worked really well. Instant transactions, zero fees, thousands of TPS between two peers, all settling as a single onchain transaction. We also came up with this idea we called counterfactual instantiation, treating contracts as deployed even though they hadn’t touched the chain, which ended up motivating Vitalik to author EIP-1014, the CREATE2 opcode now foundational to account abstraction and cross-chain deployments.
What we were really building, though, was payment infrastructure for machines. My favorite demo that we built was Web3Torrent, a torrenting client where peers paid each other micropayments for each chunk of data they downloaded. A peer would open a state channel with a seeder, download pieces of a file, and send a tiny payment for each piece. It was really cool to see it work.
A solution without a problem
The problem with state channels though was that it had no users. The applications we kept writing about, streaming payments between IoT devices and game servers and torrent peers, all required autonomous software on both sides of every transaction, software that could discover a service, negotiate a price, authorize a payment, and consume the result without a human clicking a button. The harnesses for this didn’t really exist yet, so we had to show the potential by writing demos. We were building infrastructure for a world that hadn’t arrived yet.
State channels were specifically designed for payments, but most people using Ethereum were doing DeFi and trading, not payments. There just wasn’t enough demand. So rollups turned out to be the more general scaling answer, and several of us spent a few years working on that instead.
In recent years though, stablecoins have really taken off. Payments on blockchains went from a niche idea to the fastest growing use case in crypto, and that’s a big part of what led us to build Tempo, a blockchain designed from the ground up for stablecoin payments. But even with all of that progress, machines streaming micropayments to each other was still hypothetical. Nobody was actually doing it.
Agents are the customer state channels were made for
I think that what’s happening with agents right now is finally changing that. If you’ve used Codex, Claude Code, or Amp in the last few months, you can see how dramatic of a paradigm shift AI is going to be. An agent can write code, spin up infrastructure, pull data from a dozen sources, run tests, and ship a PR. All without you. Agents are becoming the default way that people do software engineering and many different kinds of knowledge work already.
But agents don’t pay like humans. An agent might make thousands of small decisions a day, each one needing low-latency, programmatic payments. And right now there’s no standard way to do that. You either hardcode an API key with a pre-paid balance or you try to find a way to get your agent to submit using a card checkout form on a headless browser.
I think that agentic payments are the killer app state channels never had. They’re autonomous software that needs to transact with other software, at high frequency, for small amounts, without human intervention. An agent already reasons about goals, evaluates tradeoffs, and decides what actions to take. Giving it a spending policy and letting it act within that policy is the kind of bounded decision-making agents are built for.
Introducing the Machine Payments Protocol
That’s why we built the Machine Payments Protocol with Stripe. With MPP, an agent can request a resource, a service names a price, and the agent pays from its wallet without any human in the loop, billing agreement, or credit card on file. We’ve even proposed it to the IETF as an open standard built on HTTP 402. And while it works exceptionally well for stablecoin payments, it’s actually entirely agnostic to blockchains and even tokens. Visa has already extended it to work with cards.
For example, Browserbase lets agents spin up headless browsers and pay per session, Parallel gives agents programmatic web access with per-call payments, and even physical-world services can work with MPP: agents can pay to print and send mail through Postalform.
And at the core of MPP are the concept of sessions that let an agent authorize once with a service provider, commit some funds upfront, then stream micropayments within the session, and settle once at the end. Thousands of payments, one settlement. Sessions are state channels, just the most basic kind. And with Tempo, we plan to enshrine these payments natively into the chain.
MPP is live today on Tempo Mainnet, which is also now open for developers.
If you’re building agents and want them to pay for services, I encourage you to read the spec or get started with the SDK. If you’re running a service and want agents to be able to pay you, list it in the Payments Directory. If you just want to try it out, check out Tempo Wallet, which is a wallet designed primarily for managing your agentic payments.
Stablecoins are taking off for enterprise use cases like payroll, remittances, and embedded finance, and agentic payments are just getting started. There are so many ideas from a decade of working on Ethereum scaling that we’re finally going to realize with Tempo, and MPP is just the first. We’re hiring. If you want to work directly with me on bringing these ideas to life, email me at liam@tempo.xyz.