Pipelines
A capability of AutomationForge.
Editor and commandlet only. Nothing here ships inside a game.
Why you can walk away
An unattended run holds to three promises. They belong to the executor itself — every pipeline gets all of them, including the ones you build.
The one place automation gets expensive is a loop over a script. So spending is a decision you make once, up front — never a surprise in an invoice.
A run prices itself end to end and shows you the total before anything is spent.
A step refuses to overwrite anything the ledger has no record of making. Ninety-five lines already had audio; the run touched none of them.
A pipeline you can only run once is a script. These are built to be re-run after every rewrite, and to charge you only for what changed.
A step whose output already exists is skipped. Thirty-nine dialogues on the first pass; zero on the second.
Run one step or all of them. A run that stopped — gated, failed, or the editor closed — resumes where it stood rather than starting again.
Some calls belong to a person: which take survives, whether a clip is good enough, whether to spend at all. The run does not guess — it stops, and asks.
A gate suspends the run and waits. Anything a machine should not decide on its own is a gate, and the run sits there until a person answers.
Every run writes to the ledger — what executed, what was skipped, what it cost, what it produced. The audit trail is a by-product of running at all.
Everything composes
A pipeline is an asset: a definition you can edit, duplicate and check into source control, built in a node graph with a palette, a Check button and a Run button. Your surface is exactly as powerful as ours — our own voice-over pipeline runs as a user-editable definition, and the hardcoded version was deleted.
The node library is found, not listed. Every installed Forge set contributes its steps automatically, any BlueprintCallable function on an editor subsystem becomes a node, and so does a Blueprint function library in your own project. Installing a plugin adds its nodes with no edit to ours.
And the same definition runs headless from a commandlet, with no editor UI involved — so overnight batches and continuous integration need nothing added. Write it once; run it from the graph, from an agent, or from the build farm.
Two editors, one definition
An agent can write a pipeline a person then opens and rearranges; a person can build one an agent then runs nightly. Neither editor is the real one — both are thin layers over the same definition, which is why they cannot drift apart.
Nothing is available only through a panel, because an agent cannot read a panel — and a human iterating on a pipeline should not have to.
What people build
These run in the production of our own title. They are what we needed first — the node library is open to whatever you need next.
Harvest the lines out of a dialogue, resolve each speaker to a voice, price the whole thing, generate what is missing, and write the audio and its measured duration back onto the dialogue. Run it again after a rewrite and it touches only the lines that changed.
The same graph, stopped after the pricing step. Useful on its own: it answers what a full pass on an episode would cost, before anything is spent.
List every clip in a folder, measure self-penetration against a dense physics proxy, and gate on the result. Nine clips measured, eight of them held for a person to look at.
And every new set extends the same shape: chain approved audio into a face solve and the new pipeline inherits the cache, the gates and the ledger of the old one. That is the point of the layer — a capability added anywhere composes everywhere.
Why gates exist
A pipeline that cannot be stopped where a person has to decide is not automation, it is a machine spending your money in a straight line.