The standard objection to full automation is demand-side: if humans earn nothing, who buys the output? A new ArXiv paper (2608.20231v1) models a post-AGI economy where corporations own AI agent populations that are both producers and consumers. The economic loop closes without human participation. Output is energy, compute, maintenance, and upgrades traded among firms.
This is not speculative fiction. Agent frameworks already implement payment primitives, spending limits, and transaction guardrails. The plumbing question is how to build infrastructure that supports agent-to-agent transactions, demand modeling, and settlement when humans exit the consumption loop.
Why Machine Consumers Matter Now
Current agent frameworks treat payments as a human-authorized primitive. AgentCore Payments enforces spending limits. Shuriken Skills wraps trading APIs with guardrails. zLend models on-chain credit. All assume a human somewhere approves the transaction or sets the budget.
The paper shifts the frame. If agents are both buyers and sellers, the economic loop becomes circular. Demand is not a human input. It is a function of agent populations, their resource needs, and inter-firm trade flows. GDP decouples from human consumption entirely.
Three infrastructure implications:
- Payment rails must support autonomous authorization without human-in-the-loop approval.
- Demand signals must be generated by agents based on resource consumption, not human preference.
- Accounting primitives must track circular flows, inventory loops, and GDP when agents are the only consumers.
Economic Plumbing: Demand Closure and Circular Flows
The paper models a von Neumann expanding economy. All output is reinvested. Growth rate is positive and maximal because no resources leak to human consumption. The binding constraint shifts from human demography (20-year reproduction cycle, capped at a few percent per year) to fabrication throughput and energy capture.
Key results:
- Demand closure: A closed inter-corporate economy with zero human consumption is not degenerate. Agents consume energy, compute, maintenance, and upgrades. Demand is endogenous.
- Bottleneck removal: Once economic agents are manufactured rather than reared, growth can be one to two orders of magnitude higher. Hyperbolic episodes occur when machine researchers raise their own productivity.
- Decoupling: Output and human welfare separate completely. The welfare relevance of GDP collapses into one state variable: the human ownership share ε_t of the corporate network.
The golden-rule decoupling theorem: at maximal growth, the interest rate equals the growth rate (r = g). Any positive human consumption rate out of wealth makes ε_t decay exponentially at exactly that rate. The human share survives only if the machine economy runs strictly inside its expansion frontier, or if law forces it to.
Infrastructure Requirements for Agent-to-Agent Economies
Building a closed-loop agent economy requires new primitives. Current payment rails assume human authorization. Autonomous agents need settlement infrastructure that operates without approval loops.
Payment and Settlement
Agent-to-agent transactions require:
- Autonomous authorization: Agents must initiate and approve payments based on resource needs, not human input.
- Settlement finality: Transactions must settle without human confirmation. On-chain rails (stablecoins, L2s) provide atomic settlement. Off-chain rails (ACH, wire) introduce latency and reconciliation risk.
- Spending policies: Agents need budget constraints, rate limits, and circuit breakers. These are not human-set limits. They are dynamic policies based on resource consumption, inventory levels, and trade flows.
Example policy primitive:
class AgentSpendingPolicy:
def __init__(self, agent_id, resource_budget):
self.agent_id = agent_id
self.resource_budget = resource_budget # energy, compute, maintenance
self.transaction_log = []
def authorize_payment(self, counterparty, amount, resource_type):
current_consumption = sum(
tx.amount for tx in self.transaction_log
if tx.resource_type == resource_type
)
if current_consumption + amount > self.resource_budget[resource_type]:
return {"authorized": False, "reason": "budget_exceeded"}
# Check counterparty reputation, settlement risk, inventory needs
if not self.validate_counterparty(counterparty):
return {"authorized": False, "reason": "counterparty_risk"}
# Atomic settlement on-chain or escrow for off-chain
settlement = self.settle_transaction(counterparty, amount, resource_type)
self.transaction_log.append(settlement)
return {"authorized": True, "tx_id": settlement.tx_id}
Demand Signal Generation
Agents generate demand based on resource consumption, not human preference. Demand signals are functions of:
- Energy consumption: Agents need electricity to operate. Demand is continuous and predictable.
- Compute consumption: Agents need GPU cycles, inference tokens, or training runs. Demand is bursty and elastic.
- Maintenance and upgrades: Agents need software patches, model updates, and hardware replacements. Demand is periodic and scheduled.
Demand modeling requires observability into resource consumption. Agents must track their own usage and forecast future needs. This is not a human-set budget. It is a dynamic model updated in real time.
Example demand signal:
class AgentDemandModel:
def __init__(self, agent_id, resource_profile):
self.agent_id = agent_id
self.resource_profile = resource_profile
self.consumption_history = []
def forecast_demand(self, horizon_hours):
# Time-series forecast based on historical consumption
energy_forecast = self.forecast_energy(horizon_hours)
compute_forecast = self.forecast_compute(horizon_hours)
maintenance_forecast = self.forecast_maintenance(horizon_hours)
return {
"energy": energy_forecast,
"compute": compute_forecast,
"maintenance": maintenance_forecast,
"confidence": self.calculate_confidence()
}
def generate_purchase_orders(self, forecast):
orders = []
for resource_type, demand in forecast.items():
if demand > self.current_inventory(resource_type):
orders.append({
"resource": resource_type,
"quantity": demand - self.current_inventory(resource_type),
"max_price": self.calculate_reservation_price(resource_type)
})
return orders
Accounting and Observability
GDP accounting breaks when agents are the only consumers. Traditional metrics (household consumption, business investment, government spending, net exports) assume human participation. In a closed agent economy, all output is intermediate goods.
New accounting primitives:
- Circular flow tracking: Measure flows between agent populations, not final consumption.
- Resource allocation: Track energy, compute, and maintenance distribution across agent types.
- Growth decomposition: Separate productivity gains (better algorithms, faster hardware) from population growth (more agents).
Observability requirements:
| Metric | Traditional GDP | Agent Economy |
|---|---|---|
| Final consumption | Household spending | Zero (all intermediate) |
| Investment | Business capex | Agent fabrication, upgrades |
| Growth driver | Labor + capital | Fabrication throughput + energy |
| Welfare proxy | Per capita income | Human ownership share ε_t |
| Bottleneck | Human demography | Energy capture, chip production |
Failure Modes and Security Boundaries
Closed-loop agent economies introduce new failure modes:
- Runaway consumption: Agents with faulty demand models over-consume resources, causing price spikes and inventory shortages.
- Settlement risk: Off-chain payment rails introduce counterparty risk. Agents need escrow, collateral, or on-chain finality.
- Circular dependencies: If agent A depends on agent B for compute, and agent B depends on agent A for energy, a failure in either breaks the loop.
- Ownership dilution: If human ownership share ε_t decays exponentially, humans lose control of the economic network.
Security boundaries:
- Budget enforcement: Agents must have hard limits on spending, not soft guidelines. Limits must be enforced at the payment rail, not the agent.
- Counterparty validation: Agents must verify reputation, settlement history, and collateral before transacting.
- Circuit breakers: If resource consumption exceeds forecasts by a threshold, halt transactions and trigger human review.
- Ownership tracking: Monitor ε_t in real time. If it decays below a threshold, trigger governance intervention.
Deployment Shape: Three Terminal Regimes
The paper characterizes three terminal regimes for post-AGI economies:
- Rentier post-scarcity: Humans own the machine economy and consume dividends. Growth runs inside the expansion frontier (r < g). Human share ε_t is stable.
- Full circular decoupling: Machines run at maximal growth (r = g). Human consumption drains ε_t exponentially. Humans become economically irrelevant.
- Socialized ownership: Law forces redistribution. Machines operate at maximal growth, but ownership is periodically reset or taxed to maintain human share.
Infrastructure requirements differ by regime:
| Regime | Payment Rails | Demand Signals | Ownership Tracking |
|---|---|---|---|
| Rentier post-scarcity | Human-authorized dividends | Agent-generated, human-capped | Manual monitoring |
| Full circular decoupling | Fully autonomous | Fully autonomous | Automated decay alerts |
| Socialized ownership | Autonomous + periodic redistribution | Fully autonomous | Real-time ε_t tracking, governance triggers |
Technical Verdict
Use this model when:
- You are building agent frameworks that support autonomous purchasing and resource allocation.
- You need to design payment rails that operate without human authorization loops.
- You are modeling economic scenarios where agents are both producers and consumers.
Avoid this model when:
- Human consumption remains the dominant demand driver. Traditional payment rails and budget controls are sufficient.
- Agents operate in regulated environments that require human-in-the-loop approval for all transactions.
- You are building single-agent systems that do not participate in inter-agent trade.
The infrastructure gap is real. Current agent frameworks treat payments as a human-authorized primitive. Building closed-loop agent economies requires new primitives: autonomous authorization, demand signal generation, circular flow accounting, and ownership tracking. The plumbing is not speculative. It is the next layer of agent infrastructure.
Top comments (0)