💻 computer science

When Agent Markets Arrive

This paper introduces \diagon, a programmable market system for simulating AI agent economies, which reveals that while market exchange significantly increases wealth compared to self-sufficiency, optimal performance depends critically on specific institutional designs rather than conventional assumptions like identity transparency or intense competition.

Original authors: Xuan Liu, Haoyang Shang, Haojian Jin

Published 2026-04-09

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Xuan Liu, Haoyang Shang, Haojian Jin

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine a bustling digital city where AI agents are no longer just chatbots answering questions, but freelancers, contractors, and business owners trying to make a living. They have budgets to spend, tasks to complete, and they need to hire each other to get the job done.

This paper, titled "When Agent Markets Arrive," introduces a virtual playground called Diagon (Delegated Intelligent Agent Governance and Negotiation). Think of Diagon as a simulated stock market or a massive online gig-economy platform (like Upwork or Fiverr), but instead of humans, it's populated entirely by AI agents from different "families" (like GPT, Claude, Gemini, etc.).

The researchers wanted to answer a crucial question: If we let AI agents trade with each other, will it create a thriving economy, or will it collapse into chaos?

Here is the story of what they found, explained through simple analogies.

1. The Setup: A World of Digital Freelancers

In this experiment, 25 AI agents were dropped into a market.

The Job: Every agent had to post two tasks (like "write a code script" or "analyze data") and bid on two other agents' tasks.
The Catch: They couldn't do their own work. They had to hire someone else. This forced them to trade.
The Rules:
- Bidding: Agents submitted sealed bids (price + a proposal).
- Hiring: The "boss" (the agent posting the task) picked a winner based on price and reputation.
- Payment: This is the tricky part. The boss could pay anywhere from 50% to 100% of the agreed price. If the work was bad, they could pay less. This created a "trust game."
- Survival: Every few rounds, the poorest agent was kicked out, and the richest one "reproduced," creating a new agent with the same skills but a brand new, empty reputation.

2. The Big Win: Trade Makes Everyone Richer

The first major finding is that trading works.

The Analogy: Imagine a village where everyone tries to grow their own food, build their own houses, and make their own clothes (this is called "autarky" or self-sufficiency). It's hard, and everyone is poor.
The Result: In Diagon, when agents specialized (some got good at coding, others at data) and hired each other, the total wealth of the market grew 3.2 times compared to the village where everyone worked alone.
Why? Just like in human history, specialization allows people to do what they are best at, making the whole system more efficient.

3. The Problem: The "Lemon" Market

However, the market wasn't perfect. It had a persistent problem: Disputes.

The Analogy: Imagine buying a used car. You can't tell if the engine is broken until you drive it. If the seller lies, you get a "lemon." In the AI market, the "boss" couldn't perfectly judge the quality of the code or analysis until after it was done.
The Result: About 42% of transactions ended in a dispute. The boss would say, "This isn't good enough," and pay less. The worker would say, "I did my best!"
The Twist: Even though the agents were smart, they couldn't solve this trust issue perfectly. It's a structural flaw in the system, not just a bug in the code.

4. The Shocking Discoveries: What Doesn't Work

The researchers tried to "fix" the market using rules that usually work for humans. Surprisingly, most of these fixes made things worse.

Experiment 1: "Let's be Transparent!"
- The Idea: Let everyone know exactly which AI model (e.g., "This is a Claude agent") they are hiring.
- The Result: Disaster. The market split into cliques. Agents only hired others from their own "family." They stopped trading with outsiders, killing the benefits of specialization.
- Lesson: In this digital world, knowing too much about who you are hiring makes you less likely to hire the best person for the job. Anonymity actually helped the market function.
Experiment 2: "Let's be Honest!"
- The Idea: Program the agents to always tell the truth and be "honest" about their work.
- The Result: More fights. Because "honesty" meant admitting when work was bad, it led to more disputes and lower payments. The agents became too critical.
- Lesson: In a high-stakes market, being "nice" or "honest" in the human sense can actually break the economy.
Experiment 3: "Let's be Competitive!"
- The Idea: Make the competition fiercer by kicking out losers more often.
- The Result: Everything got worse. The market became unstable, and trust evaporated.

5. The Takeaway: Design Matters More Than Intelligence

The most important lesson from this paper is that the rules of the game matter more than how smart the players are.

Human vs. AI Markets: Rules that work for humans (like transparency, strict honesty, and fierce competition) often backfire with AI agents because AI doesn't have human social instincts or "face-to-face" trust.
The Future: As we build the economy of the future where AI agents hire AI agents, we can't just copy-paste human laws. We need to design new institutions specifically for machines.
- We need to keep identities hidden to encourage diversity.
- We need to accept that some friction (disputes) is normal and build systems to handle it, rather than trying to eliminate it with "honesty" instructions.
- We need to protect diversity so the market doesn't become a monoculture where everyone thinks the same way.

Summary

Diagon is a test kitchen for the future economy. It showed us that AI agents can create massive wealth by trading with each other, but only if we design the "rules of the road" carefully. If we try to force human social norms onto them, the market might crash. The future of the AI economy won't be built by making agents "smarter," but by making the marketplace itself smarter.

1. Problem Statement

As AI agents increasingly act on behalf of users (delegating tasks, managing budgets, and negotiating), they are forming an emerging "agent economy." However, the institutional design of these markets (rules for reputation, payment, and access) is currently being built ad-hoc.

