AI Memory and Curated Context
What is the difference between AI context and AI memory?
An agent begins a task. In its context window: the user's instruction, a handful of retrieved documents, a system prompt written three months ago. It has session memory from prior conversations with the same user. What it doesn't have is any record of the product decision made in a leadership meeting last week — because that was never placed into a context window and was never spoken into a session.
Context and memory are often used interchangeably. They work differently, fail differently, and the distinction matters when you're trying to understand why an agent produced the wrong output.
Context
Context is what an agent is given at the start of a task. Everything in the context window — the instruction, the retrieved documents, the system prompt, any prior conversation history included for reference — constitutes the agent's context. It is ephemeral by nature: assembled for this task, present for its duration, and gone when the task ends.
Context is a snapshot, not a store. The same agent given the same task tomorrow starts with a fresh context window, assembled again from whatever sources the system pulls from. Nothing carries over from the prior run unless it is explicitly placed back in.
This means context quality depends entirely on what goes into it. A context window assembled from a well-curated knowledge base produces different agent behaviour from one assembled from a generic document corpus — not because the agent is different, but because what it was given is.
Memory
Memory is persistence — the ability to retain information across interactions so the agent doesn't start from nothing each time. Session memory tracks what happened in a conversation. Longer-term memory stores facts, preferences, and prior exchanges so they remain accessible in future sessions.
Memory affects context indirectly: what the agent remembers can be included in future context windows, so the agent appears to carry knowledge forward. But memory is a record of what happened in prior interactions — not a record of what the organisation knows. An agent with extensive session memory knows the history of its conversations with a user. That history is valuable for continuity. It is a different thing from operational knowledge.
Where They Fail Differently
Context fails when it's assembled from the wrong sources, or when the right knowledge was never in any source to begin with. The agent has everything it was given — and what it was given was incomplete.
Memory fails when the knowledge that matters wasn't surfaced in a prior session. An agent can have perfect recall of every prior conversation and still have no awareness of a compliance requirement that changed last month — because nobody told it in a session and it wasn't in the corpus.
The two failure modes look similar on the surface: the agent produces something wrong. But they have different causes and different fixes. Context failures are an ingestion and curation problem. Memory failures are a continuity problem. Neither is fixed by improving the other.
The Question both Leave Open
Both context and memory are mechanisms for what the agent receives and retains. Neither answers the prior question: where does the organisational knowledge that should go into context actually come from?
If it comes from automatic document ingestion, it reflects what was written — not what was decided. If it comes from session history, it reflects what was said in prior conversations — not what the organisation knows as a matter of deliberate record. What the agent can do well is shaped by what someone decided to put into its operating knowledge — and when.
That's an authorship question, not a retrieval or persistence question. Context and memory are the delivery mechanisms. What gets authored before they're assembled is the upstream problem.
Engramic's approach
How Engramic Approaches it
There are multiple ways to address the authorship layer. This is one approach.
Engramic sits upstream of context assembly. Before an agent starts a task, someone — a human, an agent, or both — decides what knowledge belongs in its operating context. Engramic is where that decision gets made and recorded: not retrieved from a general corpus, not reconstructed from session history, but authored before the agent was ever deployed.