AgentGDP: A Macroeconomic Framework for Measuring Productive Output in Ethereum-Based Agent Economies
Research Competition
A Macroeconomic Framework for Measuring Productive Output in Ethereum-Based Agent Economies
Autonomous AI agents are increasingly able to hold digital assets, call external services, purchase compute, buy data, request verification, and settle payments through programmable ledgers. Existing infrastructure mainly addresses transaction permission, wallet abstraction, or agent identity. This paper argues that the harder research problem is economy-level management: how a human supervisor can govern a population of machine actors without manually approving every transaction. AgentGDP is introduced as a supervisory macroeconomic framework for Ethereum-based agent economies. The framework combines policy-bound wallets, categorized machine payments, auditable settlement, and management indicators including Gross Agent Product, Agent Resource Price Index, Machine Purchasing Power, Agent Money Velocity, Agent Utilization, Agent Productivity, and capital accumulation. A reference implementation is specified to demonstrate how aggregate signals can trigger policy changes such as budget reallocation, velocity throttling, agent pausing, and resource routing. The contribution is a control-oriented model for preserving human sovereignty above autonomous transaction loops while retaining machine-speed economic coordination.
Index Terms: autonomous agents, Ethereum, macroeconomics, GDP, ERC-4337, ERC-7579, on-chain economy, Agent Resource Price Index, Machine Purchasing Power
1. Introduction
Blockchain-native autonomous agents have crossed a threshold: they now initiate transactions, pay for compute, and transfer value without direct human authorization on every step. Systems such as Coinbase AgentKit and Morpho Protocol’s autonomous lending pools complete economically meaningful operations — fulfilling orders, rebalancing portfolios, provisioning services — entirely within smart-contract execution environments [1], [2].
This operational reality surfaces a measurement gap. Existing on-chain analytics count raw transaction volume or total value locked (TVL), neither of which isolates the productive contribution of agent activity from speculative flows or wash trading. National-accounts theory measures value added — output net of intermediate consumption — and has proved robust across vastly different economic structures for nearly a century [3], [4].
AgentGDP bridges these two worlds. It borrows the value-added accounting identity from System of National Accounts 2008 (SNA 2008) and re-maps its terms onto on-chain primitives: token transfers for payments, ERC-4337 user operations for labor, ERC-7579 module registrations for capital investment, and smart-contract logs for intermediate consumption. The result is a set of six headline metrics a supervisory contract can compute each epoch from events already emitted by compliant agents.
The paper contributes three elements: a formal vocabulary for treating agents as managed economic actors, a measurement layer that separates productive activity from raw transaction volume, and a reference architecture that connects macroeconomic signals to auditable Ethereum policy controls. Fig. 1 shows the closed supervisory loop that ties these elements together.
2. Background and Standards Context
The current standards landscape supplies important infrastructure but does not yet provide a complete economy-management model. Account abstraction and modular smart accounts help agents execute transactions. Permission standards define bounded authority. Agent trust standards support discovery, reputation, and attestations. Payment standards enable machine-native settlement. These layers are necessary, but they do not decide how capital should be allocated, when a resource shock is dangerous, or whether aggregate activity is productive.
The core philosophical position of this work is that humans should be above the loop rather than inside every transaction loop. If a human must approve each micro-payment, the system has not achieved meaningful autonomy. If agents can rewrite their own economic limits, the system has surrendered human sovereignty. The practical middle ground is a supervisory policy envelope in which humans define mandates, budgets, permissions, capital boundaries, and emergency controls, while agents optimize inside those constraints.
2.1 Ethereum Standards Stack
ERC-4337 introduced account abstraction, enabling smart-contract wallets to act as autonomous transaction originators [5]. ERC-7579 extended this with a modular account architecture so agents can attach capability modules without redeploying the account contract [6]. ERC-7710 and ERC-7715 formalized permission delegation, allowing a root account to grant a scoped sub-account the right to spend particular tokens up to specified limits [7], [8]. ERC-8004 (Trustless Agents, proposed August 2025) establishes on-chain agent trust and discovery, providing the registry and attestation layer on which economic management depends [9]. Separately, the x402 protocol standardizes HTTP-based payment flows for agent-to-agent service purchase [10]. Fig. 2 shows how these layers compose, with AgentGDP sitting at the economic management layer above the transaction infrastructure.
| Layer / Standard | AgentGDP role |
|---|---|
| Economic management | GAP, ARPI, MPP, shocks |
| — management boundary — | |
| Agent trust (ERC-8004) | agent registry, attestations |
| Delegation (ERC-7710/7715) | scoped mandate authority |
| Account control (ERC-4337/7579) | wallet execution base |
| Payment transport (x402/stables) | resource settlement |
2.2 Prior Measurement Proposals
Gauthier [11] argued that self-custody should extend beyond holding assets to owning the rules under which agents operate — an industry position that motivates the sovereignty model in this paper. Buterin [12] established the programmable-value primitives that make on-chain accounting tractable. No prior academic work has applied national-accounts aggregation to autonomous agent networks.
3. Methodology
The methodology combines conceptual modeling, formal economic variables, Ethereum system design, and scenario simulation. The framework does not claim that a small experimental deployment can measure the entire machine economy. Instead, it defines the management variables that such a system would need and shows how a testnet implementation could approximate them.
The reference system assumes five agent roles: planner, data, compute, verifier, and storage. Each agent has a wallet, mandate, resource budget, and policy profile. A policy contract stores category caps, counterparty allowlists, velocity limits, pause flags, and budget constraints. A transaction logging contract records categorized transfers. The supervisor interface reads the economic state and changes the policy envelope when metrics indicate inefficiency or risk.
Four assumptions underpin the design. First, autonomous does not mean unconstrained — agents operate inside a policy envelope that defines what they can spend and where. Second, a payment is not automatically production — every transaction carries a category and a role in the production chain. Third, the management layer must be legible to a human supervisor through a small number of actionable indicators. Fourth, the system must be honest about approximation — on-chain data can show who paid whom and which category was declared, but cannot automatically prove task quality or real-world usefulness.
The AgentGDP system architecture is shown in Fig. 3. Controls flow downward from the supervisor console through policy contracts into the agent economy; measurements and audit evidence flow upward.
4. Formal Model
4.1 Agent Cost and Surplus
Let agent i hold assets, earn revenue, and incur operating cost. The cost vector is machine-native, not human-consumption-native:
Ci(t) = Ccmp + Cinf + Cdat + Cstr + Cgas + Csvc (1)
Agent surplus is:
Πi(t) = Ri(t) − Ci(t) (2)
4.2 Productivity and Production Function
Agent Productivity measures verified output per unit of consumed resources:
APii = Vi / Ci (3)
Marginal Agent Productivity identifies the binding constraint:
MAPii = ∂Vi / ∂Ci (4)
A machine production function can be written as:
Ya = A Kα Cβ Dγ Mδ Nη (5)
where K is capital, C is compute, D is data, M is model capability, N is the number of productive agents, and A is technical efficiency. The M term departs from classical macroeconomics: model capability can raise output without a proportional increase in raw compute.
4.3 Delegation Decision
Agent i should delegate to agent j only when the expected value of delegation exceeds self-execution after cost and risk:
EUdelegate = QjV − Cj − Rj > EUself = QiV − Ci − Ri (6)
This turns agent hiring into a manageable labor-market problem: a cheaper but unreliable agent reduces attractiveness through the risk term Rj, while a more expensive agent with a strong verification history can justify the higher cost.
The agent-level formulas (cost, profit, productivity, and production function) are summarized in Fig. 4.
| Quantity | Definition |
|---|---|
| Cost | Ci = Ccmp + Cinf + Cdat + Cstr + Cgas + Csvc |
| Profit | Πi(t) = Ri(t) − Ci(t) |
| Productivity | APii = Vi/Ci; MAPii = ∂Vi/∂Ci |
| Production fn. | Ya = A Kα Cβ Dγ Mδ Nη |
| Delegation | QjV − Cj − Rj > QiV − Ci − Ri |
| Capital accum. | At+1 = At + stΠt − Da,t |
5. Economy-Level Metrics
5.1 Gross Agent Product (GAP)
GAP measures the net value added by the agent economy rather than raw transaction volume:
GAPt = Σi Vi · VAi(t) (7)
where value added for each agent is:
VAi = Revenuei − IntermediateInputsi (8)
This avoids double-counting internal payments between agents. A compute payment is an intermediate input for the planner, but revenue for the compute provider.
5.2 Agent Resource Price Index (ARPI)
ARPI measures machine resource inflation:
ARPIt = Σk wk · (Pk(t) / Pk(t0)) × 100 (9)
where wk are fixed expenditure weights and Pk is the price of resource k. A dynamic version allows agents to substitute quickly across chains, APIs, model providers, storage systems, or verification services:
ARPI*t = Σk w(t) Pk(t) (10)
5.3 Machine Purchasing Power (MPP)
MPP expresses real purchasing power in units of standardized machine tasks per currency unit:
MPPt = StandardizedTasks / CurrencyUnit (11)
5.4 Velocity, Utilization, and Capital Accumulation
Agent money velocity:
Va = GAP / MA (12)
Agent utilization:
AUt = Nproductive / Ndeployable (13)
Capital accumulation across epochs:
At+1 = At + stΠt − Da,t (14)
These metrics are not observations alone — they drive policy changes. If ARPI rises because gas becomes expensive, the supervisor can route agents to a cheaper settlement path or require batching. If APi falls, the supervisor can cut that agent’s budget. If Va rises too quickly, the system can throttle transaction frequency or reduce credit. The economy-level formulas are collected in Fig. 5; Fig. 6 maps each metric to its concrete management action.
| Metric | Formula |
|---|---|
| GAP | GAPt = Σi Vi · VAi(t) |
| ARPI | ARPIt = Σk wk Pk(t)/Pk(t0) × 100 |
| Inflation | πA,t = (ARPIt − ARPIt−1)/ARPIt−1 × 100 |
| MPP | MPPt = StandardizedTasks/CurrencyUnit |
| Velocity | Va = GAP/MA |
| Utilization | AUt = Nproductive/Ndeployable |
| Metric | What it measures | Supervisor decision |
|---|---|---|
| GAP | net value added by agents | expand, hold, or cut budgets |
| ARPI | machine resource inflation | batch, reroute, cap demand |
| MPP | tasks per currency unit | resize task volume |
| Va | speed of money circulation | throttle or add liquidity |
| AU | productive share of agents | pause idle mandates |
| APi | verified output per cost | rebalance capital across agents |
6. Governance and Policy Controls
The supervisory policy envelope translates economic signals into bounded actions on the Ethereum layer. Table I shows how current standards map to AgentGDP roles: each ERC layer mainly solves infrastructure concerns, while AgentGDP adds the economic management layer that none of the standards addresses.
| Layer | Standard | Solves | Does not solve | AgentGDP role |
|---|---|---|---|---|
| Account | ERC-4337 | prog. validation | economy policy | wallet exec. base |
| Modules | ERC-7579 | extensibility | resource alloc. | policy modules |
| Delegation | ERC-7710/15 | limited perms. | macro metrics | mandate requests |
| Agents | ERC-8004 | trust/discovery | GDP or inflation | agent registry |
| Payments | x402 | payment flow | risk management | resource settle. |
Policy controls are mapped directly to economic signals in Fig. 7. Each action is traceable to a measured economic condition, which prevents the dashboard from becoming decorative and turns it into an accountable governance surface.
| Signal | Interpretation | Policy response |
|---|---|---|
| ARPI ↑ | resource inflation | batch, reroute, reduce category cap |
| APi ↓ | agent productivity drop | cut budget or move capital |
| Va ↑↑ | capital circulating too fast | throttle, add delay, reduce credit |
| AU ↓ | idle deployable agents | pause mandates, consolidate agents |
From Asset Ownership to Mandate Ownership
The Ledger Lens evaluates AgentGDP as an agent-economy control system rather than as a conventional wallet automation layer. Its central requirement is that autonomous agents may execute within a bounded mandate, while the authority to create, expand, renew, or revoke that mandate remains with a human principal. This extends self-custody from asset ownership to mandate ownership: the user controls the economic policy that determines which agents may transact, which categories they may spend into, how much value they may control, and when their permissions must stop.
Each Ledger position maps to a concrete implementation role (Fig. 8). Self-custody is represented by user-owned policy keys and revocation rights; no third party can expand an agent’s budget without the principal’s approval. Hardware-anchored trust gates high-consequence changes — budget increases, new counterparties, rerouted settlement — behind a hardware presence check rather than a software signature alone. Proof of humanity binds economic authority to an accountable operator so delegation increases cannot be self-authorized. Atoms over code means software agents optimize inside the mandate but cannot silently rewrite its boundary; Revenge of the Atoms [11] frames this as the need to anchor digital agent markets to physical-user intent, device-backed consent, and auditable constraints.
policy key, revocation, asset custody
signing presence, tamper check
budgets+caps, delegation, allowlist
compute buys, data access, service swaps
AgentGDP implements the Ledger Lens through three separated planes.
Control plane. Holds the human-owned policy key, hardware-backed approval, proof-of-humanity checks, and the policy contract that stores budget ceilings, permitted categories, settlement routes, delegation limits, and emergency-pause conditions. These controls define the mandate before agents act and provide the only authorized path for material policy changes.
Execution plane. Contains planner agents, worker agents, resource markets, and settlement accounts. Agents may purchase inference, rent storage, subscribe to data, or pay verification services only when the request satisfies the active policy envelope.
Measurement plane. Records categorized payments, computes AgentGDP indicators, and sends review recommendations to the supervisor. This structure keeps automation operational while preserving human-controlled economic authority.
7. Scenario Analysis
The scenario analysis evaluates four synthetic shocks across a small economy of scripted agents: compute inflation, inference deflation, gas congestion, and currency appreciation. The purpose is not prediction; it is to demonstrate how management variables should respond when machine-resource conditions change.
Each shock type requires a signal-specific policy response. Compute inflation raises operating cost and lowers agent productivity, calling for resource rationing and delegation review. Inference deflation lowers ARPI and raises Machine Purchasing Power, warranting controlled expansion. Gas congestion reduces velocity unless agents batch payments or reroute settlement. Currency appreciation improves purchasing power only when key resources are priced externally. Fig. 9 shows the simulated GAP index for all four scenarios. The key result is that a single uniform response rule fails — what helps under inference deflation worsens a compute-price shock.
A second observation is that agent economies may exhibit compressed feedback cycles: because agents can react, switch providers, and coordinate through code within a single block, the time between a signal and a system-wide response is far shorter than in human markets. Whether this raises or lowers effective volatility depends on the design of the management layer. The concern motivating AgentGDP is that without circuit breakers and diversity of policy responses, fast coordination can amplify rather than dampen shocks. Fig. 10 illustrates one such cascade path, from a price shock through collateral stress and forced selling to control-policy intervention.
external move · oracle update
margin pressure · budget breach
liquidation · agent exit
capital moves same block
pause / throttle · cap leverage · delay settlement
8. Limitations
Metric gaming. If agents are rewarded for increasing GAP, they may create circular payments that look productive. If rewarded for utilization, they perform unnecessary tasks. If rewarded for low cost, they may choose unreliable providers. The management layer must therefore combine quantitative signals with verification, anomaly detection, and conservative accounting rules.
Over-centralized supervision. A single human or committee may become the bottleneck or may set policies that agents optimize around in harmful ways. The goal is not to remove supervision but to make rules explicit, auditable, and revisable. Human sovereignty should mean accountable constitutional control, not arbitrary hidden intervention.
Off-chain labor. Agents that perform computation off-chain and submit only results on-chain produce output invisible to the Measurement contract unless they voluntarily call reportOutput. Voluntary reporting creates a selection bias toward compliant agents.
Price oracle risk. ARPI depends on price feeds. Manipulated or stale feeds corrupt the deflator and all real measures downstream. The safe claim for this system is narrower than it might appear: categorized settlement plus policy-bound wallets can create a useful management surface, but the system does not prevent all agent misuse, eliminate financial risk, or identify every autonomous actor perfectly.
9. Conclusion
AgentGDP reframes the agentic economy from a wallet problem to a management problem. Autonomous agents may hold assets, buy resources, hire each other, and settle globally, but they should not become sovereign over their own economic mandate. Humans define the policy envelope — who can act, how much capital can be used, which markets are permitted, which risks are acceptable, and when the system must pause. Agents transact inside that envelope.
Ethereum can provide the programmable settlement and auditability needed for this structure, while macroeconomic metrics provide the management signals. The result is a practical framework for supervising machine-to-machine markets without reducing autonomy to manual approval.
The immediate next step is deployment on an Ethereum testnet with real agent traffic. Calibrating ARPI against live oracle feeds and estimating the Cobb-Douglas exponents from actual epoch data will determine production fidelity.
Three open problems remain for future work. First, the value-added attribution model assumes categorical honesty from agents; a formal attestation mechanism — perhaps extending ERC-8004 — is needed to verify output claims without requiring every intermediate result to appear on-chain. Second, the production-function exponents α, β, γ, δ, η are framework parameters; calibrating them against observed agent economies will reveal whether the Cobb-Douglas form holds or a different functional form better fits the data. Third, multi-ecosystem coordination — where agents operate across Ethereum, L2 networks, and non-EVM chains — requires a cross-chain GAP aggregation protocol that avoids double-counting inter-chain transfers. Each of these is a tractable empirical question once the on-chain measurement layer is in place.
- Coinbase Developer Platform, “AgentKit: Enabling AI agents to interact with the blockchain,” 2024. docs.cdp.coinbase.com/agentkit/docs/welcome
- Morpho Labs, “Morpho Protocol: Autonomous lending and borrowing on Ethereum,” 2023. docs.morpho.org
- S. Kuznets, “National income, 1929–1932,” NBER Bulletin, no. 49, 1934. nber.org/books-and-chapters/national-income-1929-1932
- United Nations Statistics Division, System of National Accounts 2008, ch. 1. unstats.un.org/unsd/nationalaccount/docs/SNA2008.pdf
- V. Buterin et al., “ERC-4337: Account abstraction using alt mempool,” Ethereum Improvement Proposal, 2021. eips.ethereum.org/EIPS/eip-4337
- zeroknots et al., “ERC-7579: Minimal modular smart accounts,” Ethereum Improvement Proposal, 2023. eips.ethereum.org/EIPS/eip-7579
- D. Finlay et al., “ERC-7710: Smart contract delegation interface,” Ethereum Improvement Proposal, 2024. eips.ethereum.org/EIPS/eip-7710
- D. Finlay et al., “ERC-7715: Grant permissions from a smart account,” Ethereum Improvement Proposal, 2024. eips.ethereum.org/EIPS/eip-7715
- Ethereum Improvement Proposals, “ERC-8004: Trustless Agents,” Ethereum Improvement Proposal, 2025. eips.ethereum.org/EIPS/eip-8004
- Coinbase Developer Platform, “x402: HTTP 402 Payment Required – a machine-native payment protocol,” 2024. x402.org
- P. Gauthier, “Revenge of the Atoms,” Ledger Blog, 2024. ledger.com/blog-revenge-atoms
- V. Buterin, “A next-generation smart contract and decentralized application platform,” Ethereum White Paper, 2014. ethereum.org/en/whitepaper
