Last weekend I was cleaning out a closet and found a notebook from 2017.
It was one of those black Moleskines with the elastic band. I remember buying it at an airport. The pages were curled at the edges. I'd shoved it in a backpack for years and the spine was cracked.
I sat down and flipped through it.
There was a camping trip I'd completely forgotten about. A startup idea scrawled across two pages with a diagram that must have made sense at 2 AM. A friend's phone number I didn't recognize anymore. A shopping list. The name of a restaurant I wanted to try.
Reading it felt like time travel. I wasn't just reading words — I was back there. I remembered the coffee shop where I wrote that startup idea. I remembered the rain on that camping trip. The notebook didn't just store information. It stored context.
That's when it hit me.
I'd spent the last few months building AI agents that couldn't remember anything from one session to the next. Every morning, fresh reset. I'd tell them my stack, my preferences, my project structure. And by the next conversation, it was gone. I was living in Groundhog Day, and I was the only one who knew it.
But here I was, holding a $15 notebook that did everything my AI agents couldn't.
The way memory actually works
My notebook works because it has layers.
Start with time. Most pages have a date. That means I know when things happened, not just what happened. The startup idea from 2017 only makes sense if you know what I was doing back then. Without the date, it's just noise.
Then context. The camping list is right next to the work notes. That's how life works. Things overlap. The notebook doesn't try to separate them into neat folders. It just captures what happened, messy and real.
And then there's forgetting. That phone number I didn't recognize? I don't need it anymore. The shopping list is irrelevant. Some stuff matters, some stuff mattered once, and some stuff never mattered at all. And that's fine, because the useful stuff is still findable.
The real trick? The notebook captures what happened. Not what someone thought I'd need later. It's a record of reality, not a prediction of usefulness.
What this means for AI agents
Here's the thing about most agent memory systems: they're built like a hard drive, not a notebook.
Everything goes into one bucket. There's no sense of time. Or rather, there's only "right now" and "everything else." No layers. No context. Nothing that connects last Tuesday's debugging session to what you're working on today.
And the forgetting is all or nothing. Either the system remembers everything (choking on noise) or remembers nothing (resetting every session). That middle zone — the functional forgetting that lets you find what actually matters — barely exists.
I realized the architecture I needed was staring at me from that coffee-stained Moleskine.
Time layers first. Memory isn't flat. Things from last week are more relevant than things from three months ago. And things that happened while you were working on an auth bug are more relevant when you're back in that auth code. That's how I naturally think about my own work: "the problem from last sprint" vs "that thing from a year ago."
Context around content. What you were doing when you said something matters as much as what you said. If you mentioned your API keys while debugging auth, the agent should surface that memory in auth contexts. Not randomly during a billing discussion.
Letting go on purpose. Not everything needs to be saved. Not everything that's saved needs to stay forever. The art isn't storing more data. It's knowing what to keep and when to let it fade.
What it feels like now
I won't get into the technical architecture here (that's a different post). But I built this into something called Lorekeeper, and the difference is night and day.
I start a session now and my agent knows what I was working on last time. Not from a system prompt I copied and pasted. It actually remembers. Really remembers.
Last week I was debugging a Redis connection issue. I came back to it three days later. Context switch, meetings, the usual chaos. And my agent picked up exactly where we left off. It knew the error message, the config file we'd been inspecting, even the theories we'd ruled out.
That's the notebook experience. It doesn't feel like AI magic. It feels like working with someone who actually pays attention.
The thing I keep thinking about
I spent months looking at this as a technical problem. Vector databases, attention mechanisms, embedding strategies. All of that stuff has its place.
But the real breakthrough came from a $15 notebook I bought at an airport.
The best memory system already exists. We've been using it for centuries. We just forgot to look at how our own brains actually work before we started building one for our AI agents.
So here's my question: what else are we overcomplicating because we haven't stopped to look at the simpler version that's already working?
If this resonated, Lorekeeper is open source. I'd love to hear what you're building.