The Binary Kinetic Engine holds the world state and decides what happens. The language model only writes the prose describing it. Each turn the engine sends a snapshot of what is relevant to the player. Never the whole history. Cost per turn stays flat however long the session runs, and the model cannot contradict what the world already recorded.
A blank page, a back catalogue, or an AI NPC that didn't quite work, the same engine does all three.
A tireless DM that tracks every choice, consequence, and location across sessions. Remembers the tavern you robbed and the barkeep who still holds the grudge.
Continuity added to an existing game over the same REST contract. NPCs remember past encounters, hold motivations, and evolve based on what the player actually did, not scripted triggers.
Protagonists and companions that grow across an entire campaign, staying consistent whether the story runs ten hours or ten months.
Factions, economies, and events that progress whether or not the player is watching. The engine holds the state; the LLM surfaces it.
No fixed script. Player actions become canonical history, building stories unique to each playthrough.
The LLM enriches items and locations on the fly: a window becomes stained glass, a blade becomes notched and rust-flecked. The engine remembers those attributes and the actions taken on them, so a window broken once stays broken, and an item described once keeps its color, material, and history every time it's seen again.
Pull a book from the shelf and the LLM gives it a life of its own: a title, an author, a story within the story. The engine keeps that invention consistent and in scope, so the detail enriches the world without rewriting it or hijacking the plot. Freedom to improvise, with the discipline to stay in bounds.
A world-state service that existing VTT platforms and studios call over REST. They keep their interface and IP, and the engine supplies the persistent world underneath.
Integration is a REST API plus one WebSocket. Your client sends a player action and gets back a resolved outcome with the narration attached. That is ordinary backend work, so a team that has shipped a web service can wire it up without AI specialists.
Same engine underneath: characters that stay in canon, can't break the rules, and cost a flat, predictable amount per turn.
Drop a language model into a game and three failures show up immediately. They are engineering problems, and they are exactly what the Binary Kinetic Engine is built to remove.
Grants items it shouldn't, forgets a death, contradicts yesterday's conversation. The model treats canon as a suggestion.
As sessions run long, the context window overflows and the AI loses the thread, state silently degrades.
The more a player talks, the bigger every prompt gets, your most loyal players become your most expensive.
Every outcome that matters, a hit, a lock, a persuasion, a theft, is resolved deterministically on the server before the language model is ever called. The AI receives an already-decided result and writes the prose around it.
Because outcomes are decided outside the model, a studio's own systems, combat, economy, physics, quest and character state, can serve as the authoritative source of truth that decides what happened to characters in the world, then hand the engine a result for the AI to bring to life. You reuse the mechanics you already shipped; the engine adds the living-narrative and NPC layer on top. That is what makes it practical to breathe new life into an existing catalogue, not just power new titles.
Architecturally supported · integration pathEvery NPC carries a relationship ledger. They remember nine kinds of behaviour, and that memory shifts how hard they are to win over next time. Because every social outcome is decided by the dice on the server before the model writes a word, there is no prompt that jailbreaks a hostile NPC into helping you.
Nine memory categories, kindness, betrayal, promise_kept, promise_broken, insult, combat_ally, combat_enemy, business, romance, accrue in the ledger and bias future social difficulty.
Social play is mechanical: 6 approaches × 14 personality types × 5 disposition tiers, resolved by d20 + mods vs DC into 5 outcome tiers. The model narrates the result it is handed, it never decides it.
A 5-lane knowledge pre-gate shapes what an NPC may reveal. Secrets stay withheld until trust is earned, gated by state, not by how the player phrases the question.
Mistreat an NPC and a live emergent-adversary flag can mark it as a foe with a grudge. A structured antagonist model to drive longer scheming arcs is scoped as a framework on top.
Each NPC's voice_id rides inside the stateless ledger, so a cast keeps distinct voices at zero server audio state. Streaming TTS runs client-side today; a premium voice route is on the roadmap.
Disposition shifts with logged memories; a colder NPC means a higher DC on the dice. No phrasing skips the check.
Dice decide, AI describes, never make mechanical decisions.Live system prompt, Binary Kinetic Engine
Game state is reconstructed deterministically by replaying a transaction ledger, the cause, not the narrative. The engine records "player attacked guard · SUCCESS · 6 dmg," then rebuilds the world from those facts. The model's words are never the source of truth.
Tell the AI the player has the sword; the engine says he doesn't; the engine wins.
Engine-owned fields, health, disposition, identity, are hard-stripped from any AI proposal before it can mutate state.
server/index.js:4471-4518Every saved game is SHA-256 checksum-verified on load. Corruption is backed up to a timestamped file and flagged, never silently overwritten.
transaction-log.js:92-151State is reconstructed each turn through an engine-owned whitelist, so AI changes can't resurrect vitals, disposition, or identity, even on replay.
reconstructor.js:129Honest scope: these layers contain malformed, rule-violating, and out-of-bounds output, they drop or clamp bad values at the boundary. They are structural, rule, and integrity checks; not a semantic fact-checker that detects whether the AI's prose is true.
Every other approach pays for engagement: the longer a session runs, the bigger each prompt gets. The Binary Kinetic Engine doesn't. The per-turn payload is governed by how rich your world is, and then it stays put. It does not grow as the session runs.
Session length moves only the stateful bar. Measured across 10 live gaming sessions, the per-turn context packet held to ~6-50 KB, set by how many richly-detailed entities are near the player, not by session length. The same 138-turn game ranged from 6 KB to 32 KB purely by where the player stood, because recent history is hard-capped at five transactions in code (reproducible live on the running stack). Leaner worlds sit lower; the design ceiling is ~64 KB (measured unfiltered upper bound ~62 KB), reached only with entity-locality filtering disabled. This is per-request payload + token predictability, not a reduction in the underlying LLM inference bill, which is provider-side. Uptime is also decoupled from your LLM vendor via a live deterministic template fallback.
Independent research shows even frontier models lose accuracy as the prompt grows, the effect researchers call "context rot." Keeping the per-turn payload small and locked is what holds the Binary Kinetic Engine in the model's low-error zone. Drag the context size and watch the error climb.
BKE operating zone: ~1K-4K tokens, single-digit error, before the steep falloff that begins around 8K+.
Curve = GPT-4o on the NoLiMa long-context benchmark (Modarressi et al., ICML 2025, Table 3): accuracy falls from 98.1% at ~1K tokens to 69.7% at 32K, roughly a 30-point drop on the same task, purely from added context. The ~128K point is a directional extrapolation (RULER; Chroma "Context Rot"), not a measured NoLiMa cell. This is one model on one deliberately-hard retrieval task, the exact slope varies by model and task, but the direction is corroborated across four independent studies. "Context rot" is the problem recursive/decomposition strategies are built to avoid (Zhang, Kraska & Khattab, Recursive Language Models, MIT CSAIL, arXiv:2512.24601).
Sources: NoLiMa, Modarressi et al., ICML 2025 (arXiv:2502.05167) · RULER, Hsieh et al., NVIDIA 2024 (arXiv:2404.06654) · Context Rot, Chroma Research, 2025 · Lost in the Middle, Liu et al., TACL 2024 (arXiv:2307.03172) · Recursive Language Models, Zhang, Kraska & Khattab, MIT CSAIL (arXiv:2512.24601).
Sessions hold almost no in-RAM state, and any node can rebuild any session from its transaction ledger. So the engine fans out horizontally with no sticky sessions, plain round-robin in front of identical, interchangeable nodes.
Runs as a 3-container Docker stack on one office PC, web, engine (bun runtime), and python-AI tier. This single-host deployment is verified and operating now.
Because nodes are interchangeable and carry no sticky session, the same stack fans out across N nodes behind a round-robin balancer. Design-validated, not yet demonstrated as a fleet.
Each game's writes go through an async lock, so updates to one session apply in order. This is a per-session detail, not a fleet-wide bottleneck.
~60 sessions ≈ +1 MB of engine-tier state, rebuilt in ~11-12 ms. Important: this is a Raspberry-Pi, TEMPLATE-mode (engine-only) patent bench, it measures engine-tier session density, not end-user latency and not AI/model capacity. Real throughput is gated by the LLM tier, not by this number.
Nothing in the engine is tied to one AI vendor. One provider interface sits between the rules engine and the model: the engine passes an already-decided outcome, the model returns narration. Implement that single contract and you can point the engine at a commercial API, a self-hosted open model, or your own internal gateway. Your credentials are injected at runtime and stay on your infrastructure.
One contract: the engine hands the model an already-decided result; the model returns narration. It runs end-to-end today, and because the model never decides outcomes, swapping providers can never change who is in control of the game.
Point the interface at any commercial provider with your own account and keys. The engine calls the model through the same contract no matter the vendor.
● Your credentials are injected at runtime and stay on your own infrastructure, they never live in the engine.
Patent-claimed, not built. Today the interface is single-active-provider; switching vendors is a configuration change, not an automatic runtime hand-off.
The architecture under this deck is the subject of a published U.S. patent application: “Stateless Multi-Provider AI Game Master System with Transaction-Based Context Reconstruction.” Three independent claims (system / method / medium) plus 37 dependent, 40 in all. Four claim-clusters map directly to capabilities shown elsewhere in this deck.
Game-state values are derived exclusively from deterministic replay of the transaction log, the model never authors state. Maps to the inversion + defense-in-depth gates (§3, §5).
Each turn’s context is rebuilt from a compact append-only ledger through an engine-owned whitelist, the basis for the bounded, locked-per-turn payload.
Ledger checksum + deterministic replay let any instance reconstruct an identical, verifiable state, the path to horizontal scaling without shared session RAM.
Claims recite operation over “any language model, commercial, open-source, and local.” Connect any hosted, self-hosted, or in-house service through the same interface.
Verified status Provisional rights available under 35 U.S.C. §154(d).
BKE does not compete with the vendors that make an NPC sound and look alive. It sits underneath them and guarantees the NPC cannot lie about what happened, remembers what you did, and costs a flat, predictable amount per turn, backed by a published anti-hallucination patent claim.
Voice & 3D NPCs, they make the character sound and look alive.
Not endorsements; not partnerships.
Server-side outcomes · nine memory categories · ~6-64 KB per turn
The rules engine resolves every outcome before the model is called. The NPC can describe, it cannot grant a win, edit a stat, or be jailbroken past a result.
9 behaviour categories ride in a compact transaction ledger, so an NPC recalls kindness, betrayal, or a broken promise across the whole session.
History never accumulates, a locked ~6-64 KB packet per turn. Your most engaged player costs the same per turn as a new one.
The only such layer with a published anti-hallucination patent claim, Claim 37, US Pub. 2026/0145077 A1. Truth and memory are the layer; the look and the voice plug in on top.
A client you build against our documented contract, we provide it and support it.
Custom client against a documented REST / WebSocket contract, not a drop-in game-engine plugin.
Build a living-NPC layer into a new game on a documented REST + WebSocket contract.
Your shipped combat, economy, and quest systems can be the authoritative "dice"; BKE adds the narrative + memory layer. A practical path, not a shipped game-engine adapter today.
No Unity/Unreal plug-in exists yet. Today integration is a custom client; a packaged adapter is on the roadmap.
The split below is real and architectural. The pricing shapes are illustrative placeholders to frame the conversation, final terms are set by Binary Kinetics, LLC. Nothing here is committed pricing.
This slide does not quote prices. The license shapes are candidate structures shown to start the discussion. Actual terms, rate, basis, and tier, are TBD by Binary Kinetics, LLC and settled per engagement.
Illustrative · not an offerPossible structures only, Binary Kinetics, LLC selects and prices the model per deal.
One license fee per shipped game or SKU. Simple for a single flagship release.
Terms TBD by Binary KineticsScales with monthly active players. Aligns cost to a live title's reach.
Terms TBD by Binary KineticsMetered on engine turns resolved. Pairs with the bounded, predictable per-turn payload.
Terms TBD by Binary KineticsBinary engine license, or a source license for studios that need to extend it in-house.
Terms TBD by Binary KineticsIntegration-only, or ongoing support and SLA. Layered on top of any base shape above.
Terms TBD by Binary KineticsShare your title, scale, and integration path, we will scope a model with you.
Illustrative structures only. No prices stated. Final commercial terms determined by Binary Kinetics, LLC.
We provide the engine, the documented integration contract, and hands-on support. Next step: a technical deep-dive, and a live demo of the engine resolving turns end to end.