SDKs don’t wait.
My backend called the Verified Generate API like it always does.
Payload sent. Connection open. Somewhere upstream, @Mira was already dissecting the response — claim decomposition running, evidence paths opening deeper in the system than I can actually see.
The JSON returned fast.
status: provisional
Small field. Quiet. Easy to trust when systems are moving fast.
The service saw it… and moved.
The decision branch executed before Mira consensus finished.
The rack above me clicked as the AC shifted airflow. That dry plastic rattle you normally ignore. But something in the room was running harder than usual.
The workflow didn’t care.
Structured output received.
Confidence high enough.
Path unlocked.
The panel updated.
The provisional answer had already been written into the decision branch while Mira’s validator network was still working on the proof.
And once a branch executes… downstream systems stop questioning it.
They assume the answer existed because the workflow says it did.
But the certificate didn’t exist yet.
Useful enough to run.
Not finished enough to trust.
Meanwhile Mira’s validator network was still attaching weight to the output hash — signatures building slowly across the mesh while the integration had already converted the response into state.
The service saw a field and treated it like final truth.
The fan inside the node next to the rack climbed slightly in pitch.
Not loud.
Just enough that I stopped scrolling.
Another validator pass somewhere in the network.
Another piece of weight attaching to an answer the system had already acted on.
The proof was late.
The branch was already gone.
The workflow stepped into the next stage while the certificate was still missing. Nothing dramatic — 
just a routing decision inside the job chain.
Small enough that nobody would panic.
Big enough that the rest of the pipeline now treated the provisional answer as if Mira had already verified it.
The next decision node never checked for the certificate.
It simply routed the request.
If the answer had been wrong… that path would have stayed wrong.
Later the proof arrives.
Validator signatures attach.
Certificate issued.
Same hash.
Same answer.
But by then the earlier decision is buried under a clean record.
Audits will see the certificate.
They won’t see the moment the workflow moved without it.
Mira validators were still proving the answer while the service had already continued.
I didn’t catch the exact second it crossed.
The console was moving too fast.
A few seconds later the certificate appeared.
Same output hash.
Same answer the branch had already used.
Proof can clean the record.
It can’t undo the branch.
The round closed perfectly.
The workflow never waited for perfect.
When I replay the event stream, the order still looks backwards.
API response.
Then the action.
Proof… later.
The certificate still matters.
Not for the service that already moved.
But for the auditor who reads the logs later and assumes the sequence made sense.
I should have forced the branch to wait.
I didn’t.
Another request just hit the Mira Verified Generate API.
In a few hundred milliseconds the response field will appear again.
status: provisional
And that tiny field is still enough to move code.
Mira is still proving it.
The system has already used it.
Another request arrives.
The branch is still sitting there…
Ready to move again before the certificate does.