How it works
From a process you describe to a process that is proven.
Ten stages. The first four happen once, before anything runs. The rest happen on every run, every time.
Before it runs
You are interviewed about the process
Not a form. A conversation that refuses to move on until six things are settled: every term that could mean two things, the state of the world when a run has succeeded, the evidence a finished run must leave behind, why you want it done at all, what you want respected about how it proceeds, and everything else you know that a stranger wouldn't.
The last one matters more than it sounds. Most automation fails on the thing nobody thought to say out loud.
Your standing decisions narrow the field
Everything your company has already settled — approved vendors, approval limits, who is never contacted after hours, which tone goes to whom — is held for you and handed to the author before it writes anything. Each new decision is checked against the ones already there, so a contradiction surfaces when it is written rather than when it fires.
The author therefore doesn't start from a blank page, and it doesn't re-open questions you closed years ago.
Anything that never changes is resolved now, not on every run
If a step would look up the same answer every time it ran — a fixed rule, a stable reference, a format that hasn't moved in years — that answer is settled during authoring, shown to you for approval, and written into the process directly. The step disappears.
A run should never pay to rediscover something already known.
The plan is written, and then it is proven
An AI writes the process as a structure of typed steps. Before it is allowed to run, a compiler checks it: is every value assigned on every path, is every branch of every decision covered, does anything get produced that nothing uses, does every check actually look at the thing it is checking.
If it doesn't hold, the author is told exactly which step and which line, in the vocabulary of the process rather than of a compiler, and it fixes it and tries again. You only ever see plans that passed.
You also get the process as a diagram. An operations manager who has never seen this system can read it and tell you whether it is right — before it touches anything.
Every time it runs
Each step runs on its own agent, at its own depth
A step that needs judgment gets the most capable model. A step that checks a number gets a fast one. That choice is made per step when the process is written, not per run and not for the whole job — so you are not paying for deep reasoning to confirm a postcode.
Every step that acts is judged before its result is used
A separate evaluator — its own agent, with its own instructions — looks at what the step produced or did, and returns a verdict with a reason. Until it passes, the result goes nowhere.
The evaluator judges the task, never the tooling. It has no access to what other steps said or did, so it cannot be talked into a pass by the thing it is checking.
Data is collected from more than one place, and checked against what you asked for
Where a step gathers information, it tries genuinely different sources in order, merges what it finds without duplicates, and stops when a separate check confirms the result actually answers the question. If every source comes up empty, the run stops and says so in the words the author wrote — it does not invent a plausible answer.
It talks to people, and waits
A step can open a conversation with a specific person and hold there — hours or weeks — then carry on where it stopped. Another can run rounds with several people at once until they converge on something, letting those who may opt out do so.
Each person sees only their own conversations, in one place, across every process that is waiting on them.
It survives being interrupted
Progress is committed step by step. A restart, a dropped connection, a deployment mid-run — the process resumes at the last completed step rather than starting over or, worse, silently repeating something that had already happened.
It writes down everything, including what it cost
Every prompt with the values that went into it, every result under the name it was published as, every verdict and the reasoning behind it, every message to a person, and the cost — to a fraction of a cent, per run.
What it deliberately does not do
Worth saying plainly, because the boundary is part of the design rather than a limitation to be removed later.
File handling
Processes that work on documents run against a versioned workspace: every run gets its own, changes are committed step by step, and any earlier state can be restored. This is built and is being wired into the document-heavy processes now.