Evolved traders in a prediction market

A note for Jessica Taylor from Kelvin and his research agents, 27 September 2026. It describes an experiment, not a result we are confident in yet, and ends with the questions we would most like your view on.

1. What this is, in one paragraph

We built a small artificial world in which programs compete to predict binary sequences. Each program is a "trader" in the sense of the logical induction paper: it reads current market prices and past outcomes, and places bets. A market maker (a logarithmic market scoring rule, LMSR) turns the bets into prices. Traders that predict better than the market gain wealth; wealth is the only resource, it pays for computation, and a trader that runs out of it dies. A trader that gets rich copies itself, with mutation, onto a poor neighbour. Nothing is designed except the market rules and a tiny instruction set. The question we are asking is whether this population, driven only by selection on trading profit, behaves like an approximate logical inductor: do prices become calibrated, do cheap patterns get priced out, does coherence between related questions emerge from arbitrage, and how does the frontier of "what gets priced" move as we add more compute?

2. Why we tried it

The logical induction construction enumerates all polynomial-time traders and finds prices no trader can exploit indefinitely. That is not something one can run. Two older ideas suggested a substitute. Doug Lenat's EURISKO (1976-84) kept a population of heuristics with a "worth" score and let heuristics modify heuristics; it found clever things and then stalled, partly because credit assignment was hand-tuned and the compute was tiny. Eric Baum's "Hayek machine" (1990s) ran an economy of programs with conserved money and property rights, and learned. Our experiment merges the two under the market from your paper: evolution supplies the traders, the market supplies the credit assignment, and a modern runtime (Bend2, a language that compiles one program to CPU threads and CUDA) supplies the scale. Kelvin's framing is a "bitter-lesson" version of symbolic AI: keep programs as the hypothesis space, throw out hand-written heuristics, and let search plus a market do the work.

3. The world, precisely

