Blog
Memory, context and working with AI.
Analysis, comparisons and experiments on memory, context, continuity and decisions over time.
Explore the eighteen observatory articles and proposed methods.

Featured · Lab
Useful memory keeps the reasons behind a decision
Why reasons, rejected alternatives and exceptions make past decisions more useful to assistants and teams.
Memory & Context

Why does ChatGPT forget what I told it?
ChatGPT can remember useful details but does not keep the full state of a long project. Understanding chat, memory and working context is the key.

AI memory vs RAG: they are not the same thing
RAG retrieves useful knowledge for a query. AI memory maintains evolving context over time. They may share retrieval technology, but they solve different problems.

The real test of AI memory starts when it is wrong
Useful memory is not memory that never fails. It is memory you can correct, update and forget without losing the history that still matters.

Can AI memory trap you in your past decisions?
Remembering past choices can help AI, but it can also create conservative bias. Useful memory should inform without deciding for you.

AI memory vs context: storing information is only half the problem
An AI memory that stores facts does not understand a story. See what separates storage, retrieval and context, and when a simple memory is all you need.

Why a great prompt cannot include what you forgot to mention
A careful prompt can only hold what you remember. See why the history of a project goes missing from your requests, and how to bring it back when it matters.

Why preserve the reasoning behind a decision?
A decision written down without its reasons tends to get applied at the wrong moment. A simple template for keeping the why, and knowing when to revisit.

Why found does not mean true
When an AI retrieves a memory, that proves nothing by itself. Four questions about source, date and status to ask before you rely on what it reports.

What should happen when a decision changes?
Erase, pile up or replace: what each choice does to a project’s memory, and why a replaced decision must not turn into a false truth later on.

How to tell that a memory has become obsolete
Replaced, contradicted, expired, out of context or moot: five ways a memory goes stale, the signals to watch for, and a ten-minute review you can try.

The difference between a memory, a fact, a decision, a hypothesis and an instruction
One event can turn into five very different notes. How to tell a memory, a fact, a decision, a hypothesis and an instruction apart, and avoid the mistakes.

Why a good memory must also know when not to write
Keeping everything feels safe, but a memory full of noise and outdated facts helps less. Why not writing is a feature in its own right, not a gap.
Working with AI

Switch AI Assistants Without Losing the Why Behind Decisions
Make decisions, sources, rights and outcomes portable across AI assistants without sharing the entire history or creating vendor lock-in.

Memory Should Be Portable Before It Is Intelligent
Evaluate AI memory portability before advanced features: exports, sources, rights, structure, history and recovery by another AI.

The Post-AI Lens: Test an Idea Beyond the Code
Seven questions to test an idea after code becomes cheaper: distribution, workflow, trust, data, learning and organizational leverage.

The Decision-Outcome Journal: The Missing Loop in AI Teams
Connect every important decision to its hypothesis, expected outcome and observed result to create an organizational memory that learns.

One Memory Across Multiple Projects Without Mixing Everything
Organize AI memory across companies and projects with explicit boundaries, private annexes, shared references and authority.

What AI Should Forget: Build a Memory Policy
Decide what AI memory should never retain, expire, correct, restrict or delete based on purpose, risk and authority.

How to keep AI project context for months
A practical method for preserving decisions, current state, hypotheses and observed outcomes when you work with AI on a project for weeks or months.

How to stop repeating the same information to AI
Stop rebuilding the same AI context by separating stable information, current project state and the temporary details of the task in front of you.

What should AI remember from a meeting, project or decision?
AI should not necessarily memorize an entire meeting. Durable memory should focus on decisions, reasoning, commitments, open questions and outcomes that will matter later.

How AI can retrieve your past trade-offs without deciding for you
AI can reread your past choices to help you think clearly, without deciding for you. Here is how to keep the judgment on your side of the table.
Comparisons

ChatGPT memory vs Claude memory: what is different?
ChatGPT and Claude both support memory, but they organize continuity differently. A dated October 2026 comparison of chat history, project memory and portability.

RAG, vector database or AI memory: which one do you need?
A decision guide for choosing document retrieval, vector search or long-term AI memory based on the actual problem your system needs to solve.

Mem0, Zep and Nawame: different approaches to AI memory
Mem0, Zep and Nawame all address persistent AI context from different starting points. A practical comparison of infrastructure, context engineering and user-owned memory.

When not to use Nawame
Nawame is not useful everywhere. Native memory, README, Notion, short projects or systems of record: when a simpler tool is enough.

Why not simply use ChatGPT or Claude memory?
ChatGPT or Claude built-in memory is often enough. Here is when it is, when a provider-independent history makes a difference, and where Nawame falls short.

Giant prompt or targeted context?
Should you paste your whole history into the prompt? Cost, noise, contradictions: when a giant prompt is fine, when targeted context wins, and how to choose.

