Whitepaper
Bojan Andrejek
Kovati · Automation Forge
Revision 2 · 1 September 2026
A snapshot, and already moving.
The playable gap.
01 · The hangover
Generation was never the whole job.
The first contact with generative tools feels like a door opening. Describe a character action and receive motion. Write dialogue and hear it spoken. Turn a reference image into a mesh. Work that once needed a specialist, a budget or a long wait appears in minutes.
Then the second week begins. The animation faces the wrong direction. The hand misses the prop. The clip has no root motion, no loop point and no gameplay notify. The voice take is a different duration from the placeholder it replaced. The face solve uses a control vocabulary the character does not read. The mesh is centred in space, at the wrong real-world size, with poor collision and no usable lightmap UVs. A new generation fixes one thing and quietly breaks another — and nobody remembers which prompt, model, seed or settings produced the version the game already references.
That is not evidence that generative tools are useless. It is evidence that generation was never the whole job. A first-time developer does not merely lack assets; they lack the production knowledge that says which invisible decisions make an asset safe to use — and that knowledge is expensive precisely because the problems are delayed.
A wrong pivot is obvious when the object floats above the floor. A missing source identity may not matter until the project has two hundred similarly named takes. A pipeline that overwrites a hand-tuned animation may work perfectly for six months before it destroys the one asset the team could not regenerate.
A generator competes on model quality, price and speed. Those change every month. The durable opportunity is the harness around them.
02 · The gap
A mechanic described is not a mechanic felt.
A design document can say “inject the stimpack”. On screen that verb is a small production — and until enough of it exists, the team cannot answer the only question that matters: does it feel right?
On paper
A generated candidate
A playable operation
Inject stimpack
A four-second character clip
Motion on the target skeleton, prop alignment, montage slot, gameplay-event notify, timing, blend and ability binding.
Open airlock
A door animation and a sound
Access state, pressure checks, sequence timing, audio, interruption rules and the system event other gameplay can observe.
Speak to the player
A voice file
The right speaker and line, duration, subtitles, facial take, chosen version, scene pacing and a replaceable target.
Place a supply crate
A textured mesh
Collision, lightmap UVs, Nanite policy, real-world scale, floor pivot, folder ownership and safe regeneration.
The distance between the first and third columns is the playable gap. It is where many ambitious first games die — not because the developer cannot imagine the game, and not because they cannot produce any individual asset, but because every verb asks them to become a temporary animation programmer, audio engineer and technical artist before they can find out whether the idea was any good.
03 · The category
PlayableOps.
Software teams have DevOps because writing code is not the same as operating software reliably. Data teams have DataOps because creating a dataset is not the same as moving, validating and governing it. Games need the same idea for playable content.
Intent or performance
What are we trying to make, for which character, scene, object or gameplay slot?
Candidates
What alternatives were produced, by whom or by what, at what cost, with which inputs?
Review and selection
Which take is chosen, who chose it, and what evidence remains?
Engine finishing
What must Unreal add before the result is genuinely usable?
Binding
Where does the game consume this result without caring how it was produced?
Provenance
Can we explain the current result, and reproduce or retrieve it where possible?
Graduation
When has a temporary result become authored, recorded or final — and when must automation stop touching it?
Replacement
Can the better result land without rebuilding the surrounding gameplay?
It is not a new word for asset management. It is the operational lifecycle around content that must become active inside a game: it begins before the file exists and continues after the first version has been replaced.
And it is not the claim that AI makes the whole game. The discipline becomes more important when output is abundant, not less.
04 · End to end
One performance, from a person to a playable character.
PerformanceForge is the clearest demonstration because it begins with a human being. A developer opens a miniature performance stage inside Unreal, records a line, and the take clock is real rather than estimated.
- 01RecordCapture voice and optional video without leaving the editor.
- 02MeasureStore the real media properties rather than assuming nominal rates.
- 03ProcessRoute the chosen source through speech transformation, face video solve, audio mouth solve, or a studio flow that keeps the performance as-is.
- 04LayerMerge control vocabularies so mouth motion does not flatten the brows or erase expression.
- 05ReviewKeep recorded and generated alternatives together. Choosing does not delete the others.
- 06BakeWrite the chosen result onto the target character in the form the engine consumes.
- 07GraduateMark the line or face take as recorded, while retaining its generated ancestry and alternatives.
An ad-hoc experiment can process the latest take immediately. A planned session can save every recording and explicitly forbid provider spend until someone reviews and chooses — because “record now” and “spend now” are not the same decision.
05 · Trinity
People and agents are first-class citizens of the same surface.
Software was traditionally a line: software on one side, a person on the other, an interface between them. Agents add a second user — not a macro clicking a panel built for somebody else, but a client with its own discovery model, failure modes, speed and permission risks. So the shape is a triangle, and every edge is intentional.
No core capability is written for a person and adapted for a machine later. The native editor surface and the agent toolset are different clients of the same typed operations. A person enters credentials and approves anything destructive; an agent may use approved capabilities but cannot write keys or delete unrecoverable work. The same boundary is enforced regardless of caller.
How that is built is its own page.
06 · Providers
Today’s model is the worst model we will ever ship on.
That sentence is not optimism about AI. It is an architecture constraint. Any product hard-wired to the current provider inherits its quality ceiling, its pricing changes, its licence risk and its operational failures. A production system should be built around capabilities, not vendor names — which is why the integrations page can grow without anything else being rewritten.
07 · Status
What works now.
Automation Forge is under active development. This paper describes the direction, but it is grounded in plugins that work today. The useful distinction is not “built” versus “planned” — it is whether a complete path has been verified, whether the surface is ready for outsiders, and whether the result is safe enough to depend on.
Read from the same source the set pages use, so this table cannot fall behind them.
AutomationForge
The umbrella the other sets plug into: wire any of them into one pipeline, leave it running for hours, and trust the result — it skips what is done, prices what is not, and stops where you would want to be asked.
Working developer preview. The graph, gates, executor and ledger run; systematic reliability testing and the final authoring surface remain.
MotionForge
The move you just described, playing on your own character in seconds — generated on your GPU, a rented card, or a hosted provider, and imported as an ordinary AnimSequence.
Working, at beta quality, with limits that depend on the model you pick.
SpeechForge
A voiced scene for cents — every line generated with character-level timing attached, priced before you commit, and cached so an unchanged script never pays twice.
Working. The product surface is still moving.
FaceForge
Spoken audio becomes a performing face — solved locally on CPU for nothing or on NVIDIA Audio2Face-3D, with emotion you set or emotion read out of the delivery, retargeted into the vocabulary your rig actually reads, and baked ready to play.
Working, with several paths verified end to end.
MontageForge
A clip becomes something an ability can play: the montage built from a recipe, notifies exactly where you authored them, and hand-tuning that survives every rebuild.
Prototype quality, and proven — in a live editor and in a game.
MeshForge
Describe a prop or drop in a reference image and get a game-ready static mesh — imported with its textures, materials, collision and lightmap UVs. One pipeline end to end: submit, poll, download, import, finish.
Developer preview. Concept, mesh, import and garment fitting work.
PerformanceForge
Sometimes the answer is not a model. Record a performer’s microphone and webcam onto one take clock, file every take with its manifest, and let a human performance drive the same pipelines the generated content came from.
Working development build, and the flagship proof path.
SurfaceForge
Turn a prompt or a reference image into reviewable material candidates, graduate one into a PBR map set, and create the Unreal material assets. Provider-neutral and editor-only: generate free on your own card, or through fal.ai when you need resolution the local route cannot reach.
Developer preview, and released. The local route is exercised end to end; the hosted one has run previews but not yet a full graduation.
What we will not pretend. A working path is not automatically production-ready for every team. Model quality varies — hands, physicality, topology, voice behaviour and facial detail all depend on the path selected. The pipeline graph needs more reliability testing before it becomes something to depend on live.
08 · At studio scale
The same lifecycle, with more people in it.
Our first users should be developers and small teams. The path to a larger market is earned through the small-team product, not invented in a boardroom.
Small-team behaviour
Studio-scale extension
A developer chooses one take.
Role-based review, approval policy, reversible decisions and an audit trail.
A definition records intent.
A production sheet shared across discipline, vendor and project boundaries.
A local ledger protects one project.
Cross-project provenance, budget reporting and policy enforcement.
A developer imports the result.
Source-control-aware sync, CI processing and approved delivery by morning.
A freelancer receives a brief.
A vendor portal exposing only the relevant brief, delivery route and acceptance state.
A team chooses a provider.
Approved provider catalogues, regional constraints, self-hosting, SSO and security review.
A studio that never generates anything may still want this. One already coordinating voice houses, mocap vendors, internal animation and technical art has the same need for targets, takes, choices, briefs, delivery and replacement. If the operational layer is sound, a vendor-delivered human performance and a model-generated candidate are simply different origins in the same lifecycle — which is where the category becomes more than “AI for Unreal”.
09 · The compact
Open first, sustainable later.
If it runs on your machine and costs us nothing to operate, the core capability stays open and useful: definitions, capability contracts, toolsets, local paths, the single-developer ledger and the modular plugin surfaces. If we operate infrastructure, coordinate several people or provide a shared production surface, we can charge for that service and the operational value around it.
The free promise must finish before the paid promise begins. Solo developers should not feel like an acquisition funnel waiting to be limited — they are the community that proves the lifecycle, finds the missing cases, and establishes whether any of this is useful outside our own game.
There is a commercial reason too, not only a community one: a studio will not hand the centre of its content pipeline to a black box that disappears if one vendor changes strategy.
10 · What will not move
The product can grow. These rules should not.
- 01The game must become playable early. A tool that creates more content without shortening the path to a decision has missed the point.
- 02A candidate is not an asset merely because it is a file. Finishing, binding, review and replacement are part of the product.
- 03Generated work must remain disposable without becoming invisible debt. Store the intent, inputs, result, target and history.
- 04Graduation is a first-class event. The system must know when automation no longer owns a target.
- 05Runtime code remains origin-agnostic. Generated, recorded and authored results are replaceable through the same target.
- 06Providers are adapters, not the platform. Choose them per work item and expect them to change.
- 07Humans and agents receive equal operational reach. Different clients, same capabilities, permissions, costs and provenance.
- 08The system prevents silent failure where it can, and names uncertainty where it cannot. A plausible wrong result is more dangerous than a visible failure.
- 09Open small-team value comes first. Studio orchestration is credible only after the lifecycle works for the people closest to the work.
- 10Honesty is the brand. Working, beta, developer preview, in development and planned are different claims.
Since it was written
Where this paper is already out of date.
It is dated 1 September 2026 and calls itself a snapshot, which was accurate and is the honest way to publish one. We move faster than we revise it, so here is what has changed in the six days since — named rather than left for you to discover.
SurfaceForge exists
The status table above has eight areas and no materials in it, because the set did not exist when the paper was written. It does now, and it shipped on 2026-09-07 — a developer preview, with the local route exercised end to end and the hosted one not yet taken through a full graduation.
Providers were added
Uthana for hosted motion, ElevenLabs for speech, and DeepL for localisation. The paper’s argument that providers are infrastructure is exactly why adding them changed no definitions — but the list on the integrations page is longer than the one in the paper.
PerformanceForge and MeshForge Garment are paid
The paper describes the open-first compact but names no prices, because there were none. 3 plugins are now paid, which is the compact working as written: paid value where a specialist workflow carries ongoing maintenance.
The company is Kovati
Kovati is the company, founded by MetaWorx LLC, which holds the IP and runs the cloud the account sits on. The studio page has the whole structure.
None of it changes the argument — the playable gap, the lifecycle and the ten rules are the parts meant to outlast any particular plugin. What moves is the inventory and the status, which is why the sets, the integrations and the release notes are the live answer and this paper is the standing one.
A revision follows when enough has shifted to warrant it. Until then, where the paper and the site disagree, the site is newer.
The document
The PDF is on your account.
Everything above is the paper, so there is nothing held back — the download is the same argument in a form you can send to somebody, mark up, or read on a train.
It sits behind an account rather than a form, and the distinction matters to us: a paper that argues solo developers should not feel like an acquisition funnel has no business trading itself for an email address. An account is something you already wanted, it takes one click with Google or GitHub, and there is no mailing list attached to it.
Questions
What people ask.
What is PlayableOps?
The operational lifecycle around content that has to become active inside a game. Software teams have DevOps because writing code is not the same as operating software reliably; data teams have DataOps for the same reason. PlayableOps begins before the file exists and continues after the first version has been replaced.
Is this just asset management?
No. Asset management describes files at rest. PlayableOps describes a result on its way into a game: what was intended, which alternatives existed, who chose one, what the engine had to add, where the game consumes it, and what happens when something better arrives.
Does this assume AI makes the whole game?
The opposite. The discipline becomes more important when output is abundant, not less. Generation is one step; the argument of this paper is that it was never the whole job.
What if the model I use gets replaced?
It will. Today’s model is the worst model we will ever ship on, which is an architecture constraint rather than optimism: anything hard-wired to one provider inherits its quality ceiling, pricing, licence risk and outages. Definitions, candidates, review, targets, history and the replacement path survive a provider being swapped.
How open is it, really?
If it runs on your machine and costs us nothing to operate, the core stays open and useful — definitions, capability contracts, toolsets, local paths and the single-developer ledger. Paid value belongs where real service begins: shared coordination, hosted infrastructure, approvals and vendor delivery. The free promise finishes before the paid promise starts.
What actually works today?
Several complete paths, and the status table above says which — set by set, read from the same source the set pages use, so the two cannot disagree. What holds regardless: a working path is not automatically production-ready for every team, model quality varies by the route you pick, and we will not pretend otherwise.