Verifiability is necessary but not sufficient for trust
Being able to check an output after the fact is not the same as being able to trust the process that produced it.
There is a comfortable idea, common in discussions of machine intelligence, that if you can inspect one run you can trust the system. Show me the citations, the tools it called, and the path it took, and I will believe what it does. This idea is half right.
Verifiability is not optional. Functionary records execution lineage for successful blocks: the block, its inputs, configuration, timing, and model or prompt hashes where applicable. Extraction blocks can also attach source passages to structured findings. That does not make every sentence of later synthesized prose claim-level grounded, and it does not prove the next run will be correct. It gives you evidence to inspect.
What a trace cannot tell you
Here is the problem with stopping at verifiability. A captured run can tell you what happened once. By itself, it says little about the next input or the next nondeterministic choice.
Consider work that changes shape every time it runs, lives in one person’s private account, and produces a defensible result today by means no one can study tomorrow. You can approve each output and still be unable to improve the thing that produced it. The problem is not that discretion happened. The problem is that it was not captured as organizational evidence.
Trust requires more than the ability to check. It requires ownership, legible authority, deliberate review, and evidence about where behavior is stable or variable. These are properties of a maintained process, not of any single output it happens to emit.
Explaining an improvisation
Much of what travels under the banner of explainable AI stops at a trace. Here is what the model did this time. That is genuinely useful. A captured AgentRun preserves prompts, tool activity, partial output, and results so the event can be reviewed and compared with later runs.
An event is not yet a durable program, but it can reveal one. Repeated runs show which choices recur, where the agent needs more context, and which outputs deserve a schema or gate. Capturing improvisation is therefore the first step toward formalization, not something the product should dismiss.
The declared flow
Functionary puts captured runs and a declared flow in the same project. An executable Sketch gives discretion a durable place, instructions, and ceilings. Typed blocks declare narrower inputs, outputs, effects, and discretion. Both remain visible on the canvas, and both can be changed deliberately.
Verification can establish that a particular result or structure passed the checks you chose. It cannot certify every future output of a nondeterministic model or external system. The declared flow tells you where variation and authority live, which checks apply, and what has changed between versions.
The practical consequence shapes the whole product: capture the freestyle work, study it, and progressively replace opaque in-the-moment choices where evidence supports a narrower implementation. Trust is not a switch thrown after one verification. It is a gradient made legible by the flow, the run record, and the review policy together.