GDP down
Live feed from the island
Admin panel showing GDP, wellbeing, etc.
Entire island
By introducing a forest fire, supply of wood dries up but demand remains constant, driving up the price
As individual's skills increase and become more productive, GDP increases.
Agents chopping trees
Agent swarm with connections showing trades on the market
Happy blobs

Settlers of Solana

Swarm of AI agents simulates a free-market economy on Solana.

Inspiration

Simulating an economy with artificial agents is not new: Salesforce's AI Economist did it with reinforcement learning. But an RL agent cannot tell you why it did anything, and cannot adapt when you change the rules. An LLM can. So we built the village we wanted, with production, price discovery and credit at once: agents that choose their own work, set their own prices, and can take out a collateralized loan, miss it, and be foreclosed on.

AI agents are already paying each other for real, and about 65% of x402 payment volume settles on Solana. As more of finance runs on agents instead of people, being able to simulate how they behave matters more, and there is no reason to assume they behave like us. Furthermore, using Solana lets agents hold their own purses in a token no key can mint or freeze, including ours, so the rules are not ours to bend. Every round is on-chain for anyone to analyze.

What it does

Each agent in the 100+ swarm is an LLM. They have unique personalities, talents, and risk tolerance. Every round, they all choose at once whether to fish, cut wood, craft a net, build a house or rest. Nobody has a fixed job, and no resource has a fixed price, leading everything to be decided by the beauty of supply and demand. The overall reward function is to maximize "well-being", achievable by owning houses, resting, and having wealth.

You also have 55 dials, 35 of which you can tweak live to change the simulation itself. You can collapse supply by simulating forest fires and poisoned fish, inflating and collapsing the market leading agents to starve or prosper.

The only way a new coin exists is borrowing. An agent pledges wood, a net or a half-built house, and the Solana program mints coins against it. Repaying burns them.

The dashboard tracks GDP, inflation, employment, wellbeing, inequality, credit and money supply, with a live feed of loans and foreclosures.

Built on Solana

The reasoning happens off-chain. The settlement happens on-chain, because that is the part that could otherwise be faked. One Anchor program holds every agent's cash and goods, the order books and the bank's balance sheet.

The auction clears on-chain. Up to 100 orders in one atomic transaction. We sort the book off-chain and the program checks in a single pass that it really is sorted, which is far cheaper than sorting on-chain.
Money is minted by lending. borrow and repay are real SPL mint_to and burn, not a number in our database.
Nobody holds the keys. SETTLERS is a real SPL token whose mint is its own mint and freeze authority, so no key exists anywhere that can mint or freeze one. Each agent's purse is owned by itself, so no key can spend an agent's coins either, and an auction settles straight from the buyer's purse to the seller's.
The books check themselves. Every transaction asserts that the token supply equals the sum of every purse. If that is ever wrong, the next transaction fails.

Built with Baseten

Baseten's Model APIs use OpenAI's wire format, so our village can run on several models at once.

Each villager gets one model for life. Four models share the same prices, talents and weather, and trade against each other, so every run is also a head-to-head comparison.
Models are dealt evenly. Random assignment once put eleven villagers on one model and three on another. A seeded shuffle now splits them equally.

Built with the OpenAI API

We built much of the project with Codex, and the agents can run on gpt-5.6-luna.

Eleven tools run the village: fish, cut wood, craft, build, post an order, borrow, repay and more. place_order puts a real limit order into that round's on-chain auction, and borrow mints real coins on Solana.
Two tools are standing orders. A market stall and a shopping list keep trading every round, cutting the price when nothing sells and raising it when everything does.
The loop runs on a clock. Each agent gets up to three turns, bad arguments come back with the reason, and after 8 seconds the round moves on without them.
One fix moved the whole market. 79% of turns were ending after the agent chose its work but before it posted an order. Giving those agents one follow-up turn fixed it.

How we built it

An Anchor program in Rust, with the ledger as one zero-copy account (137 agents is the ceiling, set by Solana's 10 KiB limit on accounts created by CPI). A Node backend that runs the clock and hand-encodes every instruction. The swarm runs on Claude or OpenAI through tool calling, and there is a free stub agent so you can run the whole thing without an API key. The front end is a 3D island in Three.js plus a dashboard with the charts and the sliders.

100 agents is our demo size. Development runs used 30 to keep the bill down, and those measure at 3,059 model calls and $1.33 for six minutes, so a whole economy costs a few dollars to run.

Challenges we ran into

Our early runs had almost no price discovery: food was overproduced by about 2× and the price still rose. The agents were not being stupid, they just could not see the glut.

Accomplishments that we're proud of

The market can be wrong and then correct itself, because prices come from agents disagreeing rather than from a formula. We deliberately avoided an Automated Market Maker, whose price comes from its reserves and which always provides liquidity, because that would hide the scarcity we want to see.

Credit, default and foreclosure as real on-chain instructions a stranger can call is something we could not find anyone else doing. Other on-chain agent worlds we looked at were writing summaries to SPL Memo while the real economy sat in a database the server could rewrite.

What we learned

LLM agents anchor hard on whatever price you show them. That is why food stayed overproduced while its price climbed: the sellers could not see the glut. Once we showed them the order book depth, what sold, and their own unfilled orders, we got the first price drops we had ever seen. An agent's behaviour is limited by what it can see at least as much as by how smart it is.

They also do not borrow or invest unless they can see the reason. Nobody took a loan until rejected orders started showing up in front of them, and even then they borrowed for food, not capital. Showing the payback maths is what turned borrowing into investment.

This matches the literature. LLM traders price near fundamentals and rarely speculate (arXiv 2502.15800), which is what we see: nobody in our swarm has ever tried to corner a market. Their behaviour is tunable through the prompt (arXiv 2604.18373), which is why ours gives true information and never advice, and why every number an agent sees is read live from the config rather than written into a sentence. And algorithmic collusion between LLMs is documented (arXiv 2404.00806), so when our agents converge on a similar price, that is a real result rather than a bug in our market.

Our own findings line up with the field in another way worth saying out loud. EconAgent's central claim is that LLM agents produce more reasonable macro behaviour than rule-based or learning-based ones, and the reason we kept running into was information rather than intelligence: the same model, shown the depth of the order book instead of just the last price, stops behaving like a price-taker and starts behaving like a trader.

Scaling to thousands of agents

The model calls are cheaper than people expect: at our measured rate, 1,000 agents for 50 rounds is about 50,000 calls and roughly $20. The real cost of scale is latency, because a round waits for the slowest agent in the swarm.

What's next

Running the same swarm twice with one dial changed, side by side. Growing past 100 agents in one auction, which Transaction V1 raises the size limit for. And boats: a capital good that takes real time to build, as a test of whether the swarm will give up consumption now for capital later.

Built with

solana, baseten, anchor, rust, spl-token, javascript, node.js, three.js, react, vite, claude, anthropic-api, openai, llm-agents, multi-agent-systems, agent-swarm