Whitepaper
The argument, in brief.
Play the design before the assets exist.
The problem
The asset is not what costs the most.
An interaction has no rhythm until a character actually reaches for the panel. A quest has no pacing until the lines are spoken. A consumable is not a consumable until something is taken out, used, and thrown away on its own beat. None of that can be felt in a design document — it has to be played.
Traditionally you either wait for the artists, or you playtest a prototype where every verb is a teleport and a debug print — and discover the design problems after the assets are paid for. The asset authored against a design that was never playtested is the real expense.
We own a mocap suit, and that is exactly the argument. The question “does injecting a stimpack feel better as a sharp stab or a braced two-handed press?” deserves ten answers in ten minutes, not two answers in an afternoon of suiting up, calibrating, cleaning and retargeting. The suit does not go away — it stops being the thing that blocks the prototype.
The thesis
Two content speeds, kept apart on purpose.
Generated content exists to feel the game; authored content exists to ship it. Five rules keep the two from contaminating each other, and every plugin in the suite is a consequence of one of them.
Generated assets are never hand-edited.
A tweaked generated asset stops being reproducible and silently becomes debt. Touch it and it has graduated — the tooling treats it as authored from that moment and never overwrites it.
Generation is reproducible, or the handle to it is.
Where the generator has a seed, the definition is the clip and the file is a cache. Where it does not, the provider’s id is the durable handle, and nothing may ever prune it.
Runtime code is asset-agnostic.
Nothing in the game knows an asset was generated. Swapping a placeholder for the mocap take is a reference change and nothing else — which is what makes graduation cheap.
Capability and adapter are separate plugins.
A capability knows nothing about our game, our framework, or even MCP. Adapters wire it into a use case. The test is one question: would another project want this?
Typed API first, UI second.
Every operation is a subsystem call with typed parameters and typed results. The editor UI and the agent toolset are both thin layers over the same surface — which is what makes agent control real rather than bolted on.
The exit
Graduation is the part nobody builds.
Generating is the easy half. The half that decides whether any of this is professionally serious is the transition out of it — and the bet was never that generated assets are good enough to ship.
The ledger records every generated asset: what produced it, what it cost, what consumes it, and what has happened to it since. Once the game has been played enough to know which assets are keepers, the ledger drives the triage — keep, fix, or replace — and the output is a production brief: for each asset, what it is for, the prompt and constraints that produced it, and a rendered reference of the thing itself. That is what goes to the mocap house and the VO studio — a shot list derived from a game that has been played.
And the rule that makes it safe: once an asset has been hand-authored it graduates, and the tooling stops touching it. Permanently. Settled on day one rather than in month eight.
For whom
It bites hardest small, and pays biggest large.
The obvious audience is the solo developer and the small team, because the constraint the pipeline removes — you cannot playtest what you cannot build — bites hardest there. That is who it was built for, and who it helps most immediately.
A large studio has the opposite version of the same problem: it can build anything, so the cost of discovering a mechanic is not fun is measured in authored assets that already went through a full production pipeline. Pre-production and vertical slices are exactly where a disposable, reproducible content layer pays — and the ledger that turns a played prototype into an exact shot list is a production-planning tool at any scale.
Nothing here removes the need for animators, actors or artists. It removes the need to pay them before you know what you are making.
How we check
What verified means here.
Generated-content pipelines are unusually good at producing bugs that pass every check, because there is no author to say “that is not what I made”. So we measure the plane a bug lives in, treat numeric verification as necessary and never sufficient, and check every wire with a reader that shares no code with the writer. These are the numbers that discipline produces, taken against our own output.
0.54 cm
mean rebuild error
Joint positions rebuilt from the model's own rotations, compared against the output it gave us.
0.000000 rad
across all 30 joints
A pose read out of a pose asset, against the same instant sampled from the animation it came from.
0.1°
shoulder axis and heading
A retargeted clip against its source — measured in the ground plane as well as in height, because the worst bugs live only there.
The document
The whitepaper, in full.
The complete whitepaper covers what this page compresses: the two-speed model in detail, the Trinity conventions for Unreal’s agent surface, the failure taxonomy of silent bugs — with the measurements behind every number on this site. It is revised as the work moves.
Sent by email, current revision, while the public copy is prepared.
Questions
What studios ask first.
Does this replace artists?
No, and it is not built as though it could. Generated assets are placeholders that let a team play the game before the real work is commissioned — and the ledger exists precisely so the real work can replace them one slot at a time, with a shot list that is exact. The people who would have spent six weeks making placeholders spend them on the work that ships.
Can I ship any of it?
Some of it. The engine tooling has no generation in it at all — montages, the pipeline executor, the ledger — and is ordinary production code. Of generated content: many voice lines, subtitles and secondary gestures never need replacing; hero animation, hero props and hero voices graduate to authored work, against a brief derived from a game that has been played.
Do I need a GPU?
For local motion generation, yes — and then it costs nothing and takes about ~14s a prompt. Without one, rent a card from inside the editor or use a hosted provider on your own account. Speech and the face solve need no GPU at all; the face solve runs on CPU.
Do I need Narrative Pro?
No. The generation family knows nothing about any gameplay framework — that is a deliberate architectural line. Narrative Pro support lives in separate add-ons, and bridges to more frameworks are on the way.
What does it cost?
The plugin sets install free and run complete on your own hardware. Hosted generation is billed by your own provider, at rates every metered step prices before it commits. Automation Forge Pro is paid per seat when it opens, and the framework add-ons are bought once on Fab.
How open is it, really?
Open where it counts: the generation cores and every agent toolset are open source as well as packaged on Fab, so the surfaces you build against can be read, audited and extended. Providers, utilities and the pipeline umbrella are free on Fab. And nothing free is crippled — the local path is a complete product for one person on their own machine, with no account and no server dependency.
Something not answered here, or on a set page? bojan@blackcode.ch.