Memory an agent can reason with
Most AI memory is a pile of text fetched by resemblance. If software is going to spend your budget, memory has to be something the system can compute with, not something it has to re-read.
Ask a chatbot to remember something and it does roughly this: it saves your sentence, turns it into a list of numbers, and later pulls back the saved sentences whose numbers look closest to whatever you just typed. That is retrieval by resemblance. For "what did we discuss last week" it works fine.
It stops working the moment the software is allowed to act.
Say you tell the system once: never spend more than 40,000 a month on paid social. That is a hard rule. It applies to every budget decision from then until you change it. But it does not resemble the sentence "draft me three headlines for the spring launch." So when the system is about to draft those headlines and set a budget behind them, the rule is not in the retrieved set. It was never deleted. It just did not look similar enough to come back.
That is the first problem. Resemblance is not relevance. What made the rule relevant was its type, that it is a spending constraint, and the fact that a spending decision was being made. Nothing about the wording.
Three failures that compound
A sentence cannot be computed with. Store a budget as prose and every time you want to ask "are we over budget right now" the system has to find the sentence, read the number out of it again, and join it to current spend again. Two turns can reach two different answers with nothing flagging the disagreement.
Text has no lifecycle. Change a target from 3.0 to 2.5 and the old sentence sits in storage next to the new one, contradicting it. Chunks of text do not supersede each other, do not expire, do not carry an owner, and cannot be audited.
Nothing knows who it belongs to. A preference held by one person and a constraint that binds the whole company look identical to a similarity search. When they conflict, and they will, there is no rule that says which one wins.
The alternative: memory as a record, not a note
Voltaire keeps a knowledge graph of your business. Customers, channels, margin, campaigns, spend, risk, and every decision the system has made, all modelled as objects with defined relationships, with a formal-logic engine reasoning over them. Memory lives inside that same graph rather than in a separate store beside it.
A remembered thing is therefore a record, and it carries structure:
- A kind. A preference, a durable fact, an objective to pursue, or background context.
- A type, where one applies. A budget constraint is a budget constraint: it has a platform and an amount, both validated. A performance target has a metric and a threshold. Not prose that mentions a number.
- A scope. Personal, team, or company. This decides who sees it, who may change it, and what happens when two of them disagree. The more specific one wins, and the system flags the conflict when it looks accidental rather than deliberate.
- A source and a weight. Where it came from, and how much it matters. The heaviest ones are always in context. The lightest are never loaded.
- A lifecycle. It can expire. It can be replaced, with a pointer to whatever replaced it.
Why this is the whole point
Once a target is a typed record sitting in the same graph as your live numbers, the system can join the two and derive the answer. Are we hitting the target? That is a rule firing over two facts. No model call. No re-reading a sentence and hoping the parse matches last time.
Memory stops being storage and starts being part of the reasoning. That is the difference between a system that recalls your constraints and a system that respects them.
And it is why we do not run the decision layer on a language model with a good filing cabinet attached. A model that is asked twice can answer twice, differently, with no way to audit either answer. When software is allowed to move money, "mostly remembered the context" is not a standard. It has to be right on every turn, and you have to be able to see why it was right.
This is the plain-language version of an argument the engineering teams building autonomous growth systems are working through in public. Manta's research note on the same problem goes considerably deeper on the representation itself if you want the full treatment.