How to Build Self-Evolving 3D Games With Jev AI

Make a folder called jev-worlds and work inside it.
Write a tiny Node server called server.mjs, with no npm packages, on port 8088.
It does two things:
1. It serves the files in this folder as a website.
2. It has one route, POST /jev, that takes { state, questions } and forwards it to Jev, the free decision model, at https://opencode.ai/zen/v1/systemone with the body { model: "jev-1.13-free", state, questions }. No API key is needed. It returns Jev's answer to the browser.
Retry twice if Jev is slow, and save every decision to decisions.jsonl.
Then test it for real: send the state "A player keeps sniping from far away" with one choice question, "counter", with the options rushers, shielded and swarm. Show me Jev's answer.

Build a 3D arena shooter in evolve/index.html and evolve/game.js, using three.js from a CDN with an importmap.
The world is a floating island made of hex tiles, with a sky gradient, fog, floating rocks in the distance and drifting particles.
The player is a small hover drone with a spinning glowing ring. WASD moves it, it aims at the mouse and fires on its own, and Space dashes.
Enemies walk in from the edge in waves. When a wave is dead, show a big GENERATION 2 banner and start the next wave.
Add bloom, soft shadows and a health bar. Make it look premium, not like a pile of boxes.

Make evolve/creatures.js. Every enemy is built from a genome:
- movement: scuttle (six legs), hop (spring legs), glide (wings), or burrow (a drill that tunnels underground where it can't be shot)
- armor: none, a front shell that blocks shots from the front, spikes, or split (it splits into two small ones when killed)
- attack: bite, acid spit from range, or explode up close
- size 0 to 4 and speed 0 to 4
Every gene must change how the creature LOOKS and how it BEHAVES.
Spawn each wave from one genome, and add evolve/lab.html that shows eight different genomes side by side on turntables.

Make evolve/brain.js. After every wave, call POST /jev ONCE with 8 questions:
- movement, armor and attack: choice questions, where each option's description says which kind of player it beats
- size and speed: score questions with 5 labels (the criteria for a score must be a list)
- the next world: meadow (slowly heals the player), ember (lava vents erupt), frost (slippery ice) or neon (dark)
- the arena layout: pillars rise, the outer edge crumbles, or open
- one gift for the player: triple shot, faster fire, shield, faster dash or piercing shots
The state is plain English that describes how the player just fought.
If Jev doesn't answer within 7 seconds, pick at random and label it "local" on screen, so it's never passed off as Jev.

While the player fights, measure: how far away they usually are when they kill, how close the nearest enemy gets, which way they circle the arena and how often, how long they stand still, how long they spend near the edge, their accuracy, how many shots bounced off shells, and how much damage each attack did to them.
Write all of that into the plain-English state for Jev.
When a wave ends:
1. Show "Jev is studying how you fought…" with a spinning DNA helix.
2. Deal eight cards, one per decision, each with how sure Jev was as a %.
3. Morph the world into the new biome in a wave that rolls out from the centre.
4. Apply the arena change and the gift, then hatch the new generation from the edge.

Add an autopilot: ?bot=sniper keeps its distance, ?bot=brawler fights up close, ?bot=circler runs in circles.
Then playtest it yourself with headless Chrome, two minutes per style, and prove three things:
1. The game never freezes.
2. Jev designs different enemies for different styles.
3. No wave can get stuck: if a wave lasts 30 seconds, shells crack and burrowers come up.
Fix anything that breaks, and show me what Jev picked for each style.

Build planet/index.html and planet/planet.js: a low-poly 3D planet floating in space, with three.js.
Faceted terrain from noise, a water sphere, a cloud layer, a glowing atmosphere, stars and a nebula.
The planet can change in all of these ways: raise mountains, carve oceans, grow forests (instanced trees), spread deserts, freeze or melt ice, build glowing cities (instanced buildings), erupt volcanoes with lava and smoke, take a meteor hit that leaves a crater, get storms with lightning, and gain rings and moons.
Every change animates over about two seconds. Nothing snaps.

Add a text box, a microphone button (Web Speech API) and a row of example phrases.
When I say something, call POST /jev ONCE with 6 questions:
1. is_command (noul): does the speaker want something to happen to the planet?
2. the main change: a choice from the list of planet changes
3. a second change, or none
4. where: here, north, south, east, west, equator or everywhere, measured from where the camera is looking
5. how big: a score with 5 labels
6. the sky colour: keep, blue, sunset, toxic, violet or crimson
If is_command is under 0.5, change nothing and say "not a planet command". Otherwise fly the camera to the spot and apply the change.
Show every decision with its % in a panel.

Add a "Let it evolve on its own" switch.
Every 16 seconds with no input, send Jev the planet's stats (land, ocean, forest, desert, ice, cities, temperature, moons), its age, and the last six events.
Ask what nature does next (eruption, mountains, forest, desert, ice age, warming, sea rise, cities grow, meteor or storm), where, and how big.
Apply it, add about 50 million years to the age, and show a big title for the event.