Why sessions lose the work
Agent sessions end. Context windows fill, conversations close, the work stops on Friday and resumes on Monday. What survives is usually a summary: the agent's own account of what it did. By Monday the summary is the only record, and nobody can check it. The new session inherits testimony and calls it context.
The result is the Monday-morning tax. Careful builders re-run the important steps because the summary cannot be verified, or worse, they build on an unchecked record and discover the error three sessions later. Sessions are a fact of agent work. Losing the work at every boundary is a choice of record-keeping, not a law of nature.
The session bridge: receipts plus working state
Continuing across sessions needs two things saved outside the session. First, the ordered verifiable execution receipt chain: one receipt per completed tool call, minted at execution time by the system that ran the calls. Second, a compact working-state note: the goal, the plan, decisions made, approaches that failed, and the concrete next step.
The receipts are the checkable record of what ran. The note is the human-readable direction. Together they are the complete resume packet, and both are small. The receipts live in storage that outlasts any session; the note can be a few lines. Nothing about the next session requires it to be the same model, the same vendor, or even the same framework.
How the next session starts: verify first, then resume
- Load the receipt chain. The stored receipts for the task, in sequence order.
- Recompute every commitment. Each receipt's SHA-256 commitment is recomputed from its canonical input and output bytes. A match means the recorded call is exactly what ran.
- Check the sequence for gaps. A missing call shows up as a visible gap, so nothing from the previous session can vanish silently.
- Read the state note for direction. Goal, plan, decisions, next step. The note says where to go.
- Resume from the verified frontier. The session continues from the last verified step, and its own calls extend the same chain.
Verification is mechanical, not a judgment call. Anything that fails is re-run or discarded, not inherited. The new session does not trust the old one; it checks it.
Proven across independent implementations
The mechanism has been demonstrated across fully independent implementations. An independent AER-1 interop run checked a receipt chain end to end on an independent implementation against real external values, and the full chain was double-verified. Session bridges use the identical property: evidence minted by one system, checked by another, with no shared platform and no mutual trust. Independent implementations are tracked in the public AER-1 registry.
The honest boundary
Receipts prove what ran, not that the plan still holds. A week-old session bridge carries verified facts about executed calls, but the goal may have changed, the codebase may have moved on, and the old plan may no longer be the right one. The receipt chain answers "what actually happened." Whether to continue, revise, or abandon the plan is still a judgment call.
Verify execution with the receipt, and keep the working-state note honest about uncertainty. The bridge guarantees continuity of evidence across sessions. Direction is still yours.
Check one yourself
The live demo runs one real tool call and mints a real verifiable receipt, free, no signup. That receipt is the same object a session bridge is built from. Inspect it, recompute the commitment, and you will have run the verification step any new session performs before resuming.