RIFT
Your AI failed. You fixed it. How do you know? An AI agent makes the wrong decision in production.
You change the agent.
The tests pass.
You ship it.
But there is one problem:
You may never have tested the situation that actually caused the failure.
By the time you investigate a production incident, the data has changed. The tool state has changed. The context has changed. The agent may have changed too.
The failure is gone.
And if you can't recreate the failure, you're not really proving the fix.
You're guessing.
Bring the failure back.
RIFT captures the world behind an AI failure and brings that world back so the original decision can be reproduced, investigated, fixed, and verified.
Not a similar test.
Not a synthetic example.
The exact incident world.
Here's what that looks like.
An AI agent is asked to process a pending refund.
Two refunds are worth $80.
One is completed.
One is pending.
The agent chooses the completed refund.
Wrong decision.
Now the live state changes.
The original situation is gone.
This is where RIFT takes over.
It captures the incident and freezes the relevant world that produced it: the data, context, tools, and agent trajectory.
The evidence is sealed.
Then RIFT brings that world back.
The original agent runs against it.
Same world. Same decision. Same failure.
Now the failure can actually be investigated.
The agent matched the refund by amount and ignored its status.
So the agent is fixed.
RIFT runs the new version against the same frozen incident.
Pending refund selected.
The fix survives the exact failure that caused the incident.
Then RIFT attacks its own evidence.
Because a release decision is only as trustworthy as the evidence behind it.
RIFT tampers with the frozen world.
The integrity check fails.
The evidence chain breaks.
Release blocked.
Restore the valid evidence.
The complete chain passes again:
WORLD INTEGRITY PASS
FAILURE REPRODUCED PASS
FIX VERIFIED PASS
EVIDENCE CHAIN PASS
DEPLOYMENT RELEASED
That is the point of RIFT.
It doesn't tell you that a fix looks good.
It doesn't ask an AI to decide whether an AI fix is safe.
It creates a boundary:
An AI change cannot be considered production-safe until it survives the exact world that produced the incident.
From failure to proof
RIFT turns an AI incident into an evidence chain:
FAIL → CAPTURE → FREEZE → RECONSTRUCT → REPRODUCE → DIAGNOSE → FIX → VERIFY → RESOLVE → RELEASE
The final evidence package preserves the entire story:
Original failure Frozen world Reproduction Diagnosis Fix Verification Integrity proof Resolution Release status So when someone asks:
“Did you actually fix it?”
RIFT can show them.
How are you capturing state?
No proxy. No cassettes. No interception.
RIFT owns the world the agent runs in — an in-memory SQLite database. Before the agent moves, RIFT snapshots every row, every table. When it's done, it snapshots again.
Before and after. Exact.
python recorder.initial = shop.snapshot() # before recorder.final = shop.snapshot() # after
The live world can change. RIFT doesn't care. It already has the world that mattered.
How do you freeze the trajectory?
Every tool call. Every result. In sequence.
{ seq: 1, tool: "lookup_customer", args: { name: "Sarah Chen" } } { seq: 2, tool: "issue_refund", args: { refund_id: "R91" } }
One frozen artifact. World state, event log, task, system prompt, agent version.
Not a reconstruction. The exact context the agent was in when it failed.
How does the integrity check work?
SHA-256. Over everything.
Task, agent version, initial state, every event, final state — canonically serialised, keys sorted, whitespace stripped. One hash.
If a single byte changes, the hash breaks. The replay refuses to run. The release is blocked.
python if not verify_world(frozen): raise ValueError("freeze hash mismatch — evidence tampered")
Not a warning. A hard stop.
What's the tech stack?
Python. Stdlib only.
sqlite3. hashlib. json. urllib.request. copy.deepcopy.
No LangGraph. No AutoGen. No LangChain. No frameworks.
The LLM makes one call. Returns one JSON object. RIFT takes it from there.
Everything else — investigation, freezing, replay, gating — is deterministic code.
The model gets to make the mistake.
RIFT decides whether it happened.
Why this matters AI systems are moving from generating answers to taking actions.
When those actions affect customers, money, data, or real-world systems, “the model behaved strangely” is not a sufficient incident response.
You need to know:
What happened?
Why did it happen?
Can I reproduce it?
Did the fix survive the original failure?
Can I trust the evidence?
Should this change be released?
RIFT connects those questions into one verifiable loop.
A trace tells you what happened.
A test tells you what happens under a test.
RIFT brings back the world that made the failure happen.
Then it proves the fix survived it.
Built for the failure that already happened
RIFT was built around one uncomfortable observation:
Production failures don't wait for your test suite.
When the world changes, the incident becomes harder to reproduce.
RIFT makes the incident itself the test.
And the result isn't another dashboard.
It's a release decision backed by evidence.
Failure reproduced. Fix verified. Evidence verified. Release authorized.
