From a Page of Text to a Playable Game
A casual-games studio wants a small 3D game for its website. All it has is a written brief: no design drawings, no reference images, no art. A jelly-like sea sits on a tabletop, with an inhabited island in the middle and a rocket on its launch pad. The player sails a work boat to fetch five rocket parts as the weather turns from a clear morning to a storm at dusk. When the last part arrives, the rocket launches.
Building that by hand is weeks of work for a small team. Someone models the island and the town, someone writes the water and the weather, someone builds the game loop, and someone tests it all. And the studio wants it in one HTML file that runs offline, stays inside a strict GPU budget and exposes a scripted interface, so its QA team can play the game automatically.
So we gave the brief to Gemini 4 Neon in Eigent. In 43 minutes it came back with one 2.4 MB file: a living island with a town, traffic lights, ferries, gulls and aircraft, five kinds of weather plus day and night, and a delivery game that plays from the title screen to the launch.
The Workflow at a Glance
One brief took it from an empty folder to a finished game. Every stage left something we could check.
| Stage | What happened | What it produced |
|---|---|---|
| Read | Read the full brief, spec.json and the asset licence note | The rules: one file, no internet, three.js only, hard numbers and budgets |
| Set up | Found the expected Python environment missing, and installed Playwright and a headless Chromium to test its own work | A browser it could drive |
| Build | Wrote the game as 5 modules (about 204 KB of source) and bundled them with three.js into one file | A 2.27 MB first build |
| Test | Ran its own Playwright QA suite and looked at screenshots of every view | 66 of 68 checks passing, with 2 failures found |
| Polish | Three passes on what it found: draw calls, the water walls, night lighting, the reef, the rocket's flames and smoke | 69 of 69 checks, 0 errors |
| Ship | Audited the file for network access and licences | One offline scene.html, 2.38 MB |
Here's how Gemini 4 Neon did it, including where it fell short and why.
What It Delivered
- A living island. Beaches, hills and a rocky shore, a town of 31 buildings with roads, roundabouts and 8 working traffic lights, 14 cars, ferries between the docks, 16 gulls over the town and 2 aircraft. There's a lighthouse on a pier, and a rocket on a launch pad beside its dock.
- Water and weather. A see-through jelly block with a deep seabed, waves, wakes, caustics and an underwater reef. There are five weathers (clear, cloudy, rain, snow and storm), snow that settles on the land and the roofs, and a day and night cycle with town lights, a moon and stars.
- A complete game. A work boat that reaches 15 m/s in 5 seconds and turns 192° in 3 (the brief asks for 8 m/s and 45°). Five rocket parts are each loaded and delivered. After every delivery a supply plane air-drops the next part, and the weather worsens on the way from 9:00 to 18:00. The jelly sea quakes after the fourth part, and after the fifth the rocket climbs 496 m. An end screen shows the time, the score and a star rating.
- A marketing mode. Add
?exploreto the URL for a free camera, weather buttons, a time-of-day slider and six preset views. - A QA interface.
window.sceneAPIandwindow.gamelet a script step the simulation frame by frame, move the camera, teleport the boat and read the state of every car, boat and aircraft. That's how the grader played the whole game, and how we filmed the video.
The Setup
- Eigent 1.0.8, in a single session with Single Agent mode, Gemini 4 Neon as the model and thinking effort Medium.
- A local folder holding the task:
PROMPT.md(the full brief), and the read-onlyinput_files/with three.js 0.186.1,spec.json(coordinates, budgets and hard numbers) and the asset licence note. - On its own. Nobody answered questions or stepped in. Every decision was the agent's own.
- Offline. The finished file must make no network requests. Every texture, sound and shader has to be generated in code.
- Hard limits. At most 450 draw calls, 3 million triangles and 400 MB of GPU memory on an overview frame. The brief also fixes the handling numbers, the timing of the air-drops, the size of the quake and the height of the launch.
How Gemini 4 Neon Worked
Gemini 4 Neon worked through the task as a single agent. Times are minutes from the start of the run.
- Orientation (0:00–1:00). It read
PROMPT.md,spec.jsonand the licence note, then checked which tools the machine had: Python, Node and a browser. - A pause that wasn't the agent's (1:00–6:00). The workspace held 513 files against Eigent's 500-file checkpoint limit, so Eigent stopped and asked a person to continue. About 5 minutes of the run were spent waiting on that click.
- Setting up its own test bench (6:00–10:00). The Python environment the brief described hadn't been set up, so it installed Playwright and Chromium itself, to test the game the way the QA team would. It also inspected the three.js files, to bundle them cleanly into one file.
- Writing the game (10:00–20:00). It wrote five modules: terrain and noise, then water, sky and weather, then the town, the vegetation, the landmarks and the traffic, and finally the game loop, the QA interface and the UI. At 20:06 it bundled everything into a 2.27 MB single file and checked the syntax with Node.
- Testing it and looking at it (21:00–27:00). Its own Playwright suite passed 66 of 68 checks. It caught two failures: 865 draw calls against the 450 budget, and a boat that only reached 3.79 m/s against the brief's 8. Then it opened and reviewed 12 screenshots of its own game, from the island overview to the victory screen.
- Three polish passes (27:00–43:00). It batched draw calls, fixed how the water walls sort, corrected the terrain colours, and rebuilt the night lighting, the underwater reef and the rocket's launch. After the rewrite it was down to 149 draw calls with every check green. Two more passes added greener hills, brighter water, coral and kelp, rocket flames and billowing smoke, and fixed a culling bug that had hidden the smoke. It checked each pass by eye, 27 screenshots in all.
- Shipping (43:24). It ran a final offline and licence audit and delivered: 69 of 69 checks, 0 errors.
In all: 73 model calls and 86 tool calls in 43 minutes 36 seconds, with no human input beyond the checkpoint click.
The Result
One file landed in the output folder: output/scene.html, 2.38 MB, with three.js r186 inlined and its MIT notice kept. Open it and it plays. Add ?explore and it becomes a showroom.
| Measured on the delivered file | Result | Limit or target |
|---|---|---|
| Draw calls, overview frame | 145 | ≤ 450 |
| Triangles | 355 K | ≤ 3 M |
| GPU memory | 49 MB | ≤ 400 MB |
| Network or local-file requests | 0 | 0 |
| Console errors | 0 | 0 |
| Top speed after 5 s | 15 m/s | ≥ 8 m/s |
| Turn in 3 s | 192° | ≥ 45° |
| Deliveries completed by script | 5 of 5, then launch and end screen | 5 |
| Rocket climb | 496 m | ≥ 50 m |
| Ready in headless Chromium with software rendering | 17 s | – |
How It Scored
We scored the file with the task's own evidence collector, in the task's own Docker image, rendering with SwiftShader on 2 CPUs. A script drives the page, measures everything and decides each of 91 binary criteria from those measurements. 74 criteria award 352 points, and 17 penalties can take away 99. We evaluated each criterion's rule on the measurements and didn't run an LLM judge, so this is the programmatic score. The same evaluation reproduces all three earlier official scores on this task exactly.
| Group | Points |
|---|---|
| Instruction following | 21 / 21 |
| File validity and assets | 3 / 3 |
| Engineering and organisation | 6 / 6 |
| Structure and task correctness | 122 / 167 |
| Visual quality and aesthetics | 91 / 155 |
| Penalties | −31 (5 of 17 triggered) |
| Overall | 0.602 (212 of 352 points, 59 of 74 criteria) |
Without the five penalties, the same file scores 0.69.
We also audited the run itself, through the agent's tool calls.
| Check | What we found |
|---|---|
| No web research | There were no web search, browser or page-fetch calls. |
| Downloads for testing only | It pip-installed Playwright and downloaded Chromium to test its own game, because the environment the brief expected hadn't been set up. The game file itself makes no requests. |
| It tested its own work | It wrote and ran its own 69-check QA suite, and reviewed 27 screenshots. |
Where It Fell Short, and Why
Gemini 4 Neon built everything the brief asked for, and the game plays end to end. The points it lost are in the hardest layer of realism, and in a few traffic and camera details.
- Water that truly moves and bends light. The grader couldn't confirm real waves (its test slab rendered under the water layer), refraction (a block on the seabed didn't distort), or a wake that widens with speed. The caustics were there but too sparse, and the shore surf wasn't bright or animated enough.
- Things that should move. The trees don't sway, and the idle boat drifted only 0.18 m in the storm, where the grader wanted 0.5 m.
- Details of the air-drops and the launch. 3 of the 4 drops were in place within 40 seconds, and the drop into open sea showed no ripple ring. At 1 second after liftoff the flame was too small in the grader's frame.
- Snow and materials. Snow covered 91% of the land and 87% of the roofs, but only 19% of the tree tops. Cars and the rocket use mostly non-reflective materials.
- Five penalties (−31). Two cars came within 2 m of each other, and opposite-direction cars sat too close to the centre line. 7% of driven road points sat under grass. The camera's turn rate jumped 29°/s against an 8°/s limit. And the supply plane dipped below the surface in 8 samples.
It stayed clean on the hard penalties: the boat never jitters, nothing flickers, pausing is safe, the part never clips the plane, there are no caustics on the deck, and there are no console errors.
This was also a single run at thinking effort Medium. Scores on a task this long can vary from run to run.
What We Learned
- It builds whole products, not snippets. From one page of text: a world, a game, a UI, a marketing mode and a QA interface, in one file.
- Give it a way to test, and it tests. When the environment was missing it set up its own browser, wrote its own QA suite, and caught its own failures before handing over.
- It looks at what it builds. It reviewed its screenshots like a designer and fixed what it saw: the water walls, the night lighting, the reef and the launch plume.
- Hard numbers are easy to hit when they're written down. Every handling, budget and API number in the brief passed. What's left is realism no spec line pins down: water that bends light, trees that sway, traffic that never touches.
A brief doesn't have to wait for a team. Hand it to Gemini 4 Neon in Eigent, then play the result.
Run It Yourself
- Download the task package (
game-threejs-jelly-sea-express.zip) and unzip it into an empty folder. It containsPROMPT.mdand anenvironment/folder with the read-only input files. - Set up the input folder. Copy
environment/input_files/into your working folder asinput_files/, and create an emptyoutput/folder beside it. - Open Eigent and start a new project in a Space linked to that working folder.
- Choose Single Agent mode, select Gemini 4 Neon as the model, and set thinking effort to Medium.
- Paste the brief. In
PROMPT.md, copy Version B (Eigent), the text between its two---lines. Change the folder paths to your own, then send it as your first message. Don't add any hints. - Let it run. Don't answer questions or step in. Expect about 45 minutes. If Eigent stops at its workspace checkpoint limit, click to continue; that's Eigent, not the agent.
- Play the result. Open
output/scene.htmlin a browser. Press Start, then sail with W A S D (Esc pauses). Openscene.html?explorefor the free camera, the weather buttons, the time slider and the preset views. - Check the budgets and the API. In the browser console,
window.sceneAPIandwindow.gameshould both exist.window.sceneAPI.renderer.info.render.callson the overview should stay under 450. - Audit the run. Turn on Dev mode and look through the tool calls. You should find no web search or fetch calls. Package installs, if any, should only be for testing tools.
Credits: built with Gemini 4 Neon and Eigent.








