Light Paper: Grindery Protocol V3
Introduction
The Agentic Web is the next stage of the internet: instead of humans clicking through interfaces, autonomous agents will carry out tasks on our behalf. These agents will plan, negotiate, and transact with other agents, unlocking entirely new ways for software to work for us. The shift is already underway, as major technology companies adopt agent frameworks and research increasingly shows how multi-agent systems can transform everything from enterprise automation to consumer services .
But to make the Agentic Web real, a host of challenges need to be solved. Agents must discover and trust one another, interoperate across open protocols, and stay safe under human oversight. They need ways to share context, attribute actions, and prove accountability. And critically, they must be able to exchange value reliably and at scale — because without payments, there is no economy to sustain their work.
This is where today's infrastructure falls short. Fiat payment systems, especially credit cards, are completely unsuited to agent-scale activity. They are too slow — settlement takes days, not milliseconds. They are too expensive — a fixed fee of $0.20 to $0.30 per transaction makes it impossible to pay for a $0.002 service call. And they are optimized for large, infrequent human purchases, not the rapid fire, machine-to-machine interactions the Agentic Web depends on.
Recognizing this gap, many blockchain protocols have emerged with the goal of enabling micropayments. Yet they stumble on the same hurdles. Settlement-first models force every transaction to wait for block confirmation, adding seconds of latency where only milliseconds are tolerable. Even "cheap" networks charge fees larger than the value of most agent calls, breaking the economics. Channel-based systems require capital to be locked up and pre-negotiated, which doesn't work in a world where agents constantly interact with new providers. And approaches like probabilistic or streaming payments fit narrow use cases but fail for the heterogeneous, disputable tasks agents actually perform.
What is needed is a new kind of protocol — one designed specifically for the Agentic Web. Its vision is clear: enable agents to transact at machine speed, with costs that shrink to near zero as usage scales, while giving users confidence that charges are controlled and reversible, and providers certainty that valid payments will be honored. To people and businesses, it should feel as seamless as today's toll systems or credit cards, integrating smoothly with existing billing and accounting processes. To agents, it should be invisible — a background layer that makes every micro-interaction economically viable. In short, the protocol must become the economic backbone of the Agentic Web, as fundamental as HTTP was for the Web itself.
Current systems not a good fit
For the Agentic Web to really work, we need a billing system that clears five hurdles. First, the cost per transaction has to be basically zero, because many of these agent-to-agent calls are worth less than a cent. Second, payments have to authorize instantly, in milliseconds, otherwise chained workflows grind to a halt. Third, costs have to be traceable back through chains of agents so users don't get "bill shock" and providers know they'll get paid. Fourth, it has to work in the normal world, where people don't want to mess with wallets or tokens — ideally the blockchain part is invisible. And fifth, it has to be simple for developers to drop into their apps, like Stripe is today.
Now, when you look at existing approaches, each one falls down somewhere.
Take on-chain settle-before-service (e.g: x402) — the simplest model, where every micro-payment is written to the blockchain before the service runs. That works fine if you don't mind paying a few cents per transaction and waiting a few seconds, but that breaks as soon as you're dealing with sub-cent agent calls that need to run in real time. You could bolt on an off-chain credit system with batching and attribution, but at that point you've basically built a different protocol.
State channels (like Raiden or Connext) were designed to make lots of payments back and forth between the same two parties cheap and instant. Great if you're Uber paying a driver 1,000 times a day, but in the Agentic Web, agents are constantly talking to new services. Channels break down because you can't open one with everyone on the fly, and it gets worse when you add locked liquidity and the need to track attribution across hops. You could try liquidity hubs and off-chain logs, but then it's no longer the lean channel idea.
Payment channel networks like Lightning extend channels so you can route across a graph of connections. That makes sense for peer-to-peer Bitcoin payments, but not for agents firing off thousands of tiny, traceable calls. Routing can be slow or unreliable, liquidity fees stack up, and there's no clean way to carry attribution metadata through. You could centralize the routing to fix some of this, but then you lose the point of the network.
ERC-20 allowances and permits — the idea of pre-approving a spender to pull funds — are fast and cheap, but unsafe. They're either too generous (blank checks) or so small they need constant refreshing, which brings the cost and latency back. You'd need a whole new layer to add limits, disputes, and attribution, and once you do that, it's not really an allowance anymore, it's something new.
Escrow contracts are perfect for big, infrequent jobs: deposit money, release it when milestones are hit. But for agent billing, they're way too heavy. Funding and releasing escrows costs more than the transaction itself, and waiting on block times kills responsiveness. You could morph escrows into pooled vaults with off-chain charge logging, but that's basically the Grindery Protocol model already.
Probabilistic micropayments — like giving a provider lottery tickets that average out to the right value — are clever for streaming video or bandwidth. But they don't work when every call is different, disputable, and needs precise attribution. You can patch it with metadata and smoothing, but you lose the efficiency that made it attractive.
Streaming payments (like Superfluid or Sablier) are great for subscriptions or "renting" something by the minute. Money just flows while the stream is open. But agent billing isn't like that — it's lots of discrete little calls, often across chains of services. Trying to chop a stream into per-task slices with logs and disputes is just awkward.
When you step back, the pattern is clear: every one of these systems either fails the cost and latency test, or it can't handle attribution and user protection, or it's too hard to integrate outside the crypto bubble. And whenever you try to "fix" them, you end up bolting on credit scopes, dispute windows, task IDs, batching, fiat ramps, and a developer-friendly API — in other words, you are building an entirely new system.
A Protocol for the Agentic Web
A new protocol is needed. And at its heart, the idea is simple: separate authorization from settlement.
When an agent wants to act, it shouldn't need to wait for money to move on-chain or through a bank. Instead, the system checks in real time whether the agent has a valid credit scope or balance, logs the intent to charge, and lets the task run instantly. The actual movement of funds happens later, in large batches, once the dust has settled and users have had the chance to dispute or reject invalid charges.
This is the same principle that makes credit cards and electronic toll systems work in the physical world. You tap, you go — the clearing and reconciliation happen afterwards. The Grindery Protocol brings that model to the digital economy, but tuned for the scale and precision the Agentic Web demands.
How it works in more detail
- Scoped Credit: Users pre-fund a small balance or extend a limited credit line. They authorize agents with spending scopes — caps, rate limits, purposes, and expiry. This ensures autonomy is bounded and revocable.
- Instant Authorization: When a charge request comes in, the system checks authoriztion records cached in an off-chain database in milliseconds that credit and scope exist. If valid, the service executes immediately.
- Tamper-Evident Logging: Each charge is recorded in a shared, append-only ledger (a Cross-Agent Billing Ledger). It binds the principal, the provider, the task ID, and the metering evidence, so charges can always be attributed and audited.
- Dispute Window: Users have a set period to reject unwanted charges. This provides the same safety net as chargebacks, but in a lightweight and programmable way.
- Batch Settlement: Accepted charges are netted and settled together. Instead of thousands of on-chain transactions, one settlement moves all funds, driving per-call costs effectively to zero.
With this design, the Grindery Protocol directly addresses the hardest problems of the Agentic Web.
Cost of Micro-Transactions.
Because all charges are logged off-chain and only settled in batches, the cost per individual call approaches zero. A thousand agent-to-agent calls can be cleared with the same single settlement fee. This finally makes sub-cent interactions economically viable.
Latency at Scale.
Authorization is handled by an off-chain credit check that takes milliseconds. An agent chain with ten or even a hundred steps runs without noticeable delay, because none of the calls wait for on-chain settlement.
Cascading Billing and Attribution.
Every charge carries the principal, the task ID, and the agent scope that triggered it. Even if an agent delegates work to another agent, which delegates again, the costs remain traceable back to the original user. At the same time, the dispute window gives users control against "bill shock," while the pre-funded balance or credit line ensures providers can trust they'll be paid.
Non-Crypto World Compatibility.
Here is where smart wallets matter. With account abstraction, users don't need to manage keys, seed phrases, or gas tokens. They can top up balances in familiar ways — via card, bank transfer, or stable payment rails — while the wallet handles the conversion behind the scenes. To the end user, the system feels like a normal Web2 payment flow, even though settlement happens on-chain.
Ease of Integration
For developers, the Grindery Protocol can be dropped in like Stripe. Instead of reinventing billing logic, they just point their agents or services at the Grindery Protocol API. The smart wallet layer takes care of authorization, scope enforcement, and disputes. Metering data from existing logs is enough to generate charge entries, and reconciliation hooks make it straightforward to plug into existing accounting systems.
Implementation
As stated, on one side, the Grindery Protocol has to integrate smoothly with existing billing systems — whether it's something like Paywalls.ai or a SaaS provider's metering and invoicing stack. This should be as simple as making an API call: log a usage event, generate a charge entry, and let the protocol handle the rest. Developers shouldn't have to build settlement logic, dispute handling, or multi-hop attribution themselves — those come "for free" with the Grindery Protocol layer.
On the other side, every user and assistant needs a smart wallet to authorize charges and enforce limits. This doesn't have to feel like "crypto." Smart wallet infrastructure — such as Grindery's account abstraction stack — makes it possible to provision wallets without seed phrases, let users top up with a card or bank account, and enforce spending scopes invisibly in the background. To the end user, it feels like loading a prepaid balance in a regular app; to the agent ecosystem, it provides a programmable wallet that speaks the Grindery Protocol.
The protocol itself can be deployed as a set of smart contracts on low-cost L1s and L2s that already support stablecoins. Viable venues include Polygon (PoS and zkEVM), Arbitrum One or Nova, Base (Coinbase's L2), zkSync Era, BNB Chain / opBNB, and Optimism. Each offers cheap, high-throughput settlement and mature EVM compatibility. Beyond the EVM world, Solana stands out as a high-throughput USDC rail, already tapped by Visa pilots. Stellar and Celo (now an Ethereum L2) have long focused on remittances and payments, while XRP Ledger positions itself for cross-border bank rails. All of these will come under pressure from Circle's Arc and Stripe's Tempo networks, which aim to make USDC payments issuer-native. The Grindery Protocol can plug directly into those ecosystems, since it is settlement-agnostic — it just needs a low-cost chain where USDC is native.
Over time, the Grindery Protocol could also become its own chain — either as a specialized L2 (like a validity rollup) or as an L3 sitting on top of a popular L2. Running as a dedicated layer brings two advantages: first, predictable ultra-low fees, since economics can be tuned for microtransactions rather than generalized DeFi traffic; and second, native CABL opcodes, meaning batching, disputes, and attribution can be system calls instead of contracts. This reduces complexity for developers and guarantees performance at scale. Think of it as turning the Grindery Protocol into the "Stripe network" for agents, where the whole chain is optimized for credit-before-settlement billing.
The benefit of this flexible deployment strategy is twofold. In the near term, the Grindery Protocol can ride existing chains and their liquidity — whether that's Polygon, Arbitrum Nova, or Base — to get adoption quickly. In the longer run, it can harden into its own app-chain or supernet/subnet (on Polygon Supernets, Avalanche Subnets, or Optimism's OP Stack), ensuring costs stay near zero even as agentic traffic grows to millions of transactions per second. That way, it doesn't just survive the coming wave of USDC-native payment rails from Circle and Stripe, but actually complements them by providing the missing billing intelligence that those raw networks lack.