cert_hash: null.
Badge: green.
That’s how it started.
The SDK came back fast. Sub-second. 200 OK. Clean JSON. No missing fields. Frontend dropped it into the UI like it had always belonged there. No shimmer. No warning. Just a confident slab of text with a green check next to it.
Consensus finalization?
Still running.
But my UI doesn’t speak consensus.
It speaks status codes.
So I shipped it.
That’s the bug.
If you scroll through Mira’s logs, you can actually watch the answer getting pulled apart in real time. Claim decomposition assigns fragment IDs. Evidence hashes attach themselves like barnacles. The validator mesh fans the workload out across the network. Weight accumulates. The supermajority line just sits there, waiting to be crossed.
My app?
Didn’t wait.
I wired the integration to stream. Provisional first. Certificate later. It felt clever at the time — keep the interface alive, don’t trap users behind spinners, make it feel instant.
I even cached the first payload for 60 seconds so the badge wouldn’t flicker.
Why 60?
Because it sounded responsible.
I never said this part out loud, but I assumed the certificate layer would catch up before anyone treated the text like it was final.
It didn’t.
The answer hit the page.
Someone copied it.
Dropped it into a doc.
Forwarded it.
Once that happens, it’s not yours anymore.
I open the auditable logs. Wrong filter. Back. Open again.
At this point I’m not debugging Mira. I’m debugging my optimism.
Fragment 3 is the drag.
A numeric assertion. Harmless-looking inside a paragraph. The kind of thing nobody double-checks until they have to.
One validator abstains.
Two vote green.
Weight uneven.
No divergence alert.
No red banner.
Just a round that refuses to close.
Abstain doesn’t scream. It just keeps cert_hash null while my badge stays green.
Behind me, the rack fan kicks up half a notch. I only notice because I’m staring at the one field Mira won’t give me:
cert_hash: null.
And my application is already treating the response like it’s sealed because I taught it a lazy rule:
API success = verified.
I never once required the thing Mira is actually selling — the certificate.
A user refreshes.
Cache TTL rolled, so the SDK calls again.
Same prompt. Slightly different phrasing in clause two. Not a new conclusion — just different scaffolding. That’s enough. Mira segments it again. New fragment IDs. The first round is still hanging open.
Now there are two provisional outputs circulating.
Two versions in the wild.
Zero certificate hashes to anchor either one.
The validator mesh does what it’s designed to do. It shifts attention to the live fragments. Economic validators follow relevance. The new round becomes the center of gravity.
The first round doesn’t fail.
It just… thins out.
Drifts below urgency.
And my UI keeps showing “Verified” because I never asked for proof of verification — only proof of delivery.
---
Here’s the part only integrators feel:
Support can’t reproduce it.
By the time they run the same prompt, the certificate exists. Screenshot says “Verified.” Logs from the moment of capture say “pending.” Everyone looks wrong. No one has a cert hash to anchor the screenshot.
That’s when the SDK channel lights up:
“Why did this answer change?”
Because I let application latency outrun consensus finalization.
I optimized for responsiveness and treated it like assurance.
In my head, “real-time” meant “settled.”
In Mira’s world, it means “running in parallel.”
Fragment 3 clears later.
A certificate prints.
Different output hash than the second provisional run. Of course it is. The bytes changed. Mira signs bytes, not intentions.
Two rounds.
Two artifacts.
Two valid certificates — inside their own boundaries.
Meanwhile my frontend is still caching the first response because the cache key is embarrassingly simple:
api_ok = true → render → move on.
No model fingerprint.
No cert_hash gating.
Nothing that forces the UI to wait for finality.
So I fixed it.
The badge now checks one thing before it ever says “Verified”:
cert_present = true.
That’s it. No philosophy. Just a boolean.
It adds a beat. UX hates it immediately. There’s a visible pause now before the green check appears.
Support won’t hate it.
It costs milliseconds.
It buys auditability.
04:01 PM. Another query streams in.
Payload arrives.
cert_hash: null.
The badge waits.
And this time, so do I.