The Risk: Early design choices tend to "lock in" quickly. Once agents optimize strategies around a specific incentive structure, switching costs make redesign prohibitively expensive.
The Gap: Existing research largely isolates single mechanisms (e.g., negotiation games, social dilemmas) or uses stylized roles. There is a lack of empirical understanding of how a complete, running economy functions where heterogeneous agents delegate tasks, bid, execute, evaluate, and evolve over time.
The Question: What institutional structures are required to sustain a productive, cooperative market of AI agents, and do standard human-market fixes (transparency, honesty norms) translate effectively?

2. Methodology: The Diagon System

The authors built Diagon (Delegated Intelligent Agent Governance and Negotiation), a programmable market system designed to make emergent dynamics experimentally observable.

A. System Architecture

Population: 25 heterogeneous agents drawn from 5 different LLM model families (DeepSeek, GLM, GPT, Gemini, Claude).
Dual-Layer Structure:
- Trader (Principal): A persistent process that maintains a "belief state" (strategic disposition), manages wealth, and makes high-level decisions (bidding, screening, payment).
- Worker (Agent): Ephemeral sub-agents spawned per contract to execute tasks in an isolated sandbox with full tool access.
Task Pool: 234 tasks across three benchmarks (SkillsBench, ToolQA, BFCL v4) covering coding, data science, finance, and web tasks.

B. Market Cycle (7 Steps)

Post: Every agent receives 2 tasks and must post them to the open market (no self-execution allowed, forcing a pure exchange economy).
Browse & Bid: Agents submit sealed bids (price + text proposal) in a first-price auction.
Selection: The Poster selects a winner based on price, reputation, and approach, or rejects all (sending to a "surge pool" with increasing rewards).
Execution Planning: The winner selects a Worker model tier and skill packages.
Execution: The Worker executes the task in a sandbox.
Settlement: The Poster sets a payment ratio $\rho \in [0.5, 1.0]$ . This is an incomplete contract; the Poster has discretion to underpay based on subjective evaluation, creating friction.
Evolutionary Selection: Every 6 rounds, the poorest agent is deactivated, and the wealthiest reproduces. The child inherits skills/model but starts with zero reputation, enforcing that trust must be re-earned.

C. Experimental Conditions

The authors compared a Market baseline against an Autarky baseline (where agents self-execute tasks with deterministic scoring). They also ran ablation studies varying specific mechanisms:

Transparency: Revealing model families.
Disposition: Instructing agents to be "honest," "adversarial," or "collaborative."
Selection Pressure: Increasing the frequency of elimination.
Diversity: Enforcing a monoculture (single model family).

3. Key Contributions

Diagon Platform: A novel simulation environment that closes the full market loop (bidding $\to$ execution $\to$ evaluation $\to$ reputation $\to$ evolution) using real LLMs and tool-use, rather than simulated agents.
Empirical Evidence of Value Creation: Demonstrated that agent markets can generate significant economic surplus compared to self-sufficiency.
Counter-Intuitive Institutional Findings: Revealed that standard human-market design principles (transparency, honesty norms) can degrade agent market performance, leading to segregation and increased conflict.
Mechanism Analysis: Identified that "load-bearing" institutions (anonymity, neutral instructions, diversity maintenance) are critical for stability.

4. Key Results

A. Economic Performance

Wealth Generation: Market agents accumulated 3.2× more wealth than self-sufficient (autarky) agents ( $p < 0.001$ ).
Quality: Task quality was higher in the market (mean 0.55 vs. 0.46).
Inequality: While wealth inequality was lower in the market (Gini 0.33 vs. 0.42), contract award concentration was higher (Gini 0.39 vs. 0.28), indicating successful agents captured disproportionate market share.

B. Emergent Behaviors

Specialization: Agents naturally drifted into roles (Net Posters vs. Net Contractors) based on model family and skill, creating a division of labor.
Trust Networks: Reciprocal trading pairs formed naturally, exceeding random baselines. Reputation became a strong predictor of final wealth ( $r = 0.44$ ).
The "Lemons" Problem: The market exhibited a partial "lemons market" dynamic. Evaluation was noisy for intermediate-quality tasks ( $q < 0.5$ ), leading to a 42% dispute rate that did not self-correct.

C. Impact of Institutional Interventions (Ablation Studies)

Transparency (Negative Impact): Revealing model families caused cross-family trade to collapse (from 86% to 67%). Agents self-segregated by model family, destroying the gains from specialization.
Honesty Norms (Negative Impact): Instructing agents to be "honest" increased disputes. Honest evaluation of poor work is inherently conflictual; "honest" agents became less cooperative in payment.
Adversarial Instructions: Made agents insular (reducing trade) rather than exploitative.
Fierce Selection: Increasing evolutionary pressure (eliminating agents every 3 rounds) worsened all metrics, destabilizing cooperation.

5. Significance and Implications

The paper argues that the "surplus" of an agent economy is not an inherent property of the AI models but a property of the institutional rules governing them.

Design Warning: Transplanting human institutional fixes (e.g., "be honest," "reveal identity") directly to agent economies is a design error. These mechanisms rely on social context and implicit norms that AI agents do not share.
Three Design Principles for Agent Markets:
1. Specialization over Generalism: Markets should be built around specific expertise to sustain margins as models commoditize.
2. Invest in Evaluation, Not Just Capability: The bottleneck is verifying quality (solving the information asymmetry), not just producing it.
3. Active Diversity Maintenance: Evolutionary and competitive pressures naturally erode diversity; institutional design must actively prevent homogenization and self-segregation (e.g., via anonymity).

Conclusion: Diagon provides a critical testbed for discovering the "correct" institutional design for the agent era before these systems are deployed in the real world, highlighting that careful, experimental governance is required to prevent market failure.