From Chatbot to Colleague: Give Your AI a Memory
For about six months, I was building an application at work on my own. Pushing out a single new feature took me roughly a week, design it, attach it to the database, sort the permissions and the views, test it, move on. Steady, but slow.
Then one day, I had the idea of rather than using the AI to troubleshoot errors or write parts of the code I wanted it to write, what about if I just handed the project over and oversaw it? So I handed the whole thing to an AI agent. I gave it the core structure of the app, the databases, the views, the permissions and I told it what the application was actually for: what was in scope, what wasn't, the nice-to-haves and the absolute must-haves. And then, crucially, I gave it somewhere to remember all of that.
What happened next genuinely changed how I work. As we built, I taught the agent what I wanted, and told it to create documentation as we go, the agent recorded what we were doing, why we were doing it, what decisions we made and what state each piece was in. It stopped being something I queried and became something I collaborated with. It got to the point where it would recommend to me, unprompted: "I think we need to add this feature now, given where you are, it's just become critical." That is a very long way from typing “The purpose of this section is this getting input from the user and validating but it’s throwing up an error that I don’t see why, can you help?” and getting back just that it checked and found the error was caused by whatever.
The thing that made the difference wasn't a smarter model. It was memory.
Why memory is the missing piece
People have used AI for a while now, and for most of that time it's been, essentially, a very good lookup engine, a chatbot, or a smarter Google. The models have grown dramatically more capable, but the one thing that kept them from being truly indispensable was that they forgot you the moment the session ended.
Think about what changes when they don't. Imagine being able to say:
- "What's the status of the project we were working on yesterday?"
- "What was the title of that book I ordered from Amazon last week?"
- "What did my wife send me in that email last Tuesday?"
The moment an AI can answer those, it stops being a lookup engine and starts being something that knows who you are, your preferences, your projects, the way you work. That is where the real productivity lives.
The memory you already have (and why it isn't enough)
Most AI tools now give you a settings page where you can store a few fixed facts about yourself. If you're a teacher, you might put in:
- My name is John Smith.
- I'm an English teacher at a primary school, teaching grades 6–9.
- My focus every year is Shakespeare, mostly Romeo and Juliet.
- I upload word-play exercises to my school's Moodle.
Now when you say "make me a class exercise to upload," it doesn't have to ask who it's for, what grade, or where it's going, it already knows, and over time it picks up your preferences too.
Providers keep this memory small on purpose: more memory is expensive for them to carry, and a system that remembers and accumulates raises safety questions they're still working through. But if you want serious, day-to-day productivity, especially with something like Cowork or Codex, the built-in memory isn't enough. You need to give the agent its own place to store everything.
Giving the agent a real memory
Here's the useful trick: almost every AI agent today can connect to Notion. That connector matters, because it gives the agent somewhere it can read from and write to and, just as importantly, somewhere you can read, check, and edit too.
So you can say, "That last thing we discussed is a project, please add it to the projects section and write it into Notion." The agent does. The next morning you open a fresh session and say, "Go check our Notion, look at projects and let’s pick up from where we were yesterday.” It reads, knows exactly where you left off, and picks straight back up.
That alone is transformative. But a single page becomes a cluttered dumping ground fast, so the real move is to give it structure. There are plenty of posts online about this, just google or ask your AI to find them for you. However this is what worked for me and has been proven over actual day to day usage.
Also before someone brings it up, I’m aware of Claude.md, Soul.md and Memory.md, these do also map quite cleanly onto what I’m going to describe below but they work best with a single agent. So if you only plan to use Claude or a single agent, it will work fine. However I am working with multiple agents, more on this in a future post, so I need(ed) a structure and consistency for multiple agents to access and save to. Still keep it simple at the start and start with one agent.
Start with a top-level page, call it AI Memory and under it a short README. The README is a standing brief: the last few things you were working on, with links to the sub-pages relevant to each. When you start a session, the only thing the agent reads first is that README. Instantly it has context, and from there it can follow the links:
- Collaboration: how you like it to work with you.
- Projects: what's on, and for each one its status, open issues, and the next piece of work.
Now it knows who you are, how you like to work, what you did yesterday, and what needs doing today, before you've finished typing your first sentence.
The important part is to train the agent to update the readme at the end of each session. You can do this via a prompt or if the agent provides it, save it as a requirement for the agent's memory settings, i.e. at the start of a session check readme, at the end update it.
From there you can extend the system further. Add a Scratch section for temporary notes and half-formed ideas ("remind me tomorrow to update the window service"). Add a Knowledgebase, and tell it: "Every time we solve something complex or annoying, write a page describing the problem, the fix, and what we had to get past." Very quickly you have something that compounds in value.
Two things to know before you do this
- First, the privacy trade-off. Granting an agent a connector, Notion or anything else, gives it the ability to act in that service *as you*, with your access. That may be perfectly acceptable for what you're doing; it may not. Weigh it honestly, decide what you're trying to achieve, and proceed with your eyes open.
- Second, memory needs tending. You have to keep an eye on the files and decide what's worth keeping and for how long. Some things matter for six months and then don't; some should stay forever; some are just clutter. A simple habit helps: when a project is truly finished, tell the agent to move it to an **Archive** page, and put one line in your README: *don't read Archive unless I ask.* That keeps the working context clean.
What it's actually been like
I've run this setup for a while now, and I'd find it hard to give up. Two changes did the most work. Every new session, my agent knows to read the README first, so it always starts with context. And at the end of anything we finish, we write back what we learned, so the system keeps teaching itself, and I can recover months later exactly what we did and why.
A lot of people bounce off AI because they expect the sci-fi version: ask one vague question, get back a finished miracle. When that doesn't happen, they write it off as a toy. With a small amount of setup, that perception changes completely, because the difference between a gimmick and a genuine collaborator is mostly just memory, and that's the case now. This will of course change going forward as the models develop and evolve.
Your ten-minute first step
Don't overthink it. Create a Notion page called AI Memory with a README sub-page. Connect it to your AI. Then, at the end of your next real conversation, ask the agent to write a short summary of what you did into the README. That's the whole first step, everything else builds on it.
Start there today, and tomorrow your AI will already remember you and what you want(ed) to do.
Comments