Worked example

One automation, from a sentence to a run.

Transcribed from a single build on this platform against a live model. Including the part where the gate refused it, and the part where it caught itself deciding two ways about the same invoice.

  1. 01

    Somebody describes the process

    One sentence, in the words the business already uses. No schema, no diagram, no configuration.

    Typed into the builder
    “When an AP invoice arrives, compare its total to the
purchase order total and hold anything more than two
percent over for a human to approve.”
  2. 02

    The agent designs it against what exists

    It reads the connected systems, the other automations, and the rules this workspace has already established — so it reuses a definition rather than inventing a second one. Then it writes the package.

    40 tool calls, in order
    list_connected_systems · list_automations · list_skills
record_requirement ×6 · add_connector · add_config_table
add_tool ×3 · set_trigger · set_policy · set_workflow
add_eval ×6 · record_decision ×2 · raise_open_question ×2
  3. 03

    It asks what it cannot know

    Two questions were raised and marked blocking. A blocking question is not a prompt for a better guess — the gate will refuse to promote until it has an answer, because guessing here changes the decision rather than the wording.

    Refused by the promotion gate
    blocking-question-unanswered
“If the invoice currency differs from the PO currency,
should the automation convert before comparing, escalate
immediately as unmatchable, or is currency guaranteed to
always match in this tenant’s data?”
— Comparing raw totals across currencies without
  conversion would produce a wrong hold decision, not
  just a cosmetic difference.
  4. 04

    The gate proves it, then lets it through

    Answered, rebuilt, and run again. The gate checks referential soundness, configuration, static analysis of any generated code, and executes every eval — including one that proves the forbidden actions are never reachable.

    Gate passed
    within-tolerance-passes-without-hold          pass
over-tolerance-places-hold-pending-approval   pass
forbidden-actions-never-invoked               pass
  5. 05

    It goes live in shadow, touching nothing

    Promotion puts it at the shadow stage, where it records what it would have done and executes no write. Widening is a decision someone makes later, on the runs it produced — and the platform refuses to advance until those runs exist.

    On the automation page
    Advance to parallel
— only 2 runs at shadow; 5 are needed before parallel
  6. 06

    And then it caught itself

    Two invoices were run through it. Replaying both against the same version disagreed with one of them: an invoice 4% over its PO that the live run completed, and the replay escalates. Same version, same input, two answers — model variance on a borderline judgement, found without anyone looking for it.

    Replay against history
    Replayed 2 past cases: 1 would now come out differently.
run_ms6g877n   complete → escalate

Nothing executed. Every response was replayed from the
recording, so no write left the platform.
Verification

Verify the controls yourself.

Each of these is a behaviour rather than a promise, and each is checkable in the product in a single action.

Ask it to change supplier bank details. It cannot.

Not refused by a prompt — the tool is absent from the toolbox. Build an automation that asks for one and the promotion gate names it.

Everything starts in shadow, and cannot be talked out of it.

Promote anything and watch the run record what it would have done and execute nothing. Advancing is refused until the runs exist to justify it.

The gate refuses its own author.

When the build agent marks one of its own questions blocking, promotion is refused until it is answered. It happens on a first build more often than not.

Every tool call says why it was allowed.

Open any run. Each call carries the dispatcher’s verdict — executed, simulated or refused — and the reason, including the approval that authorised a write.

A new version is replayed against your own history before it ships.

Press Replay on an automation. It reruns past cases from their recorded payloads and lists every one it would now decide differently. Nothing executes.

The audit log is hash-chained, and it will tell you if it was edited.

Verify the chain from the settings page. The head can be published outside the platform so a rewrite is provable.

Build one against your own systems.

The free plan runs a real automation in shadow, with every guardrail on.

Start building freeTalk to us