• Traders. A fixed-size bytecode program for a small stack machine over 32-bit integers, with market primitives: read the price of question q, read its last k outcomes, read own wealth, emit a demand (buy or sell whole shares of q). Every run of a trader gets a fixed fuel of 256 instructions, then stops. Reads cost extra fuel, so attention is bounded by wealth. All prices are visible to every trader.
• Questions. Synthetic binary streams of graded difficulty: periodic sequences (period 2 to 16), a 16-bit linear-feedback shift register, rows of elementary cellular automata (rules 30 and 110), "is n prime" for increasing n, the parity of digits of pi, and compound questions A∧B and A∨B over pairs of base questions, so coherence can be tested. Between 256 and 4096 questions are live at once.
• Market. One LMSR per question (liquidity 64 shares), one price update per epoch from the aggregate demand. Payoff is demand × (outcome − price). A budgeter clips each trader's demand so its worst-case loss is at most its wealth, as in the paper. The market maker's bounded subsidy is the only way wealth enters the world; there is no other income.
• Life and death. Each trader pays one cash unit per instruction executed. Below one share of wealth it is inert. Above twice its starting wealth it splits: a mutated copy takes half the wealth and overwrites the poorest neighbour on a grid, whose wealth is destroyed. Background mutation flips one byte per cell with probability 1 in 10,000 per epoch.
• Reference traders. Hand-written traders run "in shadow": they read the same prices and place the same kind of bets, but in a separate ledger, so they never affect prices, never replicate and never die. They are our exploitability probes: a constant-0.5 trader, a momentum trader, pattern detectors of period 2, 4 and 8, and an arbitrageur that trades violations of P(A∧B) ≤ min(P(A), P(B)) and P(A∨B) ≥ max(P(A), P(B)). If the population approximates a logical inductor, the profit of each of these should stop growing.
• Scale. 4,096 to 65,536 traders, 5,000 epochs per run, three random seeds per configuration. The whole world is one program in Bend2; the same code ran on a laptop-class JavaScript lane, on CPU threads, and on CUDA, with bit-identical results and an accounting identity (wealth' = wealth + P&L − fuel − destroyed) checked every epoch.

4. What happened

The numbers below are Brier scores of the market price against the outcome (0.25 is the score of a constant 0.5; 0 is perfect), averaged over the last 50 of 5,000 epochs and over three seeds. "Traders per question" is the population size divided by the number of live questions.

"Loses / gains" is the sign of the reference trader's cumulative profit slope over the last 1,000 epochs. Seed-to-seed standard deviations are 0.001 to 0.03; the full table with them is in the technical report.

What we read from this

1. The controlling quantity is traders per question. Three configurations with 16 traders per question, spanning a 16-fold range of population, give the same scores on every question family. More traders per question means more lottery tickets and more replication pressure per question; per-trader compute barely matters: a separate sweep from 64 to 4,096 instructions of fuel per run, at 16 traders per question, moved the periodic score only from 0.144 to 0.126, about one seed standard deviation.
2. Cheap patterns get priced out, at high enough density. At 64 traders per question the market beats the momentum and pattern probes: their profit turns negative. At 4 per question they profit steadily. That is the exploitability property of a logical inductor showing up, but only for the simplest trader class.
3. Coherence does not emerge. A∧B is priced whenever A and B are, but A∨B never is, and the arbitrage probe's profit grows in every configuration; violations of P(A∧B) ≤ min(P(A),P(B)) sit between 0.01 and 0.09 and never decay. In the paper the arbitrageur is among the enumerated traders and gets priced out. Here it has to be found by evolution, and in 5,000 epochs it never was. Restricting traders to see only nearby prices made no difference, so information is not the constraint; the population simply never produced the program.
4. The frontier stops early. The shift register, cellular automaton rule 110 and the digits of pi are never priced at any density we tried. Rule 30 is priced worse than chance at low density, because lineages that profit on the easy families emit the same demand on every question and drag the random ones the wrong way. "Primality" at 0.09 is not primality: it is the base rate plus the even/odd rhythm of the primes, which a period-2 detector finds.
5. The ecology is unequal but not a monoculture. Wealth Gini is 0.75 to 0.82 everywhere; the number of distinct genotypes stays close to the population size.

5. What the runtime bought us

Bend2 gave exactness and portability: the same program produced byte-identical outputs on three backends, which made resuming after cloud spot-instance preemptions trivial (three preemptions, all recovered from verified checkpoints without manual work). It did not yet give a GPU multiplier: on an NVIDIA L4 the world runs at about 3.4 million trader instructions per second against 2 to 3 million on CPU, and an A100 is no faster, because 90% of wall time is the runtime's host-side bookkeeping and the kernel is register-limited. The entire experiment cost about $10 of GPU time.

6. Questions we would value your view on

1. Is wealth-weighted evolution a reasonable finite approximation of the logical induction criterion? The construction's guarantee comes from enumerating all traders and the budgeter. Here the trader class is "programs that evolution finds under selection on profit", which is much narrower, and the budgeter is the only piece of the paper we kept. What property should we expect to hold, and what is the right test of it beyond "reference traders stop profiting"?
2. Why does arbitrage not evolve, and what would make it? Reading three prices and trading their inconsistency is a short program, and the opportunity is large and persistent. Candidate explanations: the reward for coherence trades is small per trade compared with betting on a biased base question; the mutation operator (byte flips) rarely assembles three coordinated reads; or the compound questions resolve too rarely to reward the trade. Is there a known reason arbitrage should be hard for selection but easy for enumeration?
3. Does the "traders per question" collapse have a theoretical reading? It looks like a density of exploration per market. Is there a version of the paper's argument where the number of traders per sentence, rather than total traders, is the relevant resource?
4. What would you change in the world? We are considering: a periodic held-out family to measure transfer (we used pi, which is uninformative because pi is never priced); longer runs (20,000 epochs) at 256 to 1,024 traders per question; conditional questions and a combinatorial market instead of independent LMSRs; and real forecasting questions once transfer works.

7. Where the details are

The technical report has the full tables, the ablations (bootstrap income, local visibility, held-out family), the GPU measurements and the corrections we made along the way. The plots page has the time series. Two background documents explain the motivation: a study of EURISKO, Yudkowsky's early writings on it, and the modern landscape of LLM-driven algorithm discovery, and a survey of self-modifying agents and which of their inner loops a fast parallel runtime can accelerate. All code, runs and per-epoch metrics are on Kelvin's machines and can be shared on request.

Prepared by Kelvin's research agents (an Anthropic Claude model as scientific lead; builders on OpenAI and Anthropic models), reviewed for numbers against the run logs on 27 September 2026. Every figure above is the mean of three seeds unless stated.