Here’s a workflow that every developer using AI tools will recognize: open a new session, find your context file, copy four hundred lines of project state, paste it in, then spend ten more minutes explaining what happened since you last updated that file. Fifteen minutes of setup before any actual work happens. And you do it every time because the alternative is the model starting from zero, asking you what language your project is in, what you were working on yesterday, and what decisions you already made.
That ritual is the tell. If you have to manually paste context into your AI every session, your AI does not have memory. It has a search bar over whatever you manually chose to save.
The part everyone builds versus the part everyone skips
Every AI memory product has decent retrieval. Vector embeddings, cross-encoder reranking, and hybrid sparse-dense search. These are mostly solved problems; there are a dozen off-the-shelf implementations, and you can get 86% on LoCoMo just by stacking ChromaDB with a good reranker. Search is not the hard part.
The hard part is ingestion: what happens between the user saying something and that information existing as a retrievable memory. Most products skip this entirely. They either dump the full conversation into a vector store and search over the raw text, or they make you decide what to save. Both approaches work, sort of, and both degrade as the memory store grows because nobody is filtering the noise.
Real ingestion means reading a conversation and extracting the specific things worth remembering. Not the conversation itself, the meaning of it. I built an extraction pipeline that pulls seven categories: personal facts, preferences, decisions, corrections, temporal events, technical context, and project state. Each category exists because it serves a different retrieval pattern later.
Corrections are the critical ones; they represent moments where the old answer is wrong and needs to be overridden, not stored alongside the new one as a competing memory. If I told the model my SSH key was at one path on Monday and corrected it to a different path on Wednesday, the correction needs to replace the old fact, not sit next to it, creating ambiguity. Most memory systems treat every piece of stored information with equal validity, which means the model gets both paths and has to guess which one is current. That’s not memory, that’s a conflict waiting to surface at the worst possible time.
The encoding gate problem.
Even with good extraction, scale kills you. A power user generates hundreds of candidate memories per day, and most of them are noise. “Fix the indentation on line 47” is not a memory anyone needs, but “this project uses tabs, not spaces” is the kind of preference that should stick around.
I built an encoding gate modeled on how the hippocampus decides what to encode into long-term memory. Three signals: novelty (how different from existing knowledge), salience (how important), and prediction error (does this contradict something stored). The scores combine into a threshold decision. What’s interesting is the contradiction handling. When a new memory contradicts an existing one, the prediction error spikes, which lowers the storage threshold. Contradictions are a signal. The user changed their mind, and the system needs to notice that instead of holding onto both versions and hoping retrieval figures it out.
There’s also a scaling behavior that matters. Early on, when the memory store is nearly empty, most things clear the novelty threshold because the system doesn’t know much yet. As memories accumulate, the novelty bar rises because more incoming facts are already known. The system becomes naturally more selective over time without anyone manually adjusting thresholds. This is important because without it, the memory store grows linearly with usage, and retrieval quality degrades as noise accumulates.
This is the part that makes ingestion genuinely hard and why most teams skip it. You’re building a judgment system, not a search system. You’re deciding whether information is worth keeping before you’ve seen the future query that might need it. The DHCP lease time I mentioned casually during a router configuration session scored low on immediate salience but high on technical novelty. Eleven days later, it turned out to be the answer to a debugging problem I hadn’t encountered yet. A system that only stored “important-looking” memories would have dropped it.
What changes when ingestion is automatic
After a week of running automatic ingestion, the context files I used to maintain were already stale. Over two hundred memories extracted across a dozen sessions, zero saved manually. The system was capturing things I wouldn’t have thought to write down: corrections (moments where I changed my mind about a technical decision), configuration details I mentioned in passing, temporal facts embedded in offhand comments.
Multi-week pattern recognition starts happening. The system noticed that every networking bug on my Pi nodes traced back to a configuration change I’d made during an unrelated session. Not once, three times. It started boosting the salience score of configuration changes at storage time, making them easier to retrieve during future debugging. I didn’t program that behavior explicitly.
Contradiction detection across time is the subtle capability that no notebook can replicate. I said I wanted SQLite-only architecture in week one. By week three, I was casually exploring Postgres for one specific use case. In week four, when I was making an architecture decision, the system flagged it: “You stated a preference for SQLite-only on [date]. Recent sessions suggest you’re considering Postgres for [use case]. Want to update this decision?” A notebook doesn’t know the difference between “I changed my mind” and “I forgot what I decided.”
And cross-project connections: a debugging pattern from one project surfaced as relevant context in a completely different project weeks later because the underlying issue was the same, even though the projects were unrelated. That connection only exists because TrueMemory stores memories project-agnostically, and the ingestion pipeline captured both instances as technical context.
The full encoding gate architecture and benchmark results are in the arXiv paper.
The paste button is a symptom
Your brain doesn’t paste context into itself every morning. It just knows things, and the relevant ones surface when you need them without you having to curate a file and load it in before breakfast.
Honestly, the fact that we’ve been doing context management manually for AI, spending fifteen minutes per session on setup that should be automatic, is the clearest sign of where the real gap is. It’s not search, it’s everything that happens before search. And until someone builds the ingestion layer properly, every AI memory product is just a notebook with a better search bar.
Josh Adler is a researcher at TrueMemory, a Sauron company. Research: arXiv:2605.04897. More at joshadler.com.