Ship with a licence

Activate, once, on a build machine

lw licence activate <key>
lw licence status

Activation fetches the local weights (the reflex head and the event gate), writes a signed token, and prints the wake service URL to put in lw.env as LW_WAKE_URL. The key rides in the request header; no command ever prints it.

What a shipped build does

Reflexes, perception, memory and running a plan happen on the player's machine, on the tick, offline. When a character has something worth planning about, one small request goes to the hosted deliberator: the event, the recent journal with its vectors, the tick's context, the character's state. The plan comes back. No player identity, no telemetry, nothing else, and the service keeps nothing between calls.

Pull the cable and the town keeps living; it stops forming new long plans until the wire is back.

If the licence lapses

Your characters lose the ability to plan and to be emergent, within a minute of the lapse. Reflexes keep running, so the game does not break. A lapsed build does not hammer the wire: the first refused wake is recorded, then wakes are answered locally and the service is asked again once a minute. lw warns on every command; renew and it resumes within a minute.

Retrains and new verbs

You never train anything yourself. Two kinds of request, both through the same door:

• A retrain makes the intelligence you already have better on your own data. Your escalations (the moments the brain was unsure) are mixed into the base's own examples and that one model is retrained on our side. It ships back to you only if it passes the same batteries the base passed and is no worse than the base on every metric; otherwise the job is rejected and the receipts say why. Student and gate weights come back to your build; a ranker improvement is applied to the hosted planner. Wording never needs a retrain: the gate reads meaning, so the retrain sharpens which class an unsure sentence gets, not whether the character reacts.
• A new verb gives characters a movement they do not have. You describe it as you would to an animator; we build and train the body, certify it in closed-loop tests, and the moment it certifies it is released to you: lw train status shows released and the version, lw licence activate pulls it. Adding it to the base every other studio starts from is a later step on our side. Existing verbs are never retrained or changed by any request. A released verb comes with its operator card, so the hosted planner can choose it on its own for any character who has it in can, under the same never rules; levels that do not name it decide exactly as before. lw licence activate pulls the body and the card; bind the engine action <name> in your adapter.

lw escalations                 what the flywheel has queued, by lane
lw sync --dry-run              exactly what would leave this machine
lw train student --propose     reflex weights come back, yours to ship
lw train gate --propose        gate weights come back, yours to ship
lw train ranker --propose      nothing to install; the hosted planner gets better
lw train status                the certification receipts as they land

Escalations are captured by default: the hosted planner records its own at wake time, and a licensed build uploads the reflex lane ninety seconds after launch and every ten minutes after that. If you gave the reflex lane a model of your own, its verdicts ride up with those moments as labels; if not, the moments are resolved on our side when a retrain is made (When the brain is unsure). Both carry features, candidates and hashed names, never journal text. They feed two things: your own retrains, and the shared base that every new activation starts from, which we retrain on everyone's captured moments under the same never-worse gate and release as a new base version (lw licence pool status shows the base you are on). Released verbs join that base too, so the vocabulary grows for everyone. That pooling is part of the terms you accepted with the trial key; raw sentences are the one thing that only leaves when you say so. Raw sentences (the gate lane) go up only with lw sync --include-unclassified. An agent on lw mcp can read what is queued and how a retrain is going, but cannot send sentences or request a retrain; those are yours to do at the terminal. The gate lane carries raw sentences and needs its own opt-in (--include-unclassified). A new verb is a request: lw verbs request <name> --looks-like "..." --wrong-when "...". We build and certify it, it is released to you the moment it passes, and lw train status shows the version to activate.

Ship to players: the bundle

A player has no Python and no embedder. lw bundle makes one folder your installer carries, and the game starts it:

lw licence buildkey create --label "v1.0 steam"      a wake-only key for the shipped brain (shown once)
lw bundle --target windows --build-key <it>           lwbrain-windows/: embedded Python, the embedder,
lw bundle --target mac --build-key <it>               your weights, the manifest, a launcher

Inside: an embedded CPython, our package with torch (CPU) and transformers, the embedder model, your activated weights and released verbs, lw.manifest.json, lwbrain.env (the wake URL and the build key) and lwbrain.py, the launcher. About 2.3 GB on disk, 1.1 GB of it the embedder; the same code as lw dev, in a box.

Your game starts it at launch and stops it at exit:

windows   lwbrain.cmd --parent <your pid>        (from code: python\python.exe lwbrain.py --parent <pid>, CreateNoWindow)
mac       ./lwbrain --parent <your pid>

Then connect to ws://127.0.0.1:8765 exactly as your adapter does today, and poll GET http://127.0.0.1:8767/v1/health until it answers (logs/ready appears at the same moment; the embedder takes ten to sixty seconds to load). Perceptions and orders go to the same :8767 API; the talk lane listens on :8094. The launcher restarts a process that dies, and exits with everything when your process is gone. lwbrain --status and lwbrain --stop for support tickets; everything logs under logs/.

The build key only wakes. It cannot sync, train, activate or bill, so a key lifted from a player's disk buys nothing but wakes, and lw licence buildkey revoke <id> stops those within a minute. Never put your studio licence key in a bundle. With no build key the bundle plans in process, which is fine for a dev build and useless for a release: no hosted planner, no ranker.

The bundle's talk lane runs the grounded stub by default. If you want a model behind it, do not ship your API key: set LW_SPEECH_BACKEND and point it at your own proxy in lwbrain.env. The same goes for a model behind the reflex lane's torn moments: LW_ESC_URL to your own proxy, never a key.

Reference: CLI · Local and hosted.