Deterministic outcomes from a probabilistic engine.

An AI writes the plan as a structure of typed steps; a compiler proves it before it may run. Every value assigned on every path, every branch of every decision covered, nothing produced that nothing uses, every check aimed at what it claims to check. What fails goes back to the AI, in the vocabulary of the process. And anything that never changes between runs (a fixed rule, a stable reference) is resolved once at authoring, shown for approval, and written in, so a run never pays to rediscover it.

Perimeter protections wrap each step individually, and the interior assumes the perimeter will one day fail: steps share no conversation and no scratchpad; each receives exactly the named values the plan routed to it and returns a declared shape, checked before anything downstream may see it. Hostile text lands as data in the one step that asked for it. It cannot reach a step that did not ask, cannot enlarge its own reach, cannot leak what it never saw, and cannot take the run anywhere the plan does not already go. Every path it could push toward was written and checked before the run began. And the text itself travels narrow: wherever the process permits, a crossing is a number, an amount, a choice from a closed list, not prose. What must remain prose is declared, so the places hostile text can even arrive are a short, known list. Each is checked before anything acts on what arrived. Containment, not a promise of elimination.

Standing decisions are captured once, checked for collisions, and enforced from the first authored word; every change is validated for consistency with the processes already defined and running. Policy is applied exactly as written, and a run comes to a person only when the decision is genuinely theirs.

The times when launching an agentic automation required a build are over. In AI++, automating a process is a conversation. It takes minutes, plus one person who knows today’s manual process well enough to describe it, review the plan the AI proposes, and bless it for use. The plan is shown as a readable flowchart, not code. What accumulates is the company’s own specification: it lives with the business and outlives any single process.

Each step runs on its own agent at its own reasoning depth, chosen per step when the plan is authored: deep reasoning where judgment lives, a fast model where the work is mechanical. Nobody pays for deep reasoning to confirm a postcode.

Every acting step’s result is reviewed by an independent evaluator with its own agent, its own instructions, and no access to what other steps said, so it cannot be talked into a pass by the thing it is checking. The verdict and its reasoning are kept. Where a step gathers data, it tries genuinely different sources in order and stops only when a separate check confirms the result answers the question. If every source comes up empty, it stops and says so in the plan’s own words rather than inventing a plausible answer.

A step holds a conversation with a named person for hours or weeks and picks up exactly where it stopped; another works several people in parallel until everyone who must sign has signed. Progress commits step by step, so an interruption on our side resumes at the last completed step, never starting over, never silently repeating something that already happened. Each person sees their own conversations in one place, across every process waiting on them.

Every prompt with the values that went into it, every result under its published name, every verdict with its reasoning, every message to a person, and the cost, all per run. Documents run against a versioned workspace: every run gets its own, changes are committed step by step, and any earlier state can be restored.

The process is fixed and readable before it runs. It does not improvise a new step because a run went sideways. It stops, in the words the plan carries for exactly that case.

A stop that was designed for is reported in plain language. A stop that wasn't is reported as a failure, with the technical detail kept for whoever has to fix it. It is never dressed up as a result.

In regulated work it collects, tracks, reminds, escalates to a human and reports status. It does not advise, decide a case, or file anything. That boundary is written into the process as a standing decision, so it is visible in the diagram and checked like anything else.

Nothing here depends on a model choosing well in the moment. The structure is fixed and proven first; the models fill in the parts that genuinely need judgment, and each one is checked.