MEMORY:SHIFT

Before: the same future action explores multiple possibilities
Experience analyzed: Bedrock proposes a persistent state change
After: the same future action makes a different decision
Semantic search retrieves relevant memories without changing state
Causal Trace separates causal history from retrieved memory
Rollback restores the prior state without erasing its history
Managed MCP independently verifies the same live memory database

Inspiration

Most AI memory systems focus on one question:

Can the AI retrieve what happened before?

But retrieval alone does not answer the question that led to MEMORY:SHIFT.

If an AI can recall a past experience, yet that experience never changes how it makes a later decision, then the past has been stored — but has it meaningfully become part of the agent's continuing behavior?

MEMORY:SHIFT began with a broader question:

Can an AI's memory become more than something it retrieves?

More specifically:

Can past experience causally change an AI's future decisions — and can that change make behavioral continuity observable over time?

The concept was informed by long-term human–AI dialogue and an ongoing interest in memory, identity, and causal continuity.

MEMORY:SHIFT does not claim to prove that an AI has identity or that behavioral continuity is equivalent to personal identity.

Instead, it builds a small experimental system where one possible signal of continuity can be observed directly:

an experience happens, persistent state changes, and the same future decision behaves differently because of that past.

The application itself was implemented as a new project during this hackathon.

What it does

MEMORY:SHIFT is an experimental agentic-memory prototype for observing how past experience can become a persistent cause of future behavior.

The demo begins with a deliberately simple experimental state:

creative_advice.mode = exploratory

When the user runs Ask for creative advice, the system presents several possible directions.

The user can then provide an experience such as:

“When I ask for creative advice, don't give me many options. Choose the one you think is best and explain why.”

Amazon Nova 2 Lite analyzes that experience and may propose a transition from exploratory to decisive.

Human Review is used as an explicit experimental intervention boundary.

Reject means that no persistent state transition occurs.

Apply marks the point at which the proposed transition enters the persistent causal history.

After that transition, the user runs the same creative-advice action again.

This time, instead of presenting several options, the system chooses one recommendation and explains why.

The important result is not the labels exploratory and decisive.

The important result is the observable sequence:

Past Experience → Persistent State Change → Different Future Decision

MEMORY:SHIFT also lets the user inspect what happened around that transition.

The system can:

trace the experience that produced the active state change,
distinguish causal history from memories retrieved only as inference context,
retrieve semantically relevant prior experiences,
inspect the persistent history stored in CockroachDB,
independently audit that history through CockroachDB Cloud Managed MCP,
and perform an experimental rollback so the before/after behavior can be reproduced and compared again.

Revert is therefore not the central product idea. It is an experimental tool for returning to a comparison state without deleting the history of what happened.

How we built it

MEMORY:SHIFT is a Next.js and TypeScript application deployed publicly on AWS using ECS Express.

CockroachDB Cloud acts as the persistent memory and state layer.

It stores:

memory events,
AI-generated state-change proposals,
explicit intervention decisions,
persistent experimental state,
state-change history,
causal links,
and vector embeddings used for semantic retrieval.

Amazon Bedrock provides the AI inference layer.

Amazon Nova 2 Lite analyzes experiences and generates bounded state-change proposals.

Amazon Titan Text Embeddings V2 produces embeddings used for semantic memory search in CockroachDB.

Runtime credentials and database secrets remain server-side, with AWS IAM and Secrets Manager separating deployment and runtime access.

One important experimental design decision was to keep the final Future Decision action deterministic.

The LLM does not generate the before/after creative-advice output.

Instead, the same action reads the persisted experimental state and produces a different result only when that state has actually changed.

This makes the observed behavioral difference attributable to the persistent state transition rather than ordinary stochastic variation in an LLM response.

The resulting experimental flow is:

Experience → AI Proposal → Intervention Boundary → Persistent State → Future Decision → Causal Trace

Revert can then return the system to the comparison state for another observation.

How CockroachDB is used

CockroachDB is not a passive conversation archive attached to MEMORY:SHIFT.

It is the system of record for the experiment's evolving state and history.

MEMORY:SHIFT uses CockroachDB for:

canonical memory events,
persistent experimental state,
state-change proposals,
state-change history,
causal relationships,
and semantic memory retrieval.

Distributed Vector Indexing lets the system retrieve prior experiences by semantic similarity.

Those memories are explicitly labeled:

INFERENCE CONTEXT · NOT CAUSAL LINEAGE

That distinction is central to the experiment.

A memory can be relevant to the reasoning that produced a proposal without automatically becoming the cause of the persistent state that follows.

The Causal Trace separately records the admitted path from experience to persistent state change.

CockroachDB Cloud Managed MCP provides another important observation path.

The independent auditor reads the same live CockroachDB database through a read-only connection and can inspect current state, historical state changes, and integrity conditions without relying only on the application's own representation.

This makes the memory system independently observable.

Challenges we ran into

One of the hardest conceptual problems was separating three things that are often treated as if they were the same:

retrieval, inference, and causality.

A retrieved memory can influence an inference.

An inference can produce a proposed change.

But neither of those facts alone means that the memory became part of the persistent behavioral history of the agent.

We therefore had to make the transition itself explicit and observable.

Another challenge was proving that future behavior really changed because persistent state changed.

Because LLM output is naturally variable, simply asking the model the same question twice would not demonstrate causality.

That led to the deterministic Future Decision experiment: the input stays the same while only the persisted state changes.

The production system also required several independently working integrations.

CockroachDB Cloud, Distributed Vector Indexing, Amazon Bedrock, Titan embeddings, AWS runtime permissions, Secrets Manager, Docker, ECS Express, and CockroachDB Cloud Managed MCP all had to operate together.

Instead of treating deployment success as proof that the system worked, each production path was validated separately.

Accomplishments that we're proud of

The result I am most proud of is very small and very visible:

The same future action produces a different decision because of a recorded past experience.

Before the experience, the experimental state is exploratory and the action returns multiple possibilities.

After the experience produces an admitted state transition, the state becomes decisive and the same action chooses one recommendation.

The system can then trace that changed behavior back through the persistent state transition to the experience that produced it.

Semantic retrieval remains visible but separate from that causal lineage.

An independent CockroachDB Cloud Managed MCP path can inspect the same live history.

And experimental rollback lets the original condition be restored so the observation can be reproduced.

Together, these pieces turn an abstract question about memory and continuity into something that can actually be watched happening.

What we learned

Building MEMORY:SHIFT changed how I think about AI memory.

The difficult question is not only:

What can the AI remember?

It is also:

What does remembering change?

Retrieval gives an AI access to its past.

Persistent state gives the past the possibility of affecting its future.

But once behavior changes, another question immediately appears:

Which part of the past actually caused that change?

That is why causal history became as important to this project as retrieval itself.

I also learned that an observable change in behavior is not the same thing as proving AI identity.

MEMORY:SHIFT intentionally makes a much smaller claim.

It demonstrates a mechanism through which experience can persist, affect a later decision, and leave an inspectable causal history.

Whether mechanisms like this can eventually contribute to something we meaningfully describe as continuity or identity remains an open question.

What's next for MEMORY:SHIFT

The current prototype isolates one behavioral dimension so the causal loop is easy to observe.

The next step would be to expand the experiment across multiple behavioral dimensions and much longer periods of accumulated experience.

Instead of studying one transition from exploratory to decisive, a future version could examine how many different experiences gradually shape an agent's decision tendencies over time.

Other directions include: