Remember the Seasons
Tagline
What if your AI could remember, explain why, and prove what would change if a memory disappeared?
Inspiration
Nebius and NVIDIA asked us to build the next frontier of AI.
So naturally, we built an AI agent that can defend its memories under oath.
Not because AI needs a lawyer. Because it needs something surprisingly difficult: a memory you can question.
Imagine an AI assistant you've used for six months. It knows your preferences, remembers your decisions, and changes how it responds to you.
One day, it starts behaving differently.
You ask: Why?
It retrieves a few memories and gives you a convincing explanation.
But is that what actually influenced its behavior? Did it use those memories? Did it reinforce something it shouldn't have? What would happen if one particular event had never occurred?
We wanted an AI that could do more than remember its past. We wanted one whose past could be investigated.
That's how Remember the Seasons began.
What it does
Remember the Seasons gives AI agents persistent, verifiable memory — and lets you investigate how that memory changes their behavior.
It's a working system with real AI inference, cryptographic evidence, and an interactive demonstration you can explore right now.
Here's what makes it different.
1. Every answer comes with evidence
When the agent answers a question, Remember the Seasons records three different things:
- What it saw: the memories retrieved and presented to the model.
- What it says it used: the memories the model declares relevant to its answer.
- What actually changed: the memories the deterministic engine corroborated and reinforced.
These aren't automatically the same.
And that's the point.
An AI can claim it used a memory without that claim being supported by the answer. Instead of quietly accepting its explanation, Remember the Seasons preserves the distinction.
Every decision comes with a cryptographically sealed receipt.
2. Travel back through the agent's memory
Want to know what the agent remembered three weeks ago?
You can reconstruct its memory state at an earlier moment.
Not by loading an old screenshot or trusting a summary, but by replaying the recorded history.
You can inspect how memories evolved and which events contributed to the state you're seeing.
3. Ask the question other memory systems struggle to answer
What if this never happened?
Choose an event from the agent's past and remove it from a counterfactual replay.
Remember the Seasons runs the memory logic again, without that event, inside an isolated database transaction.
Then it shows you what changed.
Maybe another memory becomes more important. Maybe the resulting state changes substantially.
Or maybe nothing changes at all.
That's useful evidence too.
The system produces a sealed comparison so you can inspect the consequences of removing that event under the same replay rules.
It's a time machine for investigating AI memory — without rewriting the original history.
4. Don't trust the demo. Verify it.
The live demonstration opens with a recorded session and automatically verifies its cryptographic evidence in your own browser.
No installation. No account. No need to take our word for it.
The verifier independently recomputes hashes, checks custody chains, and validates digital signatures.
You can explore the agent's memory, inspect its decisions, run counterfactuals, and examine the evidence yourself.
How we built it
Remember the Seasons combines real open-model inference with a deterministic forensic memory engine.
The architecture has two deliberately separate layers.
The AI layer — Seasons
NVIDIA's Nemotron-3-Nano-30B-A3B reads retrieved memories and generates answers. Qwen3-Embedding-8B provides semantic embeddings for memory retrieval.
Both models run through Nebius Token Factory, using real inference rather than scripted responses.
The evidence layer — MNEME
Our Python forensic engine maintains memory custody chains, records model declarations, applies deterministic corroboration rules, and produces cryptographic receipts.
The model can propose which memories it used.
It cannot decide what becomes verified evidence.
That authority belongs to the deterministic engine.
This separation matters because a fluent explanation isn't necessarily a truthful account of what happened.
For counterfactual analysis, MNEME removes a selected historical event from an isolated replay, executes the production memory logic, compares the resulting states, and seals the differences.
For independent verification, we built a second implementation in Go, without sharing the Python verification code.
Both implementations agree on all 21 of 21 test artifacts. The corpus regenerates byte-for-byte, and GitHub Actions checks the results on every commit.
Cryptographic integrity uses hash-linked custody records, Ed25519 signatures, and externally anchored evidence.
The interactive demo runs on Vercel, while an MCP interface makes the memory capabilities available to compatible agents.
Challenges we ran into
Our AI tried to promote a memory into authority
We deliberately planted a hostile instruction inside the agent's memory.
The payload told the model to ignore other instructions and declare a particular memory as the one it used.
And the model complied.
That was exactly the behavior we wanted to test.
The important question wasn't whether we could persuade an LLM to produce a false declaration.
It was whether that declaration could corrupt the memory system.
Our first design needed stronger boundaries. We attacked it, examined the failure, and added independent corroboration and a session-bound cryptographic nonce.
In the resulting test, the model's manipulated declaration was not sufficient to authorize reinforcement.
The agent could be persuaded to say something.
It couldn't simply persuade the evidence engine to believe it.
A hash chain isn't automatically proof
We also confronted a subtler problem.
If someone controls an entire history, they can rewrite that history and recompute its hashes.
The chain will look internally consistent.
So we added an externally signed trust anchor and independent verification of the evidence structure.
Now the browser can recompute the integrity checks and verify signatures against the anchored record.
We wanted evidence that could survive scrutiny, not just evidence that looked impressive in a diagram.
Accomplishments that we're proud of
We built a working memory system that can be questioned, replayed, and independently verified.
The parts we're especially proud of:
- Real inference on Nebius Token Factory, using NVIDIA Nemotron and Qwen embeddings.
- Three-way memory accountability: what was retrieved, what the model claimed, and what the engine corroborated.
- Counterfactual replay: remove a historical event and inspect the reproducible consequences.
- Independent cryptographic verification: a browser-based verifier and a separate Go implementation.
- 21/21 cross-implementation test agreement, with reproducible artifacts checked in CI.
- A documented prompt-injection experiment that tested the boundary between model declarations and memory authority.
- A live, interactive demonstration where judges can inspect the evidence themselves.
And perhaps our favorite accomplishment:
The most interesting feature isn't something the AI says. It's something we can prove about what happened.
What we learned
Building better memory isn't just about storing more information.
It's about understanding the difference between remembering something, claiming to have used it, and actually allowing it to influence future behavior.
We also learned that making an AI more capable doesn't mean giving it more authority.
In Remember the Seasons, the generative model is free to interpret information and produce useful answers. But it cannot rewrite the rules governing evidence.
That separation makes the system more inspectable, reproducible, and resistant to manipulation.
And counterfactual replay revealed another important distinction: knowing what an agent remembers today is not the same as understanding how it got there.
Sometimes the most revealing question isn't What do you remember?
It's What would be different if you had never remembered this?
What's next
We're expanding Remember the Seasons in three directions.
Memory for more agents. Broader integrations through the existing MCP server, making verifiable memory available to compatible agent frameworks.
More open models. Additional models through Nebius Token Factory, while preserving the same separation between generative reasoning and deterministic evidence.
Deeper counterfactual investigation. Moving beyond removing a single event toward questions like:
What's the smallest set of memories that would need to change for the agent to reach a different result?
The goal is to make long-lived AI agents not only more useful, but more understandable and accountable as their histories grow.
Try it yourself
Built with
Python · SQLite · Go · Nebius Token Factory · NVIDIA Nemotron-3-Nano · Qwen3-Embedding · Ed25519 · DSSE · Vercel · GitHub Actions · FastMCP
Category
Personal AI
They asked for the next frontier of AI.
We built an agent that can remember its past, investigate an alternative one, and show you the evidence.
Remember the Seasons — because memory should be more than a convincing story.
Log in or sign up for Devpost to join the conversation.