demos

A spore given a task and a complex application, with no plugin. For Blender, a small script opens a socket inside the app, and the spore writes its own client from one paragraph of protocol. Godot runs from the command line, so the spore runs it itself. The prompts and the data are public. What they show, and what they don’t, is further down.

One prompt. 18 attempts. 28 minutes. Nobody touched it.

a chain reaction in Blender

The prompt asked for a machine that runs by itself under Blender’s physics. A marble rolls down a ramp and hits a curved line of dominoes, and the last domino releases a second ball into a cup.

It also said how to judge the result: by numbers, not by eye. After each simulation the spore read every object’s position, frame by frame. It passed only when every domino had fallen, in order, and the second ball was at rest in the cup. When it failed, the numbers showed where the chain broke, and the spore changed the scene and ran it again.

Blender with its default cube, beside a terminal showing the prompt — **the start.** The default cube, and the prompt.

Dominoes half fallen and scattered in Blender, beside the code the spore is writing — **3 minutes in, attempt 2.** The chain stops at domino 10, and the ball’s lane has already knocked domino 16 away.

Dominoes collapsed in Blender, beside the spore adding a hinge — **15 minutes in, attempt 14.** The dominoes collapse backwards from the far end. The spore tries a hinge on the last one.

Every domino down and the ball in the cup, beside the spore’s table of attempts — **28 minutes in, attempt 18.** Every domino down, in order, and the ball in the cup.

what broke

1	The chute cut through the last domino. The chain ran backwards and threw the ball away.
5–7	Dominoes right, but the fallen gate blocked the ball. It thinned the gate twice, then redesigned the lane.
9	The ball was deflected sideways and left the stage. It added a cup on the measured path.
12–16	The dominoes collapsed backwards. It tried hinges for five attempts, then removed them.
17	Right order and the ball in the cup, but still rolling. It raised the damping.
18	Passed.

All 18 attempts are in the repository.

check it yourself

The repository holds the passing run’s frame-by-frame data and a short script that recomputes every claim above. It needs Python, and neither Blender nor a model.

It also lists what the spore’s own report left out: an unreported solver change, a generous idea of “at rest”, a repeated attempt, and a cup it enlarged along the way. This is one run. A new run builds a different machine, and may fail.

The run used gpt-6.1-sol on a ChatGPT plan, so it has no metered cost, on a laptop with integrated graphics.

a lighthouse, improved by looking

A shorter demo, about 5 minutes. The spore builds a scene, renders it, looks at the render, says what is wrong and fixes it. Four versions later the clipped finial, the angular sea and the fake shadow were gone. Two flaws stayed in, and the write-up says which.

First render: a low-poly lighthouse on an islet, with a large sun and a dashed foam ring — first render

Fourth render: the same lighthouse, reframed, with a distant sun and a flat horizon — fourth render

a game in Godot

Kêr-Is is a resource game on the Breton legend of the drowned city of Ys. You hold the city through 12 tides with stone, grain and gold. The sea gate brings trade and floods. A stranger offers gifts against hidden damage. If you lose, the city sinks and its bells keep ringing under the water.

The prompts set the rules and the targets. The spore wrote the code, drew everything in code, synthesised the sound and chose every number. There is no bridge here: all of it happened inside spore’s sandbox.

Two prompts. 10 balance attempts. 75 minutes. Nobody edited the game.

Play it in your browser, a 10 MB download.

balanced by bots

Bots played the game over 200 seeds, in 118 policies. They include one that does nothing, one that takes every risk, all 110 fixed strategies, a steward that plays from what a player can see, and a seer that knows the future. When a target failed, the spore found out why from the numbers, changed the game and ran them again.

The first turn met its seven targets. The data then showed what those targets didn’t cover, so a second prompt added three more and sent the spore back. It met all ten.

the seeds	24 of the 200 seeds were won by no policy. The spore wrote a search over the full future, which won all 200 on unchanged rules.
the stranger	Always accepting his bargains beat judging each offer, 55% to 44.5%. The spore gave him a voice to read, and judging now wins 60%.
the ending	The result dialog hid the drowned city. Now the city stays lit, and the result waits for 8 seconds of bells.

Low tide in Kêr-Is: the city behind its dike, workers assigned, and the stranger's offer in a wavering voice — low tide, and a wavering voice

Tide 6 of a greedy run: all three districts lost, with the sea in the streets — a greedy bot’s last tide

The repository holds the game, both prompts, every policy’s result on every seed, and a script that recomputes all ten targets with Python alone.

The spore tuned steward’s rule for the stranger on the same 200 seeds it was scored on, so we also ran 2,000 seeds it never saw. Steward won 60.8%, against 54.6% always accepting and 47.2% never accepting.

Both turns used gpt-6.1-sol on a ChatGPT plan, so they have no metered cost. This is one game, made once. A new run makes a different game, and may fail.

what these demos show

A spore working by itself for a long time, on complex work in several phases, from one prompt or a few. It builds, measures, finds what failed and carries on until the result holds. The chain reaction took 28 minutes, and the game 75 minutes over two turns.

what they don’t show

Finished work. A real game or a real Blender production would take more turns and a more detailed scope.
The intelligence of a model. These demos are about spore, not the model behind it. A different model brings different intelligence to the same prompt.

run one

npm install -g @rhizogrip/spore-clispore setup

Then follow the demo’s README. For Blender, start the app with the bridge, and paste its paragraph and the task to a spore. The Godot demo needs no bridge.

The bridge steps outside spore’s confinement, by design. Code sent through it runs inside the app, as your user. You hand the agent that way out when you give it the token, which is fine for a demo on your own machine.

In production, run the app in a sandbox of its own, with only the files it needs, and give the bridge to the runner as a source. The agent then asks for it by name and never holds its address or its token. These demo bridges would need an HTTP front for that. What confinement covers is on the security page.