Kursol
Every Monday, somebody on your team opens an AI tool and explains their job to it again.
The client. The history. The thing that broke in March and the workaround that fixed it. Fifteen minutes of context typed out to get one useful answer. Then the window closes and it's gone. Next week, same fifteen minutes.
It's like hiring a brilliant new starter who forgets everything overnight. Every night.
Most teams read that as a limitation to live with. It isn't. It's the specific thing sitting between a pilot that demos well and a tool that changes how the work gets done.
MIT went looking for the barrier and found this one
MIT's Project NANDA published The GenAI Divide: State of AI in Business 2025 in July 2025. Its headline number — that 95% of enterprise AI pilots deliver zero measurable P&L impact — is the one that travelled, and we used it ourselves writing about why AI pilots stall in month three.
The part that got less attention is what the same report identifies as the cause.
Not infrastructure. Not regulation. Not a talent shortage. Learning. The report's finding is that most generative AI systems don't retain feedback, adapt to context, or improve over time. The executives interviewed described it in the same terms your team would: fine for a first draft, no recall of client preferences, repeats mistakes it already made, needs the full briefing again every session.
None of those are model quality complaints. Every one of them survives a model upgrade.
A bigger model doesn't fix a memory problem
A context window is how much the tool can read in one sitting. Memory is what shows up without anyone going to fetch it. Vendors ship the first and businesses assume they bought the second.
The gap between them is operational, not technical. The information already exists somewhere — in a senior person's head, a Slack thread from February, an email chain, a folder nobody opens. What's missing is anything that carries it to the tool at the moment the work starts.
So the most expensive person in the room does the carrying. By hand. Every time.
That cost is invisible on any dashboard, which is why it survives so long. Nobody logs the fifteen minutes. It just shows up later as a tool the team quietly stopped opening.
What continuity actually looks like
We run this on ourselves at Kursol. One file per client, one per project, one per decision. Thomas Brenas, our Head of Operations and Growth, wrote a shorter version of this on LinkedIn; this article started there.
Three rules do most of the work.
They hold current state, not a journal. A note says what runs where, what has already gone wrong, and what's still open. Not what happened on Tuesday. A journal grows forever and answers nothing. A current-state note stays roughly the same size and answers the question you actually have.
Decisions carry the reasoning, not just the outcome. "We moved billing to a different provider" is trivia. "We moved because the old one failed twice under load, and here's what we ruled out and why" is what you need four months later when somebody proposes the ruled-out option again. The outcome without the reasoning gets re-litigated. With it, the conversation takes a minute.
Nobody has to remember to load them. This is the part that changed the day-to-day. Start work on a client and the right file is already in front of the AI before anyone types a word. Handover stops being a habit somebody has to keep. A habit that runs on discipline fails in the week everything gets busy, which is exactly the week you needed it.
The mistake worth stealing
The first version of all this was written for the person writing it. It needed to be written for the thing reading it.
Human notes lean on context the reader supplies for free — the folder it sits in, the client it obviously refers to, the shorthand everyone on the team already knows. A machine gets none of that, and a new hire gets very little of it either.
So the fixes are dull and they matter. The repo and folder names go into the note itself, because what a thing is called in the file and what it's called on disk are almost never the same. Open items live in one named field, so "what's outstanding here?" is a lookup instead of a read. Every note opens with a one-line summary, so 133 decisions can be scanned in one pass instead of 133.
That isn't extra work. It's the same information, shaped so it can be found.
What this means if you're buying AI
Gartner predicted that at least 30% of generative AI projects would be abandoned after proof of concept by the end of 2025, citing poor data quality, escalating costs and unclear business value.
Memory sits underneath most of that. A tool that can't accumulate anything can't get cheaper to run or more obviously worth keeping. It performs identically in month nine and month one, which reads to everyone watching as a tool that never got good.
Three questions worth asking any vendor, or asking about anything you've already bought:
- What does this know about our business on Monday that it didn't know on Friday?
- Where does that knowledge physically live, and do we still have it if we switch vendors?
- What happens to it when the person who was best at using the tool leaves?
The answers matter more than the model. A written-down context layer is yours, portable, and works with whatever you buy next. A colleague who has become excellent at prompting is none of those things — that's the single-champion problem, and it's one resignation from being your problem.
It's also the practical version of the argument for building AI that augments your team rather than replacing it. A system that remembers what your people decided, and why, makes them better at the job. A system with no memory just asks them to do the remembering.
Once it's running, the maintenance question is the same one that applies to any AI you've had in production for a while: is what it knows still true?
Start with one client
Take your most complicated account. Spend an hour writing three things: what's currently running and where, the decisions you've made and the reasoning behind each, and what's still open. Then make it load automatically, so nobody has to remember to hand it over.
The AI doesn't get smarter. It stops starting from scratch.
In practice those are the same thing.
FAQ
No. Prompt engineering improves a single conversation. A context layer means the next conversation starts where the last one ended, whoever opens it. One is a skill an individual has; the other is an asset the business owns. The second one survives a resignation and a vendor change.
Not to start. The value is in the writing and the structure, not the tool — plain markdown files in a shared folder will take you a long way. What matters is that the notes hold current state rather than history, that they're written for a reader with no background, and that something loads them automatically instead of relying on a person to remember.
You'll know because answers get vaguer, not sharper. The failure mode is dumping everything in and burying the two facts that mattered. Keep notes to current state, retire what's no longer true, and treat length as a cost. If a note has become a history of the account rather than a description of it, it's already too long.