Help us find out
what happens next.
We're looking for Godot studios to be design partners, and for investors who want the technical brief and the draft paper.
We build AI that predicts how a world responds to action, then checks every prediction against a real simulation engine. It's efficient enough to run on a single GPU, not a datacenter.
We combine learned models1, simulation engines2, and low-level systems optimization3 to make interactive environment modeling4 practical on constrained hardware5.
A neural network that has watched a world long enough to guess its next moment, quickly. Like any intuition, it's fast and it's sometimes wrong, and the errors build on each other.
Game engines and physics simulators know the true state of the world: where everything is and what's possible. We let the model imagine, then check it against the engine and snap it back when it wanders.
Long predictions eat memory. A 14B-parameter model can generate over 200 GB of attention cache per minute. We write custom kernels and page that memory across GPU, RAM, and disk, much like an operating system does.
Not generating a pretty video. Answering a question about cause and effect: given this world and this action, what comes next, and what comes after that?
Our first target is one 16 GB GPU. We adapt open models with small add-ons instead of spending thousands of GPU-days training from scratch.
That's the whole company. Everything below is how we do it, and where we're pointing it first.
Ask a pure video model to imagine a game for a minute and the world slowly forgets itself. Platforms wander, blocks melt, and the player sinks through the floor. We let the model imagine, then re-anchor it to the engine's real state before small errors compound into fiction.
We start from open pretrained checkpoints and attach compact task adapters, so one base model can learn many environments without retraining from zero.
The source engine is the oracle. Predictions are periodically re-anchored to true state, so outputs stay physically consistent and every result is auditable.
Rollouts generate memory faster than a GPU can hold it. Our runtime streams state across GPU, host RAM, and NVMe, and recalls it before it's needed.
Our first job for this technology: hand us a Godot build and autonomous agents explore it, level by level, edge case by edge case. You get back failures you can reproduce, each with the action trace, the state snapshot, and the video.
Games are complete worlds with rules, physics, and failure states, and they ship on deadlines with too little testing.
It's open source, so we can instrument it all the way down. The ecosystem is growing fast and its testing tools haven't caught up.
Every run produces action, state, and failure data that makes the next model better at finding what breaks.
Task adapter that specializes a shared 2.6 GB base model. No duplicated weights per task.
H200 GPU-days that published benchmarks cite for pretraining from scratch. We adapt instead.
Memory hierarchy (GPU → RAM → NVMe) managed continuously during long rollouts.
The first hardware target. If it runs here, it runs anywhere.
We're looking for Godot studios to be design partners, and for investors who want the technical brief and the draft paper.