Before this ever reaches a formal release, I want other game developers to put it through real conditions — not a polished trailer, not a curated showcase, but an honest stress test of what it can and can’t actually do inside a web build.

Below is an architectural breakdown of what the engine handles today, where its current limits are, and a link to play the live web sandbox to see the AI in motion.

What the Engine Actually Is
Stop relying on predictable state machines or massive, hard-coded logic loops that bog down your game loop. This project is a lightweight, external neural network engine designed to serve as an independent behavioral brain for game characters.

Instead of executing static scripts, the NPCs gain true multimodal agency — interpreting their surroundings, executing movement, and communicating dynamically based on game variables. The character isn’t following a decision tree you wrote six months ago; it’s making a fresh inference based on what’s actually happening in the world right now.

How It Works Under the Hood
Unlike standard local assets that add thousands of lines of code directly to your project, this operates as a dedicated API runtime. You integrate a lightweight wrapper into your game engine, which handles the secure connection between your game variables and the core neural network engine. Your project stays clean. The heavy lifting happens off to the side, freeing up local CPU cycles.

Three things are happening simultaneously:

Environmental perception: The game pipes spatial coordinate and entity data through the API. The core neural network processes this data to give the NPC an awareness of its surroundings, allowing it to track player positioning and navigate around obstacles in real time.

Dual-control navigation matrix: The character’s physical movement can be driven dynamically through custom backend scripts, or shifted on the fly to directly interpret and execute live player instructions.

Modular communication stack: The underlying engine can process inputs and return outputs flexibly depending on the game’s layout. It can parse text inputs to drive UI dialogue boxes, or process live player microphone audio to generate voice-to-voice loops.

What This Is Not (The Current Limitations)
I’d rather undersell this than oversell it, because the entire point of releasing this early prototype is to get honest technical feedback.

It is not a finished product. This is a raw prototype. Some things will break. Some dialogue will come out stranger than expected. Some edge cases in the physics setup will expose behavior I haven't seen yet.

It is not running on dedicated GPU clusters yet. The current build is validated on CPU-only hosting. This means response latency is a real, active area of tuning — not a solved problem. If you test this expecting console-AAA instant response times under heavy concurrent NPC load, you will quickly find the edges of what CPU inference can currently do.

Test the Live Prototype Now
I have embedded the early pipeline into a basic low-poly web sandbox so you can test the sync, latency, and movement routines directly in your browser.

I’m looking for eyes from other programmers to see how it holds up. Drop into the sandbox, try to throw unusual inputs at it, try to make the pathing fail, and let me know how it handles your commands!