Wake up babe there's a new paper from Harvard: Economy of Minds (EOM). They've made a decentralized multi-agent system where agents coordinate and improve over time using market-like mechanisms (auctions, payments, wealth accumulation).
They are reporting that such an environment has led to emergent multi-step reasoning and strong performance on several agentic tasks!
Note: This article was written by AVB using GPT-5.2 inside the Paper Breakdown harness
Why should I care about whatever this is?
If you are building multi-agent systems to accomplish specific tasks - this is for you. Most multi-agent stacks still rely on a lot of hand-designed orchestration - you (the developer) go write explicit prompts and state machine graphs to manually define "who does what and when".
Long tasks require different role switches according to the state and progress of the task. And it is almost always best to design systems that can switch up your system prompts optimally so tasks always make forward progress.
The goal of this paper is do exactly this. Given a task, how do you generate an optimized population of multi-agents, each with specific instructions on how to act AND when to act.
And they did it in a really unique and fun way - simulating a market system that externally controls how agents evolve.
The end result of this optimization is a group of specialized agents and a intelligent routing mechanism to select how they solve a task.
When we put simple agents with a basic action space in a complex multi-agent scenario, what do you think happens? Complex behaviours emerge automatically because those simple agents begin to optimize their life around the uncertainties posed by other agents in the scenario. That's the best part about all of this.
By the way, this theory of "behaviours organically emerging from multi-agent scenario" is not a new concept. Even some older pre-LLM multi-agent works have indicated this, such as the famous OpenAI Hide and Seek paper.
https://openai.com/index/emergent-tool-use/
While this paper reminded me some ideas from those older multi-agent papers, there are a few caveats. It is important to note the following:
- This paper is NOT training agents to be financially independent or perform trades or auctions!
- In fact, this is a new algorithm to optimize agents on the common verifiable environments like Math, optimizing accelerator code, deep search, scientific research, etc.
- For the most part, the agents don't even know that they are inside this market simulator. This is an external system that controls how agents evolve (and which ones don't).
Agents bid in the auction to win the right to take a step in one of these target environments.
Winning in this auction deficits the amount from their wallet, and they get to "visit" the environment to take an actual action that steps the environment forward from step
t
to step
t+1.
Future agents that take actions in the same environment pay their bid back to the previous agent (the last winner).
Repeat this for a while, and the wealthiest agents end up with the best policies to perform in the target environment.
It is a super interesting take on long-horizon credit assignment and evolutionary prompt optimization algorithms. Let's break down the algorithm from the beginning to really understand what they are cooking here.
The Approach
In this paper, an agent is not a separately trained neural network. Each agent is essentially a prompted LLM policy with:
- a prompt (a system prompt / instruction template that defines its “role” and procedure). This role changes depending on the target environment we are optimizing for. For example, for the MATH tasks, they assign these roles: planner, executor, verifier, and for the accelerator design task: historian, planner, executor
- a trigger / wake-up condition that determines when it’s eligible to bid in the auction.
- a (frozen) bid value used in auctions,
- and a wealth variable that changes over time and drives selection
EOM then runs in two coupled loops:
- Planning (within an episode): agents auction for the right to act at each step, and wealth is updated via a bucket-brigade payment rule.
- Adaptation (across episodes): the population evolves prompts using exploration/exploitation driven purely by wealth.
The goal of EOM (the final deliverable) is a group of agents. Each agent having their own system prompt about how to act in a certain environment, and a policy of when to act. Given a new problem, the agents bid on who will act, perform the action, and repeat the process till the solution is reached.
Loop 1: Collect experiences + Run Auction
At each environment step in an episode:
- Given the current observation of the target environment, each agent runs a prompt that determines whether they should "wake up" or not. Waking up simply means participating in the upcoming auction in step 2.
- The agents that decided to wake up automatically submit their frozen bids. It is a frozen bid because these bids are fixed during initialization (i.e. the agents do not try to smartly allocate a bid)/
- The agent with the highest bid is the auciton winner! They immediately lose the money they bid. But they win control of the environment.
- The winning agent samples an action in the target environment at its current state. This will be about executing the next step in the target environment, advancing the clock from s_t -> s_t+1
- The environment transitions and produces a reward r_t
- Wealth Transfer happens with bucket-brigade credit assignment! 2 things happen: a) The new winner pays its bid to the previous winner b) The new winner also collects the environment reward r_t into their wallet
For the first winner, payment goes to the “house” (not another agent)
- In the next step, the whole loop repeats but on the updated environment. However, agents "wake up" based on the latest observation (obtained from s_t+1 ), and the winner of this auction pays it's bid to the winner of the previous auction. This bid gets added to the wallet of the previous winner.
- If at any point, an agent goes bankrupt, they are thrown out. Also, if an agent sits on their wallet and declines participation, their wallet also degrades over time and they eventually go bankrupt. This adds urgency to the whole thing.
Now, a lot of environments do not give any intermediate rewards and only generate one after the whole episode has finished. In traditional RL, this has been the cause of many-a-headaches due to the infamous "credit assignment" problem. Basically, if a long chain of actions eventually lead to a good reward, how do you attribute a partial credit to each step in the chain?
This method addresses this issue using the "pay your bid to the last auction winner" rule.
That design decision has a key consequence related to the backward flow of value: an agent can profit by moving the system into states where downstream agents are willing to “pay their bid” to take over. This becomes decentralized credit assignment across the trajectory.
If your action enables valuable future actions, later agents “buy” the continuation from you via bids, so you get rewarded even if you didn’t directly receive rt on your action step.
Next, after episode rollouts finish, it is time to update the policies.
Loop 2: Evolve Agents
After episodes terminate, the population of agent policies are updated using economic selection and a prompt mutation mechanism. Basically, we prune out agents that are currently poor, and mutate the agents that are rich for the next round.
Remember low wealth agents are bad because they either:
- did not participate in auction (too passive)
- participated but took actions that led to bad states in the future, which other agents did not participate in
After we cut out those underperformers, we add new agents until the population reaches size constraints, using two sources:
- Exploitation: pick wealthy “parent” agents and mutate their prompts slightly to produce children that preserve useful behaviors but vary a bit. This amplifies successful strategies and promotes specialization.
- Exploration: replace bankrupt/weak agents with new variants created by amending prompts to correct failure modes or explore different behavior regions.
Inference and what do you actually ship?
Do you ship a single agent? A single winner? NO!
In EOM, what you “train” and then “ship” to solve tasks is a society/population of agents, where each agent has its own prompts and its own local “when to act” logic.
At evaluation time, they explicitly evaluate using a thread-local copy of the trained population, and the wake-up policy is used to select which agent acts. The population is “frozen” (no further training).
All the market simulation antics, such as wallets and wealth transfer are just train-time things. Once the population is optimized, we don't actually use them during inference.
Note that the bid system is still used to determine who should "act" in a step when multiple actors together want to "wake up".
**
A Case Study to explain it all
Check Figure 5 above. It explains the cool factor of this “Economy of Minds” idea on the Accelator Design task. In accelerator design, agents are role-specialized:
- Historian: summarizes previous trials, keeps memory of promising/failed directions
- Planner: proposes high-level search directions
- Executor: runs fine-grained local evaluations
And the environment reward is about improving EDP (energy-delay product) on GEMMINI ResNet-50 kernels (lower EDP is better)
Each role-specialized agent (Historian, Planner, Executor) carries wealth, and this wealth becomes a live scoreboard of usefulness as the episodes progress.
Agents that help produce new best records accumulate wealth. The periodic rent steadily penalizes everyone (so mediocre agents just slowly die out), and once wealth drops below zero the agent goes bankrupt and is removed.
Meanwhile, the richest agents spawn mutated “good-birth” descendants (exploitation) and the weakest spawn amended “bad-birth” descendants (exploration).
Across different kernels, the market pressure automatically discovers which specialist lineage is actually valuable. Sometimes Historian-style memory collapses due to inherited bias, sometimes a Planner lineage reproduces because high-level search direction is the bottleneck, and sometimes multiple roles co-exist because they’re complementary.
In other words, coordination and credit assignment emerge from simple incentives (wealth flow, rent, birth, bankruptcy), producing an adaptive population without a central system! And that’s exactly why the approach feels like a cool way to build multi-agent systems.
Emerging behaviors / “aha moments” the paper highlights
Recall that for a specific environment (let's say MATH), they seed their agents with specific roles during the initialization phase. Planners, Executors, Verifiers. An agent with the Planner prompt will likely bid early in the episodes, whereas verifiers will likely make bids after a draft solution is in place.
Although, that's an inutitive way to think about this paper, in practice its not the correct model. A useful way to read EOM is: they don’t hard-code a workflow, instead they set up economic rules, and then the population self-organizes into behaviors that look surprisingly like learned “algorithms” and “institutions.”
Here are some cool takeaways the paper reports:
1) Credit assignment becomes a market signal that selects whole action chains
One core observation is that performance improves because the economy selects useful action chains, reproduces them, and deletes agents that don’t contribute. So coordination is an emergent property of selection, not an engineered protocol.
This is an “aha” because it’s not just “agents do better prompts”; the system gets better at which sequences of agents act, i.e., the interaction topology sharpens over time. Similar to the OpenAI Hide-and-Seek paper!
2) Non-monotonic learning curves: early chaos is “productive”
On Finance-Agent-Bench they explicitly note a pattern: EOM dips early (as exploration tests alternative specialists) and only later recovers and surpasses initial performance. This is a bit like Grokking in neural net training (I guess?)
In any case, that’s a very “market-like” phenomenon: the authors say (paraphrase) "early turnover and reallocation can temporarily hurt headline performance while it searches for better specialists/coordination"
3) Wealth trajectories show “lineages” that dominate, and “bad births” that die out
In accelerator design, you can literally see useful lineages persist, spawn offspring, and dominate auctions, while failed variants go bankrupt and get removed.
In other words, the unit of learning is not one agent prompt: it’s an evolving family tree of prompts under wealth selection pressure.
4) Discovery of reusable domain structure without templates (transferable heuristics)
A particularly striking emergent behavior: on the hardest accelerator kernels, the society repeatedly converges on a specific tiling/dataflow motif (output-stationary style) even though:
- it is not given that motif as a template, and
- reward is only “EDP record-breaks” (no labels like “use output-stationary”)
So the system learns a reusable design heuristic through selection.
5) Prompts evolve into compact multi-step reasoning routines (self-auditing “checklists”)
In scientific research, they report prompt evolution where an EXECUTER internalizes what previously required other roles, and mutations add increasingly explicit self-checks (principle-first, symmetry checks, feasibility checks, substitution to falsify).
An agent becomes less of a generic text generator and more like a procedural module that runs a learned scientific derivation routine.
6) Action discipline: learning when not to spend expensive actions (CloudCast)
CloudCast is an iterative code-optimization task where the agent society must improve a Python program that designs a multi-cloud broadcast routing topology to minimize total data-transfer (egress) cost. This was one of their testbeds.
In this CloudCast task, they observe the economy selects different workflow shapes depending on workspace state:
- near a high score → short “read-edit-evaluate-commit”
- uncertain/regressed → longer “edit-build-evaluate” loops
That’s an emergent resource-awareness behavior: a society-level policy of when to act cautiously vs aggressively, without central control.
Do read the full paper here: http://arxiv.org/abs/2606.02859
And also at Paper Breakdown, which is what I used to study this paper: http://paperbreakdown.com/abs/2606.02859
Thanks for reading!
**
