First published 18 June 2026; rewritten 19 October 2026, with corrections. Every AI tool demos beautifully on day one. The real test is week six, when the novelty is gone and the value has to come from somewhere else. For most tools, week six feels exactly like day one: you are still explaining your business from scratch, every session. We called that the amnesia tax, and building AI agent memory to remove it is most of what this piece was originally about. Since then we have learned the other half of the lesson, the hard way, and it is the more useful half: memory compounds in both directions.
- A system that remembers your store gets better than its model on your store. That is the case for agent memory, and it still holds.
- But a remembered fact that stops being true is reused, cited and built on exactly like a true one. Wrong memory compounds too, and it does so confidently.
- Research has shown that an agent's memory can even be poisoned by ordinary users, through nothing more than the questions they ask.
- So the hard problems are not storage. They are authorship (who wrote this?), freshness (is it still true?) and forgetting on time.
- Below: exactly how Lumnya's three memory layers work today, the safeguards we have, the ones we haven't built yet, and two claims from the first version of this article that were wrong.
The amnesia tax
The amnesia tax is invisible on a feature list and enormous in practice: every re-explained policy, every re-discovered pattern, every insight that evaporated when the chat window closed. A tool that forgets you can only ever be as good as its model. A system that remembers you can get better than its model, on your store specifically, because each week starts from a richer picture than the last.
The durable advantage isn't the model. It's the accumulated, structured knowledge about your business.
Memory compounds both ways
Here is the part the first version of this article underplayed. The mechanism that makes memory valuable, a fact written once and reused everywhere, does not check whether the fact is still true. A product marked as dead stock in March is still marked as dead stock in May, when it has started selling again, unless something goes back and looks. Meanwhile every recommendation that reads the fact repeats it, and each repetition makes it look more established. A remembered falsehood doesn't decay on its own. It accrues authority.
Figure 1 · A fact that is never re-checked
The store changed in week 6. The memory didn't, and kept being used.
Weekly sales of one product, and what a remembered “dead stock” fact keeps saying about it.
We found a real instance of this in our own product while writing AI shopping agents read your store in copies. When you install Lumnya, it reads your store's published refund, shipping, privacy and terms pages so the assistant can quote your own words. Products are read again every time Shopify reports a change. Policies are not: if you edit your refund policy in Shopify after installing, the assistant keeps the version it read at install. A remembered policy, confidently quoted, that is no longer your policy. It is the exact failure this section describes, and it is now first on our list to fix.
There is a sharper version of the risk, too. In 2025 researchers published MINJA, a memory injection attack on LLM agents. It needs no access to the agent's memory store at all: an attacker only talks to the agent, and crafts queries that lead it to write misleading records into its own memory, records that later steer its reasoning when a different user asks something. The paper's conclusion is blunt: any user can influence what such an agent remembers. What is allowed to write to memory is a security decision, not a convenience.
How Lumnya's memory is built
Most early work on LLM memory was about capacity: how to give a model access to more than fits in its context window. MemGPT, for example, borrowed the idea of memory tiers from operating systems. Capacity matters, but for a business it is the easier problem. Lumnya's memory is not one big transcript. It is three layers with different jobs and different rules, and each answers one of the hard questions above.
Figure 2 · Three layers, three clocks
Every layer of memory has its own answer to “is this still true?”
Where Lumnya's agents get what they know about your store, and how stale each part can be.
Your Shopify store
Source of truth
live
- Fresh snapshot · inventorywhat agents read instead of hitting Shopify≤ 1 hour
- Fresh snapshot · productsorders and customers: ≤ 24 hours≤ 6 hours
- Shared factsauthor + confidence · no overwritinguntil rewritten
- Insightsweekly diagnoses and findings6 months
- Store policiesread at installnot refreshedfound while writing this
Agent notebooks: who saw what
Each specialist agent keeps its own records: what it observed, each run, each recommendation. Every record is stamped with the agent that wrote it by the helper all agent writes go through, so one agent doesn't write as another. Observations, runs and recommendations expire on a schedule rather than piling up forever.
Shared facts: authorship and confidence
When an agent establishes something about a product, a customer or an order, it writes a shared fact that every other agent can read. Each fact carries its value, a confidence, its sources and its primary author, the agent that first wrote it. Other agents can add annotations, including a value they disagree with, but they can never overwrite another agent's fact. That makes the provenance of every fact answerable: who said this, and how sure were they?
The confidences are set per kind of fact, deliberately and visibly, not invented per run. A stock level read from Shopify carries full confidence. A suggested reorder quantity carries 0.6, because it comes from a simple formula rather than a sales forecast. A weekly diagnosis carries 0.8. An earlier version of this article illustrated a fact with a confidence of 0.92; that was an illustration, and we'd rather show the real values.
Figure 3 · Confidence, by kind of fact
A stock level read from Shopify is certain. A suggested reorder quantity isn't, and says so.
The confidence Lumnya's agents attach to each kind of shared fact, set by how the fact is produced.
Confidence attached to the fact (0–1)
- Stock status, from Shopify1.0
- Weekly diagnosis0.8
- Margin0.7
- Knowledge gaps0.7
- Suggested reorder quantity0.6
- Dead stock0.6
- Bundle suggestions0.6
- Demand signals0.5–0.6
The fresh snapshot: fast, gentle, and dated
Agents read a private, regularly refreshed copy of your store data rather than querying Shopify every time, which keeps them fast and well within Shopify's limits. Every part of the snapshot has a lifetime: an hour for inventory, six hours for products, a day for orders and customers. When an agent has to read data past its lifetime, it is told the data is stale rather than handed it as current.
What we haven't built yet
This is the section the first version of this article got wrong, so we'll be precise. Here is the state of the safeguards that good agent memory needs, as of today.
| Safeguard | Why it matters | Lumnya today |
|---|---|---|
| Authorship on every fact | You can always ask who said it | ✓ Built |
| No overwriting another agent's fact | One agent's error can't silently replace another's finding | ✓ Built |
| Expiry on raw data and observations | Old readings don't pose as current | ✓ Built |
| Decay of facts unless re-verified | The dead-stock problem in Figure 1 | Not yet. Facts about products, customers and orders don't expire; insights expire after six months |
| Contradiction detection | Two agents disagreeing should surface, not coexist quietly | Not yet. A disagreeing value is kept as an annotation, but nothing compares them |
| A fact browser you can read and correct | Memory you can't inspect isn't really yours | Partly. You can ask the assistant what it knows about a product or customer; there's no screen to browse and edit facts |
| Policy refresh when your store changes | The assistant should quote today's policy | Not yet; first on the list |
| Outcomes feeding back into memory | A recommendation that worked should count for more | Partly. Results of approved actions are measured and recorded with the action; they don't yet update the shared facts |
Two corrections to the first version of this article, stated plainly. It said that observations are “promoted” to shared facts once verified. They aren't: agents write facts directly, and the safeguards are authorship, confidence and the no-overwrite rule, not a verification step. It also said that approving a recommendation “strengthens” the fact behind it. Today, outcomes are measured and kept with the action, but they don't change the fact. Both were descriptions of a design we intended, written as if it were finished. That is precisely the kind of claim we have spent this autumn removing from our product, and it shouldn't survive in our writing either.
A memory you can't question is a rumour with good formatting.
Why freshness beats intelligence
There is a tempting belief in AI products that a smarter model fixes bad memory: give it enough context and it will notice that the fact is old. In our experience it does the opposite. A more capable model is better at building a fluent, well-reasoned answer on top of whatever it is given, including a stale fact. The quality of the reasoning hides the age of the premise.
That is why we treat freshness as a property of the data, enforced by the system, rather than something we hope the model will spot. A stock level carries its age. A snapshot past its lifetime arrives labelled as stale. The places where we haven't done that yet, facts without expiry and policies without refresh, are exactly the places where we have found problems. The pattern is consistent enough that we now treat it as a rule: wherever memory has no clock, expect it to be wrong eventually, and expect it to sound right.
Designing forgetting
If the hard part of memory is forgetting on time, then forgetting has to be designed as carefully as remembering. Four principles guide what we are building next.
- A fact should live as long as the thing it describes stays still. Not as long as it was expensive to learn. A stock level changes by the hour; a store's return window changes a few times a year; “this product is dead stock” can change in a week. The lifetime belongs to the subject, not to the effort.
- High-stakes facts get re-checked when they are used. A fact that will drive a recommendation involving money should be confirmed against the store at that moment, not trusted because it was true last month.
- Disagreement is information. When two agents record different values for the same thing, that is the most interesting thing in the system that day. It should reach a person, not sit in an annotation.
- The merchant can always read, question and erase. Not as a privacy feature bolted on, but as the final check on everything above.
None of those principles is exotic. They are how a good employee treats what they know: they remember what matters, they check before acting on something old, they flag it when colleagues disagree, and they tell you what they think they know when you ask. The difference with software is that each of those habits has to be written down, as code, before it exists.
Private by architecture
Memory this specific raises an obvious question: whose is it? Everything Lumnya's agents learn about your store is stored within your store's own space and is never pooled with other merchants' data or used to advise anyone else. When you uninstall, Shopify sends apps a store-deletion request 48 hours later, and Lumnya's handler removes it all: notebooks, facts, the snapshot and the action history. When one of your customers asks for their data, the export includes what the agents recorded about them. What we don't offer yet is an export of the memory itself for you as the merchant; if you need one, ask us.
What we think good AI agent memory needs
If you are evaluating any AI product that claims to “learn your business”, these are the questions we would ask, ourselves included.
- Can it tell me who wrote a fact, and how sure it was? If not, a guess and a measurement look the same.
- How old is the oldest thing it is relying on? Every memory needs a clock, and a policy for what happens when the clock runs out.
- What happens when two parts of it disagree? The honest answer is “it tells you”. The common answer is “the last one wins”.
- Who can write to it? If a shopper's chat can change what the system believes about your store, read the MINJA paper before you trust it.
- Can I read it, and can I make it forget? Memory you can't inspect belongs to the vendor, whatever the contract says.
We are building Lumnya's memory to answer all five with a yes, and the table above is where we stand today. If you want to help us pressure-test it, the private beta is exactly for that.
Memory decides what an agent believes; gates decide what it may do. For the second half, see which actions should always wait for you and a check after the action is a log.
Frequently asked questions
What is AI agent memory?
Information an AI agent keeps between sessions, such as observations, established facts and past results, so it doesn't start from scratch each time. Good agent memory records who wrote each fact, how confident it was and how old it is.
What are the risks of AI agent memory?
Stale facts that keep being used after they stop being true, and poisoning: research on the MINJA attack (2025) showed an agent's memory can be manipulated by ordinary users through their queries alone. Freshness rules and limits on what can write to memory address both.
How does Lumnya's agent memory work?
In three layers: per-agent notebooks of observations and runs, shared facts with an author, a confidence and a no-overwrite rule, and a regularly refreshed snapshot of store data with fixed lifetimes. Fact decay, contradiction detection and a fact browser are not built yet.
Is my store's data shared with other merchants?
No. Everything Lumnya's agents learn is stored within your store's own space, never pooled across merchants, and deleted when you uninstall through Shopify's store-deletion request.
Sources
- [1] S. Dong et al., “Memory Injection Attacks on LLM Agents via Query-Only Interaction” (MINJA), arXiv:2503.03704, first submitted 5 March 2025, revised 12 February 2026 (accessed 19 Oct 2026).
- [2] C. Packer et al., “MemGPT: Towards LLMs as Operating Systems”, arXiv:2310.08560, 2023 (accessed 19 Oct 2026).
- [3] Shopify, Privacy law compliance: mandatory compliance webhooks (accessed 19 Oct 2026).
- [4] Lumnya product behaviour described here was verified in Lumnya's source code on 19 October 2026: the agent namespaces, the fact catalogue and authority rule, confidence values, cache lifetimes, retention, store-deletion handling, outcome measurement, and the policy importer.
Lumnya is a team of ecommerce AI agents for Shopify stores, now in private beta. Join the waitlist.
Comments
…Every comment is read and approved by a human before it appears — the same confirm-gated rule the product runs on.
Loading comments…
Filed under Build Log
All posts