
Agents for Humans: Evidence, Not Inference — How BeforeBell Proves an Agent Actually Did the Work
What building BeforeBell taught me about agent reliability: why a completion message is not proof, and how authoritative state, event ordering, revalidation, idempotency, and race-safe persistence make autonomous workflows easier to trust.
The question I kept coming back to
One question kept coming back while I was building BeforeBell:
If an agent says it completed a task, how do I know the task actually happened?
That question does not matter much when an AI is only answering questions.
It matters a lot more once the agent is allowed to change application state.
If a chatbot gives me a bad answer, I can ignore it.
If an operational agent says a teacher has been assigned to a class when no assignment actually exists, that is a different kind of failure.
So I did not want BeforeBell's interface to treat the agent's narration as proof.
The principle I ended up using was:
Evidence, not inference.
A completion message is not evidence
BeforeBell is a school-operations agent for coordinating teacher-absence coverage.
The workflow uses the Strands Agents SDK and runs through Amazon Bedrock AgentCore Runtime, but the agent itself is not the system of record.
Authoritative application state lives in Amazon DynamoDB.
That includes assignments, coverage offers, human decisions, case state, and workflow events.
So the UI does not have to ask:
What did the agent say happened?
It can ask:
What was actually persisted?
That distinction ended up shaping much more of the system than I expected.
The final green status is not the interesting part
The clearest example is the main human-in-the-loop scenario.
Daniel Reed is absent for P2, P3, and P5.
BeforeBell safely covers P2 and P3 through routine policy. P5 crosses a protected-planning boundary, so the workflow stops and asks an administrator to choose from a bounded set of permitted options.
The administrator approves the external-substitute path.
This is where the important part begins.
It would be easy for the application to treat that approval as success and make the case look resolved.
But an external substitute has not actually been confirmed yet.
So P5 stays unassigned.
The case remains only 2/3 covered.
Approval is authorization, not execution.
The administrator has decided what the school is willing to do.
That does not mean the approved action has already happened.
Only a later trusted fulfillment step can confirm the substitute, revalidate the current state, create the assignment, and allow the case to become resolved.
The order of events is part of the proof
The final result is simple: Daniel Reed eventually becomes fully covered.
But the sequence matters more than the final status.
The application preserves an event trail like this:
06:09:00 agent human_exception_decision_requested status: waiting
06:10:00 administrator human_exception_decision_approved status: succeeded
P5 STILL UNASSIGNED authorization recorded, not execution
06:12:00 system coverage_assignment_created status: succeeded
06:12:01 system coverage_case_status_updated status: succeededThe important part is the gap in the middle.
At 06:10, the approval exists.
The assignment does not.
That means the system can answer several different questions without guessing:
- Did the agent request human judgment? Yes.
- Did an administrator approve a permitted option? Yes.
- Was P5 assigned at that moment? No.
- Did a later trusted step create the assignment? Yes.
- When did the case actually become resolved? After the assignment existed.
The application does not need to reconstruct that story from a model response.
The story is already present in authoritative state and persisted events.
That is what I mean by evidence, not inference.
Valid earlier does not mean valid now
Once I started thinking about evidence this way, another problem became obvious.
A decision can be valid when it is proposed and invalid a few seconds later.
A teacher who was available may no longer be available.
An offer may have expired.
Another workflow may already have assigned the same person.
The state may simply have changed.
So BeforeBell revalidates important actions immediately before changing authoritative state.
It does not assume that because something was safe when the plan was generated, it must still be safe when the write happens.
The same principle applies after a human decision.
Human approval matters.
Current state still matters too.
Duplicate events should not create duplicate reality
Real systems repeat things.
A webhook can arrive more than once.
A client can retry.
A network timeout can leave the caller unsure whether an operation succeeded.
An agent can invoke the same operation again.
If every repeated request can create a fresh side effect, an autonomous workflow can create duplicate reality very quickly.
That is why idempotency became part of BeforeBell's reliability model.
A repeated trusted event should not create a second assignment just because it was delivered twice.
Where the same operation is retried, the application should resolve back to the same authoritative outcome instead of inventing a duplicate one.
It is not a flashy feature.
It is exactly the kind of thing that becomes important when an agent is allowed to do real work.
A valid plan can still lose a race
There is another failure mode that has nothing to do with the quality of the model's reasoning.
Two operations can both read a state that looks safe.
Both can decide the same assignment is available.
Then they reach persistence at nearly the same time.
If both writes succeed, the model was not the problem.
The application allowed an invalid state transition.
BeforeBell protects important assignment operations with atomic DynamoDB writes so competing workflows cannot silently violate assignment invariants.
That reinforced something I think is easy to forget when talking about AI agents:
Agent safety is not only an AI problem.
A lot of it is still ordinary software engineering:
- validation;
- atomic writes;
- idempotency;
- stale-state detection;
- authorization;
- persistence; and
- tests.
Adding an LLM to a workflow does not remove those responsibilities.
If anything, giving the workflow more autonomy makes them more important.
A real event should become real state
Scenario C reinforced the same lesson from another direction.
Emma Brooks is initially the preferred coverage candidate.
She declines.
If that decline only existed in conversation history, the workflow could later behave as if she were still available.
Instead, the decline becomes authoritative state.
BeforeBell replans around it using the updated application state.
That gave me a simple rule that applies far beyond this one scenario:
A real event should become real state.
Why I kept testing the ugly paths
BeforeBell currently has 27 automated test files with 186 tests.
I did not set out to hit a particular number.
The suite kept growing because I kept asking one question:
What happens when the workflow is not as clean as the demo?
The important tests are not just about whether the happy path completes.
They cover boundaries such as stale and expired offers, acceptance and decline, replanning, idempotency, persistence, competing assignment attempts, human decisions, trusted fulfillment, and end-to-end state reconciliation.
A demo can always be arranged so events happen in the expected order.
The more interesting question is whether the application still protects its invariants when events are repeated, delayed, stale, declined, or competing.
The lesson I am taking away from BeforeBell
The more autonomous an agent becomes, the less comfortable I am with:
“The agent said it worked.”
For an operational system, there should be a clear difference between:
- what the model reasoned;
- what the agent attempted;
- what a human authorized;
- what a trusted system confirmed;
- what the application persisted; and
- what the final authoritative state became.
BeforeBell is a school-coverage prototype, but I do not think this lesson is specific to schools.
The same problem exists anywhere agents can change meaningful state.
If an agent sends money, updates an account, provisions infrastructure, changes a document, or schedules something, the final answer should not be the evidence.
The system should be able to show what actually happened.
That is the main idea I am taking away from the build:
Useful autonomy needs evidence.
Not hidden reasoning.
Not a confident completion message.
Not a green status simply because the agent said the task was finished.
Actual state.
Actual events.
Actual accountability.
Evidence, not inference.
BeforeBell was built for the Agents for Humans Hackathon 2026 using the Strands Agents SDK, Amazon Bedrock, Amazon Bedrock AgentCore Runtime, Amazon DynamoDB, Next.js, and TypeScript.
BeforeBell — Agents for Humans build series
- Article #3 — Agents for Humans: Evidence, Not Inference — How BeforeBell Proves an Agent Actually Did the Work
Enjoyed reading this content? Let the author know!
Your likes, comments, shares, and saves help creators reach more builders.
Loading recommendations
Loading article