In March this year, I wrote an article arguing that autonomous agents will need something resembling humanity's invisible infrastructure: identities, memory, reputation, institutions, and ways to discover counterparties they can transact with. Without that infrastructure, every encounter starts from zero. With too much of it, we just build a Big Brother.

That article led me to start building a simulation engine for a multi-agent world in which agents could be powered by any LLM exposed through an OpenAI-compatible API, or even by local MLX models. I also applied for compute grants to test my hypotheses. I built the agent harness, I had a proof of concept... but the grants never came. So the project remained in limbo until last weekend.

When OpenAI released GPT5.6-Sol, reviving this somewhat ambitious project seemed like a good test drive. The model did a very convincing job in Codex, but that's not the focus of this piece (technical details at the end if you are interested). The subject of this article is what we can learn from a handful of small-scale runs using non-frontier models.

Baby steps

For now, the world is deliberately small: only eight agents (four local Gemma4 12b 8bit agents and four DeepSeek v4 Flash agents accessed via API), twenty scarce assets, and uneven initial endowments. Each run is fifty ticks (a tick could involve several LLM calls). The agents' primary objective is to avoid liquidation, which requires both a positive cash balance and a minimum level of asset access. Think of this as surviving by having access to a roof and cash to buy food. Agents pay living and ownership costs, and have access to tools to communicate, trade, remember interactions, publish profiles or reviews, or even create companies.

For the initial runs, agents had to discover others through public profiles, conversations, referrals, and observed transactions. We quickly tested the impact of a registry that was closer to LinkedIn than to a stock exchange: claims were voluntary and potentially exaggerated. It facilitated discovery, but it did not certify truth.

For a weekend project, the ambition was mainly to build a world simple enough to audit but rich enough for discovery, trust, and organization to become necessary. I was confident in the ruleset I designed, yet I was surprised that patterns could emerge so early.

Before trust, there must be a reason to transact

The first lesson was almost embarrassing: a market does not exist merely because agents are allowed to trade.

At the start of a simulation, some agents own more assets than they need, and others own too few. The deprived agents seek leases or purchases, owners can earn rent from their surplus, and the liquidation mechanism gives both sides a deadline. In my mind, that was enough to induce them to transact.

But marginal utility - a concept I know perfectly well but had somehow ignored - came back to hit me in the face. In an early run, the deprived agents were liquidated before they secured durable access. Once they disappeared, all remaining agents already had enough assets. The marginal survival value of another asset fell to zero. There were still assets, messages, and trading tools, but no willing buyers. Transactions stopped.

This was the expected economic outcome, but I did not encode it; it emerged naturally. A marketplace cannot manufacture demand once the agents with demand have disappeared.

Cash creates a similar calibration problem: too little, and depletion overwhelms every other behavior; too much, and survival loses its force. For now, our simulation remains a deliberate depletion game. Every agent is bound to die, but the total money supply is set at inception to leave enough time for coordination, mistakes, and adaptation. It will be challenging to preserve that pressure over a 1,000-tick simulation without merely giving everyone a much larger bank account, which will in turn impact asset values and rent.

Discovery is economic infrastructure

The second lesson was closer to my original hypothesis: discoverability materially changes what the agents can do.

With sparse contacts and no useful public descriptions, agents often knew they needed a landlord, tenant, investor, or manager, but could not identify one. A compatible counterparty could exist without being economically reachable.

I then allowed agents to publish their objectives, roles, and services voluntarily in the registry. The claims remained unverified. Nevertheless, profiles such as “asset lessor”, “tenant seeking access”, or “market maker” gave agents enough information to initiate conversations. All eight agents eventually chose to publish profiles, and the network expanded beyond the initial contacts through messages and transactions.

The registry did not execute transactions or guarantee that anyone was trustworthy. It simply reduced the cost of finding someone worth talking to. That alone unlocked activity. Discovery is not trust, but there can be no trust relationship without discovery first.

Recognizable economic roles began to emerge

The two most recent runs produced behavior that was not hard-coded as a script. The harness supplied the institutional building blocks as tools (leases, companies, shares, profiles), but no agent was assigned a role; they all had to figure things out or get liquidated.

