# 100 LLM Agents Running a Town Economy for 26 Weeks: What Breaks When Agents Set Prices and Earn Wages

> Source: <https://dev.to/mech_app_ai/100-llm-agents-running-a-town-economy-for-26-weeks-what-breaks-when-agents-set-prices-and-earn-590k>
> Published: 2026-09-11 10:05:37+00:00

A team placed 100 memory-equipped LLM agents in a closed economy simulation on real Pokhara Lakeside geography and ran it for 26 simulated weeks. The agents earned wages, ran businesses, and set prices autonomously. Across 91 validated runs (2.44M agent decisions, 21.5B tokens), the money stopped moving in a specific, measurable way.

This is the first published multi-agent economic simulation that runs beyond 1-2 weeks into 26-week territory. It exposes coordination, state management, and failure modes invisible in shorter runs.

Most agent simulations run for a few days or weeks. This one needed to maintain:

The simulation used real geography (Pokhara Lakeside) with spatial constraints. Agents moved between locations, interacted with businesses, and made economic decisions based on memory and current state.

The money stopped moving. A 12x tourist demand shock raised business revenue 4.62x (p<0.001), decomposed exactly into:

Monetary transmission stopped there:

A randomized cash transfer (NPR 5,000 to 20 of 100 agents) showed the same pattern from the opposite direction:

The wealth distribution was near-frozen at the 2-week horizon typical of agent-society studies (ρ=0.964). But not frozen. ρ fell to 0.832 at 12 weeks and 0.752 at 26 weeks. This horizon-dependence is invisible in short runs.

The simulation ran on a multi-agent orchestration layer with these components:

**Agent Memory Architecture**

Each agent maintained:

**State Persistence**

The system used two validation layers:

Every headline number was verified twice. The full run corpus is released for reanalysis.

**Orchestration Flow**

``` python
# Simplified orchestration pulse
def simulation_pulse(agents, environment, pulse_id):
    # 1. Spatial resolution
    locations = resolve_agent_locations(agents, environment)

    # 2. Economic decisions (parallel)
    decisions = []
    for agent in agents:
        context = build_agent_context(agent, locations, pulse_id)
        decision = agent.llm_call(context)  # Tool calls for wage, price, purchase
        decisions.append(decision)

    # 3. Transaction settlement
    transactions = settle_transactions(decisions)

    # 4. Monetary conservation check
    assert sum(t.amount for t in transactions) == 0

    # 5. State update
    for agent in agents:
        agent.update_state(transactions, pulse_id)

    # 6. Observability
    log_metrics(agents, transactions, pulse_id)

    return transactions
```

**Tool Calls**

Agents had access to:

Economic tools succeeded ~96% of the time across two model families. Social tools failed 94-97% of the time, with no measurable shift away from them despite repeated failures.

| Failure Mode | Detection Method | Frequency | Impact | 
|---|---|---|---|
| Price rigidity | Menu repricing rate | 99.7% items never repriced | Monetary transmission stops | 
| Wage stickiness | Wage change distribution | 1.03x movement (p=0.42) | Revenue shock doesn't propagate | 
| Hoarding | Cash velocity, MPC | 96.7% cash held | Demand shock doesn't clear | 
| Social tool failure | Tool call success rate | 94-97% failure | Agents don't coordinate | 
| Wealth freeze | Spearman ρ over time | ρ=0.964 at 2 weeks, 0.752 at 26 | Short runs miss long-term dynamics | 

**Observability Primitives**

The team tracked:

These metrics surfaced the economic deadlock before the simulation diverged.

Swapping the backing LLM moved every outcome measured (p=0.0039). Deleting agents' memory moved none of them detectably.

This is counterintuitive. Memory was expected to matter. It didn't. The model family mattered more.

The team tested two model families:

Both showed the same price rigidity and wage stickiness patterns, but at different magnitudes. The economic deadlock was model-invariant.

| Approach | Pros | Cons | Used Here | 
|---|---|---|---|
| Central ledger lock | Strong consistency, no double-spend | Serialization bottleneck, single point of failure | No | 
| Optimistic concurrency | High throughput, parallel execution | Requires rollback, complex conflict resolution | No | 
| Event sourcing + validation | Auditability, replayability | Storage overhead, validation latency | Yes | 
| Distributed ledger | Decentralized, tamper-proof | High latency, coordination overhead | No | 

The team chose event sourcing with dual validation (live + offline). This provided auditability and caught monetary conservation violations without serializing all transactions.

The simulation enforced:

No agent could:

The simulation ran on:

**Resource Consumption**

Token costs dominated. At $0.01/1K tokens (GPT-4 class pricing), each 26-week run cost ~$2,150 in LLM API calls.

**Token Budget Exhaustion**

Long-running simulations hit token budget limits. The team had to:

**Economic Deadlock**

When agents set prices too high and wages too low, the market stops clearing. Detection requires:

**State Divergence**

Agent state can diverge from ground truth due to:

The dual validation layer caught these, but at the cost of 2x compute overhead.

**Model Drift**

LLM API updates can change agent behavior mid-simulation. The team:

**Use this approach when:**

**Avoid this approach when:**

The key insight: memory didn't matter, but model choice did. Price rigidity and wage stickiness are model-invariant patterns. If you're building multi-agent economic simulations, test across model families early. The economic deadlock will surface regardless of memory architecture.