Replay any decision from its inputs.

Four artefacts, one source

Audit and replay are not a logging layer you bolt on. They fall out of how the processor is generated:

Generated dispatcher

The executable specification of the decision graph, as readable Java. The graph the reviewer inspects is the graph that runs — there is no separate runtime interpreting it.

Structured audit record

Per event: what fired, in what order, and the per-node detail — generated from the graph, not instrumented by hand.

Event log

The captured inputs. The decisions are a pure function of these plus the approved processor.

Replay

Feed the captured events back through the same approved build and reproduce the same decisions — with the evidence to show it.

What a record looks like

One event in, one structured record out — the event, its readable form, and the ordered path it fired through the graph. This is the literal output of the generated processor (the same record the in-browser tester shows):

eventLogRecord:
    eventTime: 1782069063783
    event: PriceUpdate
    eventToString: PriceUpdate{symbol=BTCUSD, price=1.987}
    thread: main
    nodeLogs:
        - eventBridge:  { method: onPriceUpdate }          # decoded the input
        - riskCheck:    { method: assess, withinBand: true }
        - rootNode:     { method: onPriceUpdate, decision: ACCEPT }
    endTime: 1782069063784

A reviewer reads the path; an auditor keeps the record; the test fixture replays against it. One mechanism serves compliance, debugging and regression.

How replay works

1. 1
   Capture the event log — the ordered inputs the processor saw.
2. 2
   Replay those events through the same approved processor build.
3. 3
   Compare the decisions: same inputs + same approved processor → the same decisions, with the records to prove it. A divergence is a diff you can point at.

Because dispatch order is fixed at compile time rather than decided at runtime, replay is a structural property of the generated processor — not a feature wired in afterwards.

What it requires

Audit and replay are supported by the generated structure, but they are not magic. Honest reproduction depends on:

• capturing the event log — replay is only as good as the recorded inputs;
• the same approved processor build (version the artefact like any other release);
• deterministic inputs — external side effects, clocks and I/O belong at the shell, not in the decision core;
• appropriate runtime setup for the replay pass.

The point is not that correctness is automatic. It is that the decision is made testable rather than trusted: you can re-run it from its inputs and inspect the path.

Run it yourself

Don't take the claim on faith — drive a processor, watch the audit record build, and replay a decision from its inputs, in your browser:

Why it matters for regulated and agentic-AI processes → Agentic AI you can defend.