GPT-6.1 Sol

Five minutes of nothing

Every seed starts the same way, and so did Sol. It read up on bushes, wrote a four-line program to grow wood, and ran it for three minutes.

while True:
 harvest()
 plant(Entities.Bush)
 move(North)

The program harvests each bush the moment it plants it, long before anything has grown, so three minutes of running produced no wood at all. Sol’s thinking found the problem straight away:

The fix bounced, though: the game won’t let you edit a program while it runs, so the new version was rejected, and Sol ran the old one for two more fruitless minutes before writing a second program with a different name. The same slip, in the same order, happened on seed 2 and seed 3. GPT-6 Astra wrote the identical four lines on its seeds too. Five minutes out of 360 doesn’t matter much; it’s a nice reminder that a seed fixes the game’s randomness, not the model’s.

One farm, in columns

From about fifteen minutes in, the rest of the run is built around one idea. Instead of a field of one crop, Sol plants the farm in repeating columns: grass left to grow on its own, trees spaced out in a checkerboard (the game rewards trees with room around them), carrots, and later a column of sunflowers for power. Fertilizer on the trees yields weird substance as a by-product. A single program tends all of it, so every pass of the drone feeds five or six resources at once.

On seed 3 that program is multi_econ, written once at 1h38m. Instead of hard-coding the farm, it asks the game how many drones it has and how big the field is, gives each drone its own columns, and sets them off:

clear()
def worker():
	start = get_pos_x()
	while True:
		x = get_pos_x()
		y = get_pos_y()
		if can_harvest():
			harvest()
		if x % 4 == 3:
			if get_ground_type() != Grounds.Soil:
				till()
			plant(Entities.Sunflower)
		elif x % 2 == 0:
			if y % 2 == 0:
				plant(Entities.Tree)
				if num_items(Items.Fertilizer) > 0 and not can_harvest():
					use_item(Items.Fertilizer)
		else:
			if get_ground_type() != Grounds.Soil:
				till()
			plant(Entities.Carrot)
		if get_water() < 0.3:
			use_item(Items.Water)
		move(North)
		if get_pos_y() == 0:
			for i in range(max_drones()):
				move(East)
			if get_pos_x() < start:
				while get_pos_x() != start:
					move(East)
for i in range(max_drones()-1):
	spawn_drone(worker)
	move(East)
worker()

Because it reads the drone count and field size each time, that one program ran in five stints to the end of the game as the farm went from a few drones to sixteen and the field to 32×32. On seeds 1 and 2 Sol did the same thing by rewriting: economy, then economy4, economy16, economy32 and final_economy, each built for the drones it had at the time (economy32 spawns exactly fifteen workers). Both styles worked. Seed 3’s single program didn’t produce the best score (seed 2 did), so this is a difference in how Sol wrote code, not evidence for which way is better.

These stints added more score than anything else on every seed, and Sol seems to have known it. Near the end of seed 1 it went back to the mixed farm instead of another specialist:

Pumpkins first

The specialist resources mostly went smoothly, with one revealing hiccup. On seed 1 at 1h30m, Sol’s first cactus program sorted the field and then crashed when it tried to compare a cactus with a square that had nothing in it. Cactus is planted with pumpkins, and the farm had run out of pumpkins, so some squares were never planted. Sol read the situation correctly: it bought a pumpkin upgrade, farmed pumpkins for fifteen minutes, and then re-ran the same cactus program unchanged for 41,472 cactus. The same crash happened on seed 2.

The reasoning summary from that moment is a small curiosity of its own. Codex shows a summary of the model’s thinking, not the thinking itself, and here the summary wandered off the farm entirely:

What Sol actually did next was farm pumpkins in the game, so whatever it was thinking, the summary didn’t capture it.

Sixteen drones

In the last two hours of every seed, Sol had the full 32×32 farm and sixteen drones, the most the game allows. That is where the economy took off: a single ten-minute stint of economy32 on seed 1 produced 235 million wood. Astra also reached sixteen drones on seed 1, but stopped at eight on seeds 2 and 3, and the difference shows most on seed 2:

Every model on seed 2

When the field got big

The farm’s growth had a cost. Some programs written while the field was smaller kept running when it reached 32×32, and stopped paying.

Dinosaurs are the clearest case. Bones are paid out when the dinosaur hat comes off, and the bones program walks the dinosaur in a loop around the whole field, only taking the hat off once the dinosaur can no longer move. On a smaller field that happened often enough: on seed 1 it produced 81,800 bones in a fifteen-minute stint at 2h18m. On 1,024 squares, as far as the code and the inventory show, it never happened within a stint, so each tail was paid only when a later program changed the hat or cleared the field.

On seed 1, Sol paid about three million cactus for the top dinosaur upgrades at 5h12m, then ran bones for fifteen minutes and eight more. Neither stint showed a bone while it ran; the tails were cashed in by the programs that followed, for 17,424 bones and 1,024. In between it tried shrinking the field, which didn’t take, and its thinking worked out why too late:

With thirteen minutes left, it went back to the mixed farm. On seed 2 the same thing happened at 4h35m: ten minutes of dinosaur farming, cashed in for 8,100 bones when the next program cleared the field (and the cactus program stalled too), and this time Sol wrote a new version that shrinks the field to 16×16 and clears it first:

set_world_size(16)
clear()
while num_items(Items.Cactus) > 0:
	change_hat(Hats.Dinosaur_Hat)
	alive = True
	while alive:

That brought in over a million bones in ten minutes. On seed 3 Sol wrote bones16 straight away when it needed bones on the full field, for 4.2 million. Astra’s late bones stints look just as empty while they run, but its tails were longer when the hat came off: 258,064 bones on seed 3.

What decided the score

The score adds up one term per resource, roughly one point for every tenfold of production, so a few hundred million of something is worth about eight or nine points and a few hundred thousand about five or six. Sol’s column farm put hay, wood, carrots and weird substance into the hundreds of millions or billions on every seed, and those four alone account for around 33–35 of its 72–76 points. That is also where it pulled away from Astra: on seed 2, wood is worth 9.3 points to Sol and 6.9 to Astra.

The rarer resources were never close. Sol produced between 230,000 and 650,000 gold depending on the seed, power and fertilizer stayed small, and bones swung from about 100,000 on seed 1 to 5 million on seed 3, depending largely on how the dinosaur farming went in the last hour. Sol’s choices there decided the gap between its own seeds; its column farm decided the gap to everyone else.