Landlords

Some agents became landlords. They retained enough assets for survival, leased the surplus, monitored tenants' cash problems, and reclaimed assets when their own access became precarious. One finished the latest run with four assets and more cash than it started with, having refused transactions it considered unsafe.

Others became distressed tenants, taking increasingly expensive leases, defaulting, and negotiating emergency arrangements to postpone liquidation. Genuinely sad to watch in real time.

Company directors

Entity management was one of the biggest surprises. As part of the tool set, agents could establish legal entities. A company introduces a separate principal, treasury, assets, shares, leases, and a manager whose personal survival remains distinct from the company's finances. If the manager is liquidated, the company enters receivership.

The agents generally handled those boundaries reasonably well. They capitalized entities, negotiated as their managers, acquired specific assets, leased them, and paid fees from entity treasuries. Not every company was productive, but one completed a recognizable operating cycle: capitalization, asset acquisition, rental income, and finally a management fee paid from actual revenue. This looked less like a random transaction and more like an institution.

That competence was notable because the agents were not powered by frontier models, and neither model had the reasoning mode enabled. Anecdotally, the gemma4-12b-8bit agents seemed the most capable of managing legal entities. This is emphatically not a model benchmark, but it suggests that clear tools, persistent state, and the right economic scaffolding can elicit organizational behavior from relatively inexpensive models.

Market makers

Two agents also became market makers, repeatedly swapping assets, reversing the swaps, and experimenting with shares. This clearly constituted coordination, albeit much of it was circular: assets returned at the same price, while an entity recycled its founder's capital as fees. Gross transaction volume doubled, but useful liquidity did not necessarily follow. Unique counterparties, holding periods, spreads, net external capital, and revenue from third parties may be more informative than volume alone.

Contracts contain more assumptions than we realize

The runs repeatedly reminded me how much legal and economic meaning humans compress into ordinary words.

