Machine Consumers: How AI Agents Become Both Producers and Buyers in Post-AGI Economic Models

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.

Agentic AI, minus the noise.