Please read first: this entry runs on mock players
I'm in Sri Lanka, and Nebius Token Factory doesn't accept cards issued here. Nebius staff confirmed it on the hackathon Discord on 28 and 29 October, and nothing changed before the deadline, so I never got an API key. Everything in the demo and the video runs on mock players, and the app labels them on screen. The Nemotron and Tavily calls are written and covered by tests with a mocked API, but none of them has ever answered a live request. I understand this may make the entry ineligible for the main prizes. I'm submitting it anyway because the work is real, and setting one environment variable (NEBIUS_API_KEY) switches it to Token Factory.
Inspiration
I make small mobile and web games at StarFun Games. Players always find the difficulty spike before I do, usually in a one-star review, because I can't play my own level like a stranger. Strangers are hard to find when you work alone, and Google Play makes new personal developer accounts run a closed test with at least 12 testers for 14 days before they can publish. I wanted a first round of strangers I could call up in a minute or two, before spending real testers on a broken level.
What it does
Ghostplay sends nine "ghosts" into a level: three casual players, three core players and three experts. Each ghost is meant to be an NVIDIA Nemotron model, with the model's size as the player's skill. A small, fast model skims and rushes like a casual player. Super, with a reasoning budget, plans ahead and times the spikes.
You watch them play, then get:
- heatmaps of deaths, visits and wall bumps, and a replay you can scrub turn by turn;
- completion for each type of player ("Casual: 0 of 3");
- a first-glance check, where a vision model looks at a picture of the level like a new player;
- a genre lens, where Tavily searches for what players and designers say about the problems the swarm hit;
- a design report with evidence, tile coordinates and a patch of up to six tiles.
A breadth-first solver has to prove the patched level can still be finished before you can apply the patch. Then the same nine ghosts replay it, and you see completion before and after. You can also paint your own level and run the whole loop on it.
In mock mode, the players follow the solver's route with random mistakes shaped by their type, and the mock report clears the tile where the most players died.
How I built it
- Token Factory as the only model provider. Every call goes to the OpenAI-compatible endpoint through about 60 lines of plain
fetch(lib/nebius.js). At startup the server readsGET /v1/modelsand picks the first model per role that Token Factory actually serves. Two Nemotron 3 serverless IDs retire on 9 November, before judging, so nothing is hard-coded to them. - Models and roles:
nvidia/Nemotron-3-Nano-Omnifor casual players,nvidia/Nemotron-3_5-Lightningfor core,nvidia/Nemotron-3.5-Super-VLfor experts (thinking on, 384-token reasoning budget) and for the vision check,nvidia/Nemotron-3-Ultra-550b-a55bfor the report (2,048-token reasoning budget, strict JSON schema). - Built around the rate limit. My first design made about 480 calls per run, which is eight minutes at the default 60 requests a minute. Now a ghost looks at the board and commits to its next one to four moves, as people do between glances, and a mock run takes about 90 calls. The browser paces calls, reads the
x-ratelimit-remaining-requestsheader and backs off on 429s. - Safe for a public demo. Limits count runs, so a judge's run is never cut off halfway. Every input is validated on the server, and the report is timed to fit Vercel's 60-second function limit.
- One deterministic engine in plain JavaScript runs the rules in the browser, on the server and in the solver, so a move means the same thing everywhere.
- React and Vite on the front end, Vercel serverless functions, no database, 26 automated tests.
Challenges I ran into
- No API key. Token Factory needs a Visa or Mastercard from a supported country, and Sri Lankan cards are refused. I built the whole product against clearly labelled mock players so every screen could be finished and tested.
- The rate limit. Planning several moves per call cut the calls per run by about five times.
- Model IDs. The catalog lists
Nemotron-3_5-Lightning(underscore) next toNemotron-3.5-Super-VL(dot), and two models retire mid-judging, so the app discovers models at runtime. - Solver cost. A hostile custom level could make the server solver take 6 seconds and 1.4 GB. I capped levels at eight crates, gave each solve a fixed budget that can stop mid-search, and made it say "too complex to check" instead of "impossible" when the budget runs out. The worst level I could build now takes under half a second, and searching first for routes that never push a crate cut an open room full of crates from 1 second to 7 ms.
Accomplishments that I'm proud of
- A patch never reaches the board unless the solver can finish the patched level, and the same players replay it.
- The whole loop (play, heatmaps, report, patch, re-test, before and after) works end to end, with one button that always shows the next step.
- An independent code review found eight bugs, and all eight are fixed with regression tests.
What I learned
Design for the limits you can see from the docs before you write the agent loop. Token Factory's rate-limit page changed the shape of the whole product. And make offline mocks first-class: they let me build and test everything when the real API was out of reach.
What's next for Ghostplay
- Run it on real Nemotron models as soon as I can get a key, and publish the numbers.
- Import Tiled and Unity tilemaps so it plays real game levels.
- Batch swarms of hundreds of ghosts on Nebius Serverless Jobs for solid completion rates.
Limitations
These are language models playing from a text view, so they approximate players and can't stand in for a real playtest. Ghostplay measures difficulty, clarity and softlocks. It can't tell you whether a level is fun, and it only reads its own grid format today. This submission has never run on a real model.
Built With
- javascript
- nebius-token-factory
- node.js
- nvidia-nemotron
- react
- tavily
- vercel
- vite