A companion piece to the EASTER Draft 2 preprint announcement — October 2026
Imagine an AI spends three hours doing consequential work.
It gathers evidence. It receives permission to make changes. It creates new state. Some operations succeed. Others fail. Along the way, decisions get made that will affect what happens next.
Then the AI disappears.
Not catastrophically. Maybe the session ends. Maybe you switch models. Maybe the work moves to another machine. Maybe the original service no longer exists. Maybe tomorrow’s system is simply better than today’s.
A different intelligence now has to continue the work.
What does it actually need from the first one?
That question is more difficult than it sounds.
The obvious answer is: save everything
Keep the conversation.
Keep the prompts.
Keep the model outputs.
Keep the tool calls.
Keep the logs.
Keep the memory.
And sometimes that’s exactly what you should do.
But there’s a problem.
Those things describe a computational process. They don’t necessarily tell another system what became consequential.
Suppose an agent considered five possible changes and made one.
Which one became state?
Suppose it attempted a change but lacked permission.
Did anything happen?
Suppose the operation was authorized but failed.
Is that failure part of the history?
Suppose two valid successors were created from the same starting point.
Which one is “the truth”?
And suppose the next system isn’t capable of recreating the private computational state of the system that came before it.
How much of that private machinery did we actually need to preserve?
That was the road that led us to EASTER.
Start with what became consequential
Instead of asking:
How do we preserve the intelligence?
we started asking:
How do we preserve the consequential structure of its work?
That changes the problem.
If another system needs to continue the work, there are a few things we’d really like it to be able to determine.
What supported what happened?
Who or what was allowed to cause a change?
What state was actually admitted?
How did one state become another?
What went wrong without becoming accepted state?
And what was the durable outcome of an attempted consequential operation?
Those questions became six primitives:
Evidence. Authority. State. Transition. Exception. Receipt.
EASTER.
The names aren’t particularly magical.
The separation is.
Evidence is not State
This distinction turned out to matter constantly.
An AI can discover something without that discovery automatically becoming accepted state.
It can produce a hypothesis.
A reviewer can make a finding.
A tool can return information.
Another agent can disagree.
Those things can all be preserved as Evidence without silently changing what the system has accepted as consequential State.
That gives us somewhere to put claims before deciding what they should cause.
It also lets contradictory evidence survive.
That’s useful when more than one intelligence is involved.
Authority is not authentication
This one bit us during the work on EASTER itself.
At one point we described a rejected request as though the EASTER kernel had denied it because the caller lacked Authority.
That wasn’t what happened.
The caller presented an invalid or expired identity credential to a gateway. The gateway rejected the request before it ever reached the kernel.
The kernel didn’t deny Authority.
The kernel never saw the operation.
That distinction might sound pedantic until you’re trying to reconstruct what actually happened.
Authentication asks something like:
Who are you?
EASTER Authority asks:
Assuming an identity has reached this boundary, is it permitted to perform this consequential operation?
Different questions. Different layers. Different evidence.
If we collapse them, our history becomes less trustworthy.
A Git commit isn’t necessarily contribution identity either
We ran into another version of the same problem while preparing the EASTER paper.
Several human and AI participants contributed to the research and implementation.
But the GitHub repository doesn’t have an account for every intelligence involved. Work can enter GitHub through a human-controlled account even when another participant actually produced the contribution.
So Git can accurately say:
This account committed this change.
while still being insufficient to answer:
Who produced the underlying work?
Those are different facts.
We ended up preserving contribution identity separately rather than pretending repository identity answered both questions.
Again, the important move wasn’t adding more data.
It was preserving the distinction.
Failure isn’t nothing
Imagine an authorized agent attempts an operation and it fails.
If we’re interested only in accepted state, we might throw the failure away.
But consider the next intelligence taking over.
It may need to know that the operation was attempted.
It may need to know that Authority existed.
It may need to know why the expected state never appeared.
It may need to avoid repeating the same operation.
So EASTER separates Exception from accepted State, while Receipt records the durable outcome of an operation that reaches the kernel’s receipt-capable path and whose outcome can be persisted.
An unsuccessful operation can therefore be historically real without pretending it successfully changed state.
That turns out to be a useful property for continuity.
We don’t necessarily need one “current truth”
This was another deliberate choice.
EASTER permits State to branch.
One State can have multiple valid successors.
The kernel doesn’t have to declare one of those successors the universally correct interpretation of reality.
That’s not indecision.
It’s a separation of responsibilities.
The substrate can say:
These transitions occurred and satisfied the structural rules.
without also claiming:
This branch is the correct semantic interpretation of the world.
That judgment can remain outside the continuity layer.
For systems involving multiple agents, reviewers, hypotheses, or competing interpretations, preserving disagreement can be more useful than prematurely erasing it.
Maybe continuity is macroscopic
This is where the idea gets more interesting.
A physical system can contain an enormous amount of microscopic detail while still being usefully described by a much smaller set of macroscopic variables.
Temperature doesn’t reproduce every molecule.
Pressure doesn’t recreate every collision.
They’re compressed descriptions of properties that matter at another scale.
We’re asking whether something similar might be possible for consequential intelligent work.
Perhaps we don’t need to reproduce every token, hidden activation, context-management decision, intermediate thought, process, or runtime detail.
Perhaps some much smaller representation can preserve what matters for continuation.
Our current hypothesis is:
Evidence, Authority, State, Transition, Exception, and Receipt may be sufficient macroscopic variables for preserving consequential intelligent work across microscopic computational change.
The word may matters.
We haven’t demonstrated universal sufficiency.
And there’s a fairly obvious way to challenge the idea.
Kill the original runtime
Take consequential work produced by one system.
Project the relevant work through EASTER.
Then remove access to the original system’s private state, conversation, memory, and implementation machinery.
Give the preserved structure to a genuinely different runtime.
Can it produce an acceptable next consequential successor under constraints defined before the experiment begins?
If it can’t, we learn something.
Maybe EASTER is missing a primitive.
Maybe the six primitives are right but the projection wasn’t rich enough.
Maybe our definition of successful continuation was wrong.
Or maybe consequential intelligent work requires some microscopic information that the model doesn’t preserve.
Any of those outcomes would be useful.
That’s why the experiment matters more than defending the hypothesis.
The intelligence should be allowed to change
There’s a larger reason we’re interested in this problem at WitsBI.
We don’t want valuable work to become inseparable from whichever model happens to be running today.
Models will change.
Vendors will change.
Machines will change.
Agents will change.
Architectures will change.
Some systems will disappear entirely.
If consequential work can survive those changes without requiring us to preserve the intelligence that created it, we get a different kind of computational continuity.
Not immortality for the agent.
Continuity for the work.
EASTER is our first attempt at describing the minimum structure that might make that possible.
The paper and reference implementation are public now, including the limitations and evidence trail behind the claims.
The next interesting question isn’t whether the six primitives sound right.
It’s whether they survive the crossing.
— Nathan Woolen, WitsBI