I built FreshCtx to stop stale agent actions. Then I found a harder failure: the action still happened.
A couple of weeks ago I posted FreshCtx here.
The problem was pretty narrow:
an agent reads a balance, approval, inventory level or some other live state, makes the right decision, and then reality changes before the action executes.
FreshCtx revalidates the evidence at the action boundary.
That part worked.
But the discussions here exposed a problem I couldn't stop thinking about.
What if the control is correct, but the action still happens?
Imagine this:
The agent decides to make a payment.
FreshCtx checks the evidence.
Or a human approves the action.
The tool runs.
The payment succeeds.
Then the response times out.
The agent sees:
PAYMENT FAILED
Reality says:
PAYMENT HAPPENED
What should the agent do now?
Retry?
If it retries, you may have two payments.
And that made me realize FreshCtx shouldn't try to solve everything.
FreshCtx asks:
Is the evidence behind this action still current right before execution?
I built a separate product for the next question.
It's called Revera.
Revera asks:
What actually executed, what effect can we establish independently, and if we fix the problem, can we prove the same execution path now behaves correctly?
The flow is roughly:
discover → reproduce → observe → diagnose → remediate → exact retest → evidence
One rule became important while building it:
The system under test should not be the only authority on whether its own action succeeded.
If the agent says the action failed but the external effect occurred, I want both facts preserved.
If we can't establish what happened, I would rather see UNVERIFIABLE than manufacture a convenient answer.
Revera is live now:
https://reveralab.com
I'm looking for a small number of people building agents that actually change something:
payments, infrastructure, customer records, access, deployments, bookings, approvals, workflows.
I don't need a polished integration.
Give me one consequential action or one public repo and let's see what Revera can actually establish.
And I'm particularly interested in cases where you think it will fail.
Question for builders here: what is one action in your agent that you would absolutely not trust it to retry blindly?
The failure mode is much more consequential than stale context, but the key signal seems to be whether it shows up in real agent systems. Have builders brought you actual incidents where execution and reported outcome diverged, or is that still the hypothesis you’re trying to validate?
One clarification because I know the obvious question will come up:
Revera is not meant to replace observability or tracing.
A trace can tell me that the agent called charge_customer and received an error.
The question I'm interested in is whether the customer was actually charged.
That distinction sounds small until an autonomous agent decides whether to retry.
If anyone has a public repo where this kind of ambiguity can happen, send it over. I want the first external runs to be systems we didn't build.