Interactive world models on app.nz: GPU sessions, ABot-World, and ARDY

Most GPU inference is a vending machine: request in, artifact out. World models broke that shape for us. ABot-World generates 720p video at 16 FPS in response to your keystrokes, with no fixed rollout length. ARDY steers a humanoid at 20+ FPS while you stream new text prompts mid-motion. Neither fits a predict() call — they need a GPU that stays up, holds state, and talks over a socket.

So we built sessions into the cog platform, and shipped both models as open-source cogs you can run on app.nz today:

• /spaces/abot-world — walk through a generated world with WASD
• /spaces/ardy — steer a character with prompts, waypoints, and keys

The session protocol

A session cog is a normal cog container with one extra surface: a websocket at GET /session next to the standard /predictions endpoint. The platform adds three routes:

# boot (or reuse) the model's GPU pod and hold it
curl -X POST https://app.nz/api/cogs/{model_id}/sessions -H "Authorization: Bearer $APP_NZ_KEY"
# -> {"session":{"id":"...","status":"starting","wsUrl":"/ws/cogs/sessions/..."}}

# stream: actions in, frames out
wss://app.nz/ws/cogs/sessions/{session_id}

# close (idle timeout and a hard cap also close it for you)
curl -X DELETE https://app.nz/api/cogs/sessions/{session_id}

Billing is wall-clock GPU-seconds at the machine's listed rate, settled when the session closes. You never pay for a forgotten tab: sessions idle out after the model's idle window, and a hard cap (default two hours) backstops everything. The spend shows up in the same hardware rollup as predictions.

The protocol is deliberately boring. ABot-World sends binary webp frames; ARDY sends JSON pose frames (16 joints + bone pairs — a few hundred bytes at 20 FPS, cheap enough to run over anything and trivial to retarget onto a three.js skeleton or a VRM avatar). The platform doesn't care: it proxies text and binary alike and stamps activity for the idle reaper.

ZeroGPU-style UX

Click a space, watch the pod boot (cold starts show live progress), then play. The spaces pages create the cog from its template on first use — one click from "never heard of it" to driving a world model, with the per-minute price on the button.

Both cogs run a simulated backend on CPU — a procedural world for ABot, a procedural gait for ARDY — so the repos test end-to-end in CI without weights, demos work anywhere, and the GPU wiring is an isolated contribution surface (model.py::AbotWorld / model.py::ArdyMotion). The GPU images bake weights at build time; pods never download at request time.

• github.com/lee101/appnz-abot-world
• github.com/lee101/appnz-ardy

Every example in every README is a real run

Alongside the world models we shipped a harness that keeps the whole open-cog fleet honest: it boots each cog through the real platform path — actual RunPod cold start, actual billing — runs canonical inputs, and writes the outputs back into each repo's README.

The numbers it produced this week: background removal ran end-to-end in 64 seconds wall (1.4s inference) and billed $0.0001. That includes pod scheduling, image pull, model load, and the prediction itself. The same harness covers the upscaler, vectorizer, voxel-3d, depth-vfx, and inpainting cogs — and doubles as our nightly RunPod integration test, because an example that stops regenerating is an outage report.

Where this goes

Sessions generalize past world models: anything that holds GPU state behind a socket — live diffusion streams, collaborative editors, game servers — is now a deployable app.nz workload with per-second billing. The open cog list keeps growing (background removal, upscaling, stems, inpainting, vectorization, voxel meshes, depth VFX, two interactive world models, with frame interpolation and depth-anything next), each one a small MIT adapter you can run without us. That's the point: the platform is the convenient way to run them, not the only way.