A tight cloud of starlings swirling against a golden evening sky
Starling murmuration, RSPB Minsmere. Photo: Airwolfhound, CC BY-SA 2.0

vizmaya desk · science from first principles

A small AI tried 734 ideas in an hour. Its rivals tried 158, 99 and 81.

SwarmEvolve is a new way to make AI search for math and science answers. It comes from Brown University and was posted on 5 November 2026. It is a preprint, so no one has peer reviewed it yet.

734 vs 158 vs 99 vs 81 · programs tried in 60 minutes

How does a small model pull that off?

Source: Jiang and Karniadakis, arXiv 2611.08483v1, p1 and p18. vizmaya desk, 7 Nov 2026.

The puzzle

Hard math problems are a search for a good program.

Fit 26 circles in a square so their radii add up to the most. A scorer can grade any try. Finding the best try is the hard part.

How does an AI search for the best try?

Source: paper p20 (circles), p21 to 22 (hexagons), p5 to 6 (scorer).

Close-up of honeycomb with many six-sided wax cells and a few bees
Hexagon cells are nature's packing puzzle. The paper packs 11 hexagons into the smallest hexagon. Photo: mooyai, CC0

The old way

AI searches the way nature does: try, score, keep the best, repeat.

Each round, an AI writes new versions of the best programs and mixes their best ideas. A scorer grades them. The winners go back in the pile.

So what slows the loop down?

Source: paper p1 to 2, p5.

A small Galapagos finch with an orange beak perched on a grey post
Evolution's recipe is vary, select, repeat. A Galápagos finch. Photo: p.j.k., CC BY 2.0

The crack

Rivals spend most of the hour with the AI talking to itself.

OpenEvolve: 52.5 of 60 minutes writing text thoughts (87%). CodeEvolve: 46.8 (78%). ShinkaEvolve: 34.4 (57%). SwarmEvolve: none.

That works out to about 20 to 35 seconds of writing per program (computed).

Black typewriter keys with round letter buttons
Typewriter keys: one letter at a time, like text thoughts. Photo: hill.josh, CC BY 2.0

What if the AI wrote nothing down?

Source: paper p18, Supp Table 2 (Qwen3 8B, 21 problems, 3 seeds).

The turn

SwarmEvolve skips the words. The AI thinks in raw numbers.

Normally an AI writes each thought as words, one word at a time. Here it feeds its own inner numbers straight back into itself, 40 times. No words, no waiting.

Rivals: 20 to 35 seconds of text per program. SwarmEvolve: about 0.55 seconds of number-thinking per program (computed: 6.7 min x 60 / 734).

Rows of wooden beads on an abacus
An abacus: counting in numbers, not words. Photo: Paul Schadler, CC BY 2.0

Who turns those numbers back into a program?

Source: paper p3, p5, p18; 0.55 is computed. The race animation is an illustration, not to scale.

The turn

Helpers pass notes, not essays.

While it thinks, an AI keeps working notes in its memory. Each helper hands its notes to one writer. The writer reads them all and writes one new program.

A dark trail of ants crossing bare orange ground
An ant trail. Illustration only. Photo: dotun55, CC BY-SA 2.0

How many helpers can one GPU run?

Source: paper p3 to 4, Fig 3 and Eq 3. Illustration, not data.

The turn

Each round sends out 450 helpers.

10 swarms of 45. Each swarm has one job: refine the best program (4 swarms), mix the best ideas (3), explore odd directions (2), or start fresh (1).

A black and white photo of a wooden beehive with a dark cluster of bees hanging at its base
A swarm of bees clustered at the foot of a hive. Photo: Library of Congress, Matson Collection, via rawpixel, CC0

What if 15 of 45 helpers say the same thing?

Source: paper p5, Fig 2 (p4).

The turn

A filter drops the 15 helpers who say the same thing.

In each swarm of 45, it keeps the 30 whose thinking differs most. Then the writer reads only those.

Cost of this check: 0.05 minutes of the hour. ShinkaEvolve's similar check: 4.5 minutes.

Flour falling through a metal sieve into a bowl
A sieve keeps some and lets the rest fall through. Photo: waitscm, CC BY 2.0

Did all that pay off?

Source: paper p5, p9 (Fig 5), p18. The dots are made-up points that show the rule, not real data.

The result

734 tries in an hour. Rivals: 158, 99, 81.

734programs tried

That is 4.65, 7.41 and 9.06 times as many (computed).

ContestedThe paper says 5 to 13 times (p2, p7). Its own 8B tables give 4.65 to 9.06. We checked twice, hoping for 13.

A growing pile of colourful folded paper planes on a table
A growing pile of paper planes. Each plane is one try. Photo: HighTechDad, CC BY 2.0

Did more tries mean better answers?

Source: paper p1 (Fig 1), p18 (Supp Table 2). Qwen3 8B, one GPU, 60 minutes.

The result

A small model beat rivals running a model four times bigger.

SwarmEvolve with the 8B model averaged 0.804. The rivals with the 32B model averaged 0.774, 0.733 and 0.731.

Higher is better. 1.0 matches AlphaEvolve's published answer where one exists. The 8B runs used an L40S GPU, the 32B runs an H100. Four times bigger is 32B vs 8B (computed).

How fast does it get there?

Source: paper p7, Table 1 (average of 21 problems, 3 seeds); score defined on p6.

The result

It matched the rivals' one-hour results in 7, 8 and 4 minutes.

These are median minutes to reach what each rival reached in a full hour. Each rival needed all 60.

A silver stopwatch on a black background
The budget is 60 minutes. Photo: wwarby, CC BY 2.0

What does this change for you?

Source: paper p8, Fig 4 (Qwen3 8B, 21 problems, 3 seeds); p1, Fig 1 right.

The payoff

Ask where the compute hour goes.

Bigger models help: SwarmEvolve went 0.804, 0.837, 0.869 from 8B to 32B. Yet its 8B version beat all three rivals' 32B runs.

So where the hour goes matters a lot. SwarmEvolve ran it all on one GPU.

Next time you read an AI claim, ask how many tries it made per hour, and on what hardware.

Where does it break?

Source: paper p7 (Table 1), p18.

Several small colourful computer chip dies lying in a clear tray
Chip dies from an NVIDIA Tesla P100, an older GPU. Not the one in the paper. Photo: FritzchensFritz, CC0

The limits

It lost on 3 of 21 problems.

Best or tied on 18 of 21 (computed). It trails on the three below, with the 8B model.

Does it beat the record holders?

Source: paper p7, Table 1; p38, Fig 21. Problem names are the paper's.

The limits

It beat AlphaEvolve on 3 of 16 problems. The records still stand.

Wins: 26 circles (2.635983 vs 2.635863, tying the best known) and two math bounds. Still far behind: kissing number, 220 vs 593.

ContestedOne bound is defined differently from AlphaEvolve's (p31).

A pyramid of black cannonballs on grass
Stacked cannonballs. The kissing-number puzzle asks how many balls can touch one ball. Photo: WorldIslandInfo.com, CC BY 2.0

How much is the swarm itself worth?

Source: paper p7, p31 to 32 (Supp Table 5, best of 3 runs, 8B); packomania.com/csqv.

The limits

The swarm helps, but less than the headline.

Thinking in numbers vs 40 tokens of text: 0.804 vs 0.796. With zero helpers, it still finishes above all three rivals.

Our reading: much of the lead comes from the whole design, not only the swarm.

Who did the work, and where can you check?

Source: paper p16 (Supp Table 1, Qwen3 8B); p17 (swarm size, no table).

Credit and sources

Who did the work, and how to check it.

Credit

Qile Jiang and George Em Karniadakis, Division of Applied Mathematics, Brown University. Funded by a DARPA MATHBAC grant, HR0011-26-3-E152 (p10). Builds on AlphaEvolve, FunSearch, OpenEvolve, ShinkaEvolve, CodeEvolve, LatentMAS and Qwen3.

Sources

Method

Every number comes from the paper or Packomania and was checked against our research file. Computed: 4.65, 7.41 and 9.06 times; 0.55 seconds; four times bigger (32B vs 8B); 18 of 21. No replication found yet. Charts and dots in slides 5, 6 and 8 are illustrations.

Photos

What will you ask the next time someone sells you a bigger model?

vizmaya desk, 7 Nov 2026.