Local memory or independent memory?
Built-in memory, files on your computer, a home-made knowledge base or an independent memory: four approaches compared, with their trade-offs and their limits.

Notion, Obsidian or Nawame: documenting is not the same as remembering
Notion and Obsidian document very well. Remembering decisions over time is a different job. Where each tool shines, and how to combine them.
Privacy & Portability

How to move project context from one AI to another
Moving from ChatGPT, Claude or another assistant without starting over takes more than exporting chats: transfer state, decisions, reasons, constraints and provenance.

How to share AI context without sharing personal data
Useful AI context does not require exposing your entire personal memory. Separate scope, identity, sensitive data and working context before retrieval.

What if Nawame disappeared tomorrow?
Portable memory is more than an Export button. What should remain understandable if the service itself disappears?

How AI memory can become a prompt injection channel
Retrieved memory must remain data, not silently become privileged instructions for an AI system.

Your data belongs to you: what should a real AI memory export contain?
An Export button is not enough. Content, useful history, replacements, provenance, versioned formats: what an export needs to stay useful once you leave.

Data portability vs portability of meaning
Downloading your conversations does not let you switch AI without losing the thread. What separates a raw export from one that keeps meaning, and how to test it.

Sovereignty and AI memory: why privacy can require trade-offs
More privacy sometimes means fewer features. What Nawame’s sovereign mode changes, what it costs, and how to choose depending on how you work.

Importing memory without importing hallucinations
A memory exported from another assistant is full of summaries and guesses, not guaranteed facts. Here is how to sort it before you bring it in.
Teams & Organizations

AI Memory Without Sources Is Just a Persistent Opinion
Reliable AI memory preserves source, date, confidence, rights and observed outcome : not just a convincing summary.

Why Organizational Memory Needs to Know Information Freshness
Accurate information can become wrong. Learn how to date, review and expire items in an organizational AI memory.

Conversation, Decision and Outcome: Three Objects You Should Not Confuse
A conversation explores, a decision commits and an outcome verifies. Separate these objects to build actionable organizational AI memory.

Forgetting as a Feature of AI Memory
Reliable memory must correct, expire, unlink and delete information without destroying useful history or legitimate obligations.

How to Store an Inference Without Turning It Into a Fact
Prevent hypotheses from becoming truth through repeated summaries by preserving source, epistemic status, contradiction and review.

Shared Memory, Private Memory and Authority: Drawing the Boundaries
Reliable memory architecture separates private notes, shared team knowledge and decisions that carry authority.

How to build company memory that AI can actually use
Useful company memory is not one giant document repository. AI needs facts, decisions, rules, history, provenance and access boundaries to be kept distinct.

Team AI memory: how to keep sources and contexts separate
Shared AI memory becomes risky when decisions, personal opinions and different projects are mixed together. Scope, provenance and authority need explicit boundaries.

What AI memory should never copy from your system of record
CRM, ERP, Git or banking data should not become duplicated truth inside AI memory. Memory should preserve the context those systems do not explain.

Source, validation and authority are three different things
Knowing where information came from does not mean it is true or authoritative. Organizational memory has to keep those statuses separate.

Why personal memory must not automatically become company memory
Pouring everyone’s AI conversations into a shared memory looks efficient. Here is what gets lost, and how to share what matters without exposing the rest.

What happens when two people edit the same memory?
Two versions of one fact, a contradicted decision, a silent overwrite: how a team keeps a shared memory trustworthy, and what no tool can settle for you.
Lab

Reliable memory keeps sources, dates and disagreements
A source establishes origin, not necessarily truth. How sources, effective dates and corrections shape trustworthy assistant memory.

Portable memory needs clear sharing boundaries
Changing assistants should not erase context. Why portable memory must preserve private work, access rights and shared sources.

A negative result can improve AI memory
Hypotheses, synthetic corpora, costs and measurement errors: how the Nawame Lab turns experiments into architectural decisions.

Semantic search: what embeddings can retrieve
Embeddings connect different ways of expressing an idea. Nawame’s research explains why similarity must remain separate from evidence and authority.

Why a handover needs more than one search
A first result may reveal what to search for next. Nawame’s experiments examined multi-step retrieval, evidence coverage and the limits of synthetic handovers.

Past decisions need their own time frame
Finding an old version is only part of historical retrieval. Nawame tested explicit validity periods to help assistants use the right decision.

Should AI memory be rewritten for machines?
Nawame compared human documents with structured assertions. The experiment separated compression gains from evidence quality and handover weaknesses.

Rewriting a decision can change its status
An assistant can preserve a number while turning a proposal into a rule. Nawame’s experiment explains why decision status must stay connected to its source.

Why an assistant can cite evidence and miss its consequence
Nawame tested guidance placement and question-specific alerts. Citation, comparison and justified abstention proved to be different capabilities.

An optional parameter can hide the right memory
A Nawame test failure showed how tool contracts shape AI answers. Information can be present while an unintended filter makes it unreachable.

Embeddings: recompute only what changes
How reusing unchanged document fragments reduces embedding computation, and what our Lab result actually measures.

Choosing embedding infrastructure through comparable measurements
Shared or dedicated CPUs: findings from a Nawame benchmark, queueing effects and the limits of performance comparisons.

Finding a decision inside a long document
Targeted passages can improve retrieval from long documents, but selecting them can lose qualifications or expose hidden instructions.

A memory is data, not an instruction
Why distinguishing memories, intended instructions and prompt injection is difficult, and what Nawame's classification experiments taught us.

AI memory: when SQL is enough, and when to test a graph
What experiments with relationships, graph storage and vector indexes reveal about choosing an AI memory architecture.

Resilience and full cost: what a memory service needs to measure
Computation, failover, recovery and encryption: understanding the full cost and trust boundaries of a memory service.

Memory for business software, even without a chatbot
How object-linked memory preserves decisions and reasons, with permissions, history and clear limits to the current Embedded evidence.

Capturing explanations without overloading teams
When to request a human explanation, how to qualify it, and why restrained prompts matter to useful business memory.

With and without memory: what an Embedded evaluation measures
Results from two model families on synthetic data: object-based retrieval, scoring errors and the limits of the conclusions.

Why Reliable Agents Need Traces, Evals and Human Recourse
A reliable agent exposes its journey, is evaluated on real cases and allows people to stop, correct and appeal its actions.

OpenTelemetry and AI Memory: Correlate Without Recording Everything
Connect technical traces, decisions and agent outcomes without turning observability into an intrusive organizational memory.

Measure Tokens per Outcome, Not Tokens per Conversation
Connect tokens, human time, external tools and correction to a business outcome to optimize the true economics of an AI workflow.

Agent Graceful Degradation: Continue, Pause or Ask
A practical method for deciding whether an AI agent should continue with limits, ask, queue work, hand off or stop.

A One-Off Evaluation Does Not Protect an AI Agent From Drift
Build an evaluation schedule that detects changes in models, data, tools, use and populations after production release.

Declared Trust Is Not Evidence
A framework for checking AI trust claims through observable controls, tests, outcomes, limitations and appeal.

A good memory must know when to retrieve nothing
Finding something is not always better. Reliable memory has to know when no memory is relevant enough to use.

Can an AI judge whether another AI remembered correctly?
AI judges can evaluate many answers quickly, but memory quality cannot be reduced to one automatic score.

When semantic search finds a precedent that never existed
Semantic search can surface a memory that resembles your question without actually being about it. Why that is risky, and how to account for it.

Limits of retrieval at scale
Why more documents can mean worse answers: recall, precision, near-duplicates, freshness, contradictions, and what you can do about each of them yourself.

Why we deliberately test topics that do not exist
Asking a memory a question with no answer checks that it can say "nothing" instead of making something up. Why the test matters and what it does not prove.

How to test non-writing
A reliable AI memory must know what not to keep. A six-step, repeatable test with eight made-up events, counting false positives and false negatives.

How we measure memory errors
False recall, omission, an old fact taken for current: seven kinds of AI memory errors, how to catch each one, and why a single score misleads.

How to test an AI memory without cheating on the benchmark
Known test sets, cherry-picked cases, metrics changed afterwards: how people fool themselves with AI memory benchmarks, and a method to avoid it.

How to measure whether a memory really avoids rework
Is an AI memory useful or just reassuring? A repetition log kept over a few weeks can tell you, with no special tooling and no invented numbers.

The errors a long-term memory can carry forward
A mistake written down once can be read a hundred times. Five ways it spreads through a long memory, and the habits that make it visible.

Can we detect decision cycles without psychologizing the user?
A question reopened with nothing new is something you can state with dates, not with a diagnosis. Neutral wording rules, examples and limits.

Why we publish Nawame’s limitations too
False precedents, noise, dilution and time: here is what Nawame does not yet do well, what we measure so far, and why we choose to say it openly.
Guides

Connect ChatGPT to Nawame: a step-by-step guide
Connect ChatGPT to Nawame through developer mode: steps, the e-mailed code, first tests, troubleshooting and limits, based on OpenAI’s own documentation.

Connect Mistral to Nawame: a step-by-step guide
Add Nawame as a custom MCP connector in Mistral’s Le Chat: steps, per-function permissions, a first check, troubleshooting and the limits Mistral documents.

Connect Grok to Nawame with a custom MCP connector
Connect Grok to Nawame with a custom MCP connector: steps from xAI’s documentation, authentication, troubleshooting, limits and a manual fallback workflow.

Using Nawame on a long-running project: a worked example over several weeks
One project followed from start to finish with Nawame: starting, resuming after a break, switching AI, tidying up. A made-up example, limits included.