The cheapest blockchain transaction is not necessarily the cheapest AI-agent action. Once model inference, RPC calls, signing infrastructure, gas, protocol fees, slippage, approvals and failed retries are counted, the real cost can be many times the visible network fee.
What Matters
An AI agent does not pay only gas. A complete autonomous action can consume model tokens, RPC or indexer calls, wallet/signing infrastructure, network fees, bundler or relayer fees, protocol charges, slippage, token approvals and retries after failed execution.
DN defines Cost per Successful On-Chain Action as the total economic cost required for an agent to decide, authorize, submit and successfully complete one intended state change.
The key metric is failure-adjusted cost per success—not the fee shown in the block explorer.
DN Evidence Block
Network and model pricing changes over time. DN-AOCA therefore stores each cost component separately and uses timestamped observations instead of freezing one “average transaction cost” into the methodology.
The Signal: Gas Is Only One Layer
Most blockchain cost comparisons start at the transaction receipt. That is too late for agentic finance.
An autonomous agent has already incurred costs before the transaction reaches the mempool:
- model inference to decide what to do;
- market-data, RPC or indexer reads to construct the action;
- wallet or secure-signing infrastructure;
- simulation and policy checks;
- and sometimes a bundler, relayer or paymaster.
After submission, the agent can still pay protocol fees, slippage, bridge fees and the cost of failed attempts.
The DN Agent Action Cost Stack
1. Intelligence Cost
Model input tokens, output/reasoning tokens and any paid tool calls required to decide the action.
2. Observation Cost
RPC, indexing, price feeds, simulation, search or proprietary API calls used to understand current state.
3. Authorization Cost
Wallet infrastructure, secure enclaves, signers, policy engines, key-management services or approval workflows.
4. Network Execution Cost
Gas, priority fees, L1 data charges, compute fees or other chain-native execution costs.
5. Coordination Cost
Bundlers, relayers, paymasters, gas sponsorship infrastructure or execution routers.
6. Economic Execution Cost
Protocol fees, swap fees, slippage, price impact, bridge fees and other value-transfer friction.
7. Setup Amortization
Token approvals, account creation, smart-account deployment or other one-time costs spread across future actions.
8. Failure & Retry Tax
Gas and infrastructure spent on failed transactions, stale quotes, reverted swaps or repeated agent decisions.
DN Cost per Successful On-Chain Action
This is the headline metric. It is deliberately chain-agnostic and model-agnostic.
DN Failure-Adjusted Cost
Some chains still charge fees when a transaction fails. Solana's official fee documentation explicitly states that base and priority fees are charged whether the transaction succeeds or fails.
If the probability of failure on each attempt is p, the expected number of failed attempts before one success is:
DN therefore models:
A system with cheap transactions but a high stale-quote or revert rate can be more expensive per success than a slightly more expensive but reliable execution stack.
DN Autonomous Overhead Ratio
This tells us how much extra infrastructure the agent requires relative to the action itself.
For a low-value payment or transfer, the AI layer can dominate total cost. For a large trade, slippage and protocol fees usually dominate instead.
AI Inference Can Cost More Than the Transaction
At the time of verification, OpenAI's GPT-5.6 Sol API lists text pricing of $4 per million input tokens and $20 per million output tokens.
A simple illustrative agent turn using 2,000 input tokens and 500 output tokens therefore costs:
That is an inference-only example. It excludes tools, network execution and retries.
On a very low-cost chain, the model decision itself can therefore cost many times the blockchain fee. This is not an argument against agents. It is an argument for measuring the right denominator.
OpenAI — GPT-5.6 Sol model pricing
Ethereum: Compute Complexity Still Matters
Ethereum charges according to gas consumed multiplied by the effective gas price. The official Ethereum documentation gives examples of approximately:
| Action | Illustrative gas units from Ethereum.org |
|---|---|
| Send ETH | 21,000 |
| Send ERC-20 | 65,000 |
| Transfer NFT | 84,904 |
| Uniswap swap example | 184,523 |
The same model inference can therefore lead to very different network costs depending on the transaction the agent constructs.
Arbitrum: One Transaction, Two Fee Dimensions
Arbitrum transactions contain both an L2 execution component and a parent-chain data component. The latter reimburses the cost of posting compressed transaction data to Ethereum.
That means an agent's cost model should not treat “L2 gas” as a single fixed number. Calldata size can change the parent-chain portion even when EVM execution is similar.
Arbitrum — Gas and fee structure
Solana: Tiny Base Fee, But Setup and Failure Still Matter
Solana currently charges a base fee of 5,000 lamports per signature, plus any optional prioritization fee. The priority fee is based on the requested compute-unit limit rather than actual compute used for legacy and v0 transactions.
Solana also charges fees on failed transactions, and some actions require account creation or rent-exempt deposits.
This creates a classic agentic-cost trap: the headline transfer fee can be tiny while token-account creation, priority fees, API infrastructure or repeated failures dominate the end-to-end action cost.
Gas Sponsorship Does Not Make Cost Disappear
Coinbase CDP Smart Accounts support gas sponsorship, batching and spend permissions across Base, Ethereum, Arbitrum, Optimism, Polygon, BNB, Avalanche and Zora.
For the end user, sponsored gas can make an action feel gasless. Economically, however, the cost has moved to the sponsor, application or paymaster.
DN therefore tracks both.
DN Sponsored Cost Transfer
A product can advertise “free transactions” while still operating an expensive agent infrastructure behind the scenes. That distinction matters for business models, unit economics and autonomous-agent budgets.
Batching Can Change the Unit Economics
Smart accounts can batch multiple operations into one user operation or transaction. If an agent regularly needs an approval followed by a swap, batching can reduce signing overhead, latency and sometimes fixed network cost.
But batching can also create larger calldata, more computation or a larger failure domain.
The correct metric is not “number of transactions.” It is:
Approval Amortization
An ERC-20 approval or smart-account deployment can be a one-time setup cost that enables hundreds of later actions.
If a $2 setup cost supports 1,000 later actions, its amortized cost is $0.002 per action. If the user performs only one action, the full $2 belongs in that action's economics.
Protocol Fees and Slippage Dominate Large Trades
For a $10 payment, a few cents of inference or RPC cost can be material.
For a $100,000 swap, a 10-basis-point execution loss equals $100. In that scenario, optimizing model tokens while ignoring routing quality is economically irrational.
DN Agent Action Cost Calculator
AI Agent Cost per On-Chain Action Calculator
Model the full cost of one successful autonomous action, including AI inference, RPC/data, signing, network gas, protocol friction, amortized setup, sponsorship and expected retries.
Action Value
AI Inference
Infrastructure
Protocol & Execution
Setup & Failure
DN Cost Analysis
The relevant benchmark is the cost of a successful state change, not the cheapest individual transaction.
How the Calculator Works
Three Actions Can Have Completely Different Cost Drivers
| Agent action | Likely dominant cost | What naive gas-only analysis misses |
|---|---|---|
| Send a $5 stablecoin payment | AI + infrastructure fixed cost | Inference and RPC can exceed network fee. |
| Swap $100,000 of crypto | Slippage + protocol execution | Optimizing pennies of gas while losing 10 bps is false economy. |
| Bridge and deploy collateral | Cross-chain + setup + failure risk | Approval, bridge, retries and destination-chain execution all matter. |
DN Cost Attribution Classes
Each observed dollar should be labeled by who caused and who paid it.
| Class | Examples | Payer |
|---|---|---|
| AGENT_COMPUTE | LLM tokens, tool calls | Developer / application |
| DATA | RPC, indexer, market feed | Developer / application |
| AUTH | Wallet, signer, enclave, policy engine | Developer / user |
| NETWORK | Gas, priority fee, L1 data fee | User / sponsor |
| COORDINATION | Bundler, relayer, paymaster | User / sponsor / app |
| PROTOCOL | Swap fee, bridge fee | User |
| MARKET_IMPACT | Slippage, price impact | User |
| FAILURE | Reverts, stale quotes, retries | User / app / sponsor |
Why This Is Different From DN's x402 Cost Benchmark
DN's x402 Cost & Reliability Benchmark measures the payment rail itself.
DN-AOCA asks the broader question:
How much did the entire autonomous workflow cost to successfully change on-chain state?
An x402 payment can therefore be one action inside the larger cost stack, not the whole benchmark.
Permission Controls Can Increase Cost—and Still Be Worth It
The previous DN priority article, the AI Agent Transaction Permission Risk Index, showed why narrower authority reduces blast radius.
Some controls add simulation, policy evaluation, additional signatures or quorum approval. Those can increase latency or infrastructure cost.
That does not make them inefficient. The correct economic question is:
DN-AOCA v1.0 does not attempt to assign a dollar value to security loss, but future versions should connect both indexes.
DN Break-Even Action Value
Fixed agent costs are easiest to justify on larger-value actions.
If the agent costs $0.05 to operate and is expected to improve execution by 5 bps, it needs roughly $100 of action value before the expected benefit covers the fixed cost:
DN Cost-per-Action Dataset
observation_id timestamp_utc agent model model_input_tokens model_output_tokens model_cost_usd tool_call_cost_usd rpc_provider rpc_cost_usd wallet_provider signer_cost_usd chain action_type network_fee_usd l1_data_fee_usd priority_fee_usd bundler_fee_usd paymaster_cost_usd sponsor_paid_usd protocol_fixed_fee_usd protocol_fee_bps slippage_bps transaction_value_usd setup_cost_usd setup_expected_reuses failed_attempts failed_attempt_cost_usd time_to_finality_ms system_cost_per_success_usd user_cost_per_success_usd cost_bps methodology_version
The Future DN Leaderboard
DN should eventually benchmark identical agent actions across chains and stacks—for example, “decide and send $10 USDC,” “approve and swap $1,000,” and “bridge $1,000 and deposit into a lending market.”
| Stack | AI Cost | Infra Cost | Network Cost | Failure Tax | Total / Success | User-Paid |
|---|---|---|---|---|---|---|
| Ethereum + EOA | Pending synchronized run | Pending | Pending | Pending | Pending | Pending |
| Arbitrum + Smart Account | Pending synchronized run | Pending | Pending | Pending | Pending | Pending |
| Base + Sponsored Smart Account | Pending synchronized run | Pending | Pending | Pending | Pending | Pending |
| Solana + Native Wallet | Pending synchronized run | Pending | Pending | Pending | Pending | Pending |
Falsification Test
The DN thesis becomes less useful if repeated observations show that AI, RPC, signer, bundler and retry costs are consistently negligible relative to network fees and protocol execution across most real agent workflows.
It also weakens if gas sponsorship reliably removes cost without simply transferring it to another payer.
If that happens, gas-only benchmarking would be sufficient. DN should publish that result.
Frequently Asked Questions
What is AI agent cost per on-chain action?
It is the total cost required for an autonomous agent to decide, authorize, submit and successfully complete an intended on-chain state change.
Why not just measure gas?
Gas excludes model inference, RPC/data calls, signing infrastructure, bundlers, protocol fees, slippage, setup costs and failed retries.
Can model inference cost more than the blockchain fee?
Yes. On low-cost chains and small-value actions, the model and software stack can cost more than the network transaction itself.
Does a gasless transaction have zero cost?
No. Gas sponsorship changes who pays. The application, paymaster or sponsor still bears the network cost.
Why include slippage in an agent-cost benchmark?
Because slippage is an economic cost caused by execution. For large trades it can exceed every software and network fee combined.
Why include failed transactions?
Because a production agent must succeed. Measuring only successful receipts hides the cost of stale quotes, reverts and retries.
DN Alpha Thesis
The economics of the machine economy will be determined by more than cheap blockspace.
Agents will choose models, data providers, wallet systems, chains, paymasters and execution venues dynamically. The winning stack will minimize cost per successful useful state change, not any single fee component.
Final Verdict
The network transaction is only the visible tail of an agentic workflow.
A serious benchmark must include:
Model CostRPC/DataSigningGasBundler/PaymasterProtocol FeesSlippageSetupRetry Tax
The cheapest blockchain is not automatically the cheapest agent stack. The correct unit of analysis is the successful autonomous action.
Continue the DN Agentic Finance Research Stack
AI Agent Transaction Permission Risk Index x402 Cost & Reliability Benchmark Agentic Treasury BenchmarkPrimary Source Ledger
- Ethereum.org — Gas and fees: gas formula and illustrative gas usage by action type.
- Solana — Fee Structure: 5,000 lamports/signature, optional priority fee and charging on failed transactions.
- Arbitrum — Gas structure: L1 data plus L2 execution components.
- Arbitrum Nitro: L2 gas and L1 data fee mechanics.
- Coinbase CDP — Smart Accounts: gas sponsorship, batching and spend permissions.
- Privy — Wallet policies and controls: policy enforcement and programmable wallet controls.
- OpenAI — GPT-5.6 Sol API pricing: current token pricing used for the illustrative inference-cost example.
Change Log
| Date | Version | Change |
|---|---|---|
| 29 Oct 2026 | DN-AOCA v1.0 | Initial full-stack cost methodology, failure-adjusted cost model, sponsorship accounting, calculator, dataset schema and future synchronized leaderboard design. |
Risk & methodology disclosure: Costs change continuously. The calculator is a modelling tool, not a guarantee of future execution cost or profitability. Model pricing, network fees, provider pricing, sponsorship policies, protocol charges and token prices can all change. Educational content only; not financial, tax, legal or investment advice.