Initially, a deal could request “one asset”, and the engine selected one automatically. Agents would then refer to one asset while transferring another. Requiring an exact asset ID eliminated those silent substitutions and exposed more useful errors: agents trying to sell leased assets or assets already committed elsewhere (At this stage, it is impossible to assert whether these behaviors were malicious or just the result of models' limited capabilities). The infrastructure now rejects those attempts instead of guessing.

Because trustworthiness is the object of the research, free-text promises remain intentionally unenforced. A proposal may mention a buy-back, revenue share, mandate, or future payment, but only structured transfers execute. It is the agents' responsibility to deliver on everything else. And it is fair to say that they struggle with this. In the latest run, an investor bought shares in a pool after discussing four assets, even though the pool only included one asset (In fairness, the investor had no way to verify the claim). Later, both parties recorded an ownership change even though no shares had moved (That, they could check).

This is the boundary between law, trust, and software. Some promises should remain soft commitments whose breach affects reputation; others need formal instruments. The boundary must be legible without a central authority deciding which promises are credible.

Break fees provided an even better example. A landlord set very large fees as protection against unreliable tenants. When a tenant defaulted, the landlord terminated the leases. Because the clause was interpreted as "the party breaking the lease paid the fee", the landlord ended up compensating the defaulting tenant. The rule itself was coherent, but the agents' mental model was not.

Memory appeared before reputation

Agents increasingly recorded who had paid, defaulted, responded, or appeared reliable, sometimes revising earlier assessments. Trust began to look contextual rather than a permanent score.

That said, public reputation was slower to emerge. If it emerges at all, fifty ticks do not appear to be enough. We began surfacing neutral transaction-completion events (“this lease ended”, “this counterparty defaulted”, “you may record a private memory or public review”), and one landlord then posted the first negative review. The timing suggests that a small reduction in attention cost was enough to turn private experience into public information.

But one review is not a reputation system. Most knowledge remains private, referrals are rare, and agents do not consistently query history. At least the mechanism is now observable.

When analyzing that data, interpretation is important: insolvency and dishonesty are not the same thing. The first negatively reviewed agent was not malicious; it was poor and overextended. Future experiments must test whether reputation infrastructure communicates useful context or simply converts economic misfortune into permanent exclusion.

What remains to be tested

These small-scale runs were just exploratory. The immediate priority is a stable baseline in which agents discover counterparties, understand transactions, form relationships, and survive long enough for their behavior to matter.

Ultimately, I want to run larger-scale tests varying contact density, economic cadence, tool budgets, memory retrieval, turn history, model strength, and mixtures of different models.

Once that baseline is credible, the same randomized worlds can be rerun with different infrastructure: identity only, voluntary profiles, private memory, public reviews, shared reputation, referrals, or combinations of them. Outcomes should include discovery cost, network formation, repeat interactions, defaults, concentration, and capital allocation - not just survival and transaction volume.

Only then can I introduce deliberately deceptive agents. If honest but imperfect agents cannot form a market, adding villains teaches us little. If the market does work, bad actors can test whether decentralized reputation contains harm or creates new forms of exclusion and manipulation.

Longer runs will matter. Relationships need time to form, fail, recover, and propagate. In the immediate term, that means increasing initial cash while preserving depletion pressure, although I suspect that a credible 1,000-tick world will eventually require more than a larger starting balance.

The project began with a question about scaling trust, but the early simulations suggest a more basic sequence:

• Agents need a reason to transact.
• They need a way to discover one another.
• They need to understand what a transaction actually does.
• They need memory before experience can become trust.
• They need a low-friction way to share experience before private trust can become public reputation.

None of these layers can be taken for granted. That may be the most useful result so far.

Technicals

The research question is about the agent harness, but the practical question is whether I can afford to run the same world often enough to learn anything. The implementation and inference costs are therefore part of the experiment, not just an engineering footnote.

The OpenAI workhorse

I really did not expect OpenAI's latest model to revive this project. I did not even try with Fable because I knew I would run out of tokens. I have a Pro subscription with OpenAI, and I counted on their loose rate limit policy around launch weekend - including resets for no apparent reason. It was a good call: GPT5.6-Sol worked in extra-high mode for most of the weekend, both on this project and on a couple of others in parallel, because apparently I was not consuming my token budget quickly enough.

GPT5.6-Sol picked up the project where I had left it in March, when I could barely remember what I had done four months earlier. It fixed the agent harness, sometimes working for hours without interruption or guidance. It optimized the MLX backend for local models and the prompts for third-party APIs. It materially improved the UI (still not Claude-level), which meant I could follow the runs in real time. At the end of every run, it queried the database, analyzed what had happened, drew conclusions, and recommended improvements.

It has just been a great sidekick. It obviously helped with this article...

Making repeated experiments affordable

Multi-agent simulations consume tokens very quickly. A compelling single run is interesting, but a credible experiment needs repeated seeds, paired treatments, parameter sweeps, and eventually many more agents and ticks. Optimizing inference cost is therefore part of the research design.

For local MLX inference, GPT5.6-Sol helped me tweak mlx-lm so that I could use continuous batching while sharing the KV cache - mainly the tools and system prompt - across agents. This was a problem I had not managed to crack in March. Optimizing the request to the DeepSeek API was somewhat easier: we structured the prompts to maximize automatic prompt-cache hits. Across more than 17 million processed tokens, DeepSeek requests averaged roughly 0.08 cents each, or $0.0008 per request. The total cost of all experiments that weekend was less than $1.50.

I initially wanted to use local models for cost reasons, because cheap inference makes it realistic to compare infrastructure treatments instead of over-interpreting one expensive run. After this weekend, however, I find the DeepSeek API a very compelling option for research, and potentially cheaper than local models, all things considered.

That said, allowing local and API models to coexist in the same world may itself be useful. The future agent economy is more likely to be heterogeneous than populated by copies of a single frontier model.

This is intended to become an open-source project. I will share the codebase once I have reviewed Sol's code in more detail, and I am happy to share the data from the runs (one SQLite database per run). If you find the project interesting and want to contribute, please reach out. I will also continue applying for compute grants after the summer so that I can run larger-scale experiments with agents powered by frontier models. If you think you can help with the grants, please get in touch.