Why does our AI assistant keep asking customers the same questions it asked last week?

Because a language model API is stateless. Every call starts from nothing, and whatever the agent appears to remember is text your application chose to send again. If nothing in your design decides what to send, the answer is nothing, and the assistant starts over. That is the whole mystery. The rest of this piece is the follow-up questions, in the order buyers tend to ask them.

Can't we just use a bigger context window?

You can, and it will cost you twice. A bigger window lets you resend more history, but it does not change who decides what gets resent, and you pay for every token on every turn. A conversation that has run for forty turns is resent in full on turn forty-one.

Past a certain length it also fails on quality. The one decision that matters sits among thousands of tokens of small talk, and the model weighs them all. A context window is a desk, not a memory. Memory is the discipline of choosing what gets put back on the desk.

What should the agent be allowed to remember?

Less than the vendors suggest. Most vendor material is about storage and retrieval: which vector database, which embedding, how to fuse semantic and keyword scores. That layer is now interchangeable infrastructure, so pick one your team can operate. What decides whether the agent improves or degrades over time sits upstream of it, in what is allowed to be written.

An agent that stores everything builds a landfill. Retrieval then has to find the approved discount inside ten thousand near-identical fragments of past conversation, and similarity search is poor at telling a decision from a discussion about a decision. We think automatic, write-everything memory is the wrong default for any business workflow. Writes should be curated: confirmed facts and explicit decisions, each with a name attached to whoever confirmed it.

The name matters. "The customer needs a refund" means one thing when the customer said it and another when a planning agent inferred it from a tone. If both land in the store as the same kind of record, the agent will later treat its own guess as something a person told it. Keep inferences in a separate class, and never promote them to fact without a person or a system of record confirming them.

How many kinds of memory do we need?

Two. Vendor diagrams split memory into four or five types: in-context, semantic, episodic, procedural, sometimes more. For a business deployment, two distinctions do the work.

One is working context, the live conversation, which disappears when the session ends and should. The other is a ledger: a small, curated, attributable record of what was confirmed and decided, scoped to a user, an account or the whole organization. Semantic and episodic memory are retrieval strategies over that ledger. Procedural memory, the "how we do things here", is configuration, so keep it in version control with an owner and not as something an agent learns that nobody can read.

Selective retrieval is also cheaper. Mem0, a memory vendor, reports in its own 2026 benchmark that it averages under 7,000 tokens per query against roughly 26,000 for stuffing full history into context (Mem0). The authors sell the product, so read that as a vendor claim. The direction follows from the arithmetic above.

Should it remember what our ERP already knows?

No. In a company that runs Odoo or ERPNext, which ThinqHub implements, the system of record already holds the customer, the payment terms, the open orders and the credit limit. Copying those into an agent's memory creates a second version of the truth that starts going stale the moment someone edits the original.

The agent should read them from the ERP at the time it needs them, through a permissioned call, and treat the answer as current. What the ERP does not hold is what came only out of conversations: the exception someone agreed to by message, the preference a buyer stated, the reason a delivery moved. That belongs in the ledger, and drawing the line there keeps the store small, cheaper to run and easier to audit.

Can we delete it when someone asks?

You must be able to. A memory store holds personal and commercial data about identifiable people and accounts, which makes it a data-protection object whatever the product calls it. If you cannot delete one person's entries on request and cannot expire entries by scope and age, you have built a liability an audit will find. Which rules apply to you depends on where you operate, and a lawyer should answer that, not a blog post.

The order of work follows. Decide the scope of each memory first: user, agent, session or organization. Mixing scopes is how one customer's detail surfaces in another's conversation. Decide the owner and the deletion path next. Only then decide what to write. Our context engineering piece covers the neighbouring problem of what an agent may see at all.

Where do we start?

Pick one workflow where people currently repeat themselves to your agent. List the five facts it should have carried over. Write those, with attribution, and nothing else. Measure whether the repetition stops. If it does, you have a memory system. If you cannot name the five facts, a database was never going to help.

Agents that are live but keep asking customers to start over usually have an architecture gap and not a model limit, and it is cheaper to audit before adding more automation. Our approach starts with that audit, and our AI services cover the build. To talk through what your agents should remember, get in touch.