An AI agent does not need one magical memory system. It needs the right storage for the right kind of state. A file can hold a small project preference, a database can hold durable facts, embeddings can help retrieve related text, and task history can explain what happened.

The short answer

Use explicit storage for important state and retrieval for discovery. Keep permissions, freshness, source, and deletion behavior visible. Never let an embedding search silently become the authority for a financial or destructive action.

Four useful memory types

Files are easy to inspect and work well for project notes, configuration, and user-owned documents. Databases are better for structured facts, status, ownership, and relationships. Embeddings help find semantically related text but can return an approximate match. Task history records actions, results, approvals, and failures.

The agent can combine them. It might retrieve a relevant note, check the current account state in a database, and inspect the last task run before proposing an action. Each source should retain its own authority.

Freshness and permissions

Every memory item needs an owner, source, timestamp, and permission boundary. A stale preference should not override current account data. A private document should not appear in another user’s retrieval result. A deleted record should be removed from indexes and caches according to the product’s policy.

Test retrieval with adversarial cases: similar names, outdated instructions, conflicting documents, and a user without access. Run the test for 2 hours with representative data, then inspect false positives and false negatives.

Keep writes controlled

Let the agent propose a memory update before silently writing it. Apply schemas and validation at the storage boundary. Keep an audit event containing the old value, new value, reason, actor, and approval when appropriate.

For task actions, use an idempotency key and durable status. A retry must not create duplicate work. If the agent’s summary disagrees with the stored result, show the stored result and mark the discrepancy instead of teaching the incorrect summary as new memory.

Sources and limits

OpenAI’s scaling update gives context on agent infrastructure and long-running workloads. Its Cerebras partnership shows why latency can matter to interactive agent behavior. The Amazon partnership illustrates how serving infrastructure can support stateful runtimes. These announcements do not define a memory architecture for your product.

The safest agent memory is boring: explicit sources, clear permissions, controlled writes, and a way for a human to inspect or correct it.

Retrieval is not truth

An embedding search can find a useful passage, but similarity is not authority. Return the source, timestamp, and access decision with each retrieved result. If two documents disagree, show the conflict and ask for a current source instead of blending them into a confident answer.

Use structured state for values that affect money, permissions, or workflow status. Use semantic retrieval for discovery and explanation. This boundary prevents a stale note from overriding the account database or a convenient paragraph from authorizing a destructive action.

Run a 2-hour test with stale, conflicting, deleted, and unauthorized memories. Review what the agent retrieves and what it attempts to write. The test should include a user asking the agent to reveal another person’s private context.

Memory needs a lifecycle

Define creation, update, expiration, correction, deletion, and audit behavior. A memory without an expiry date can quietly become a permanent lie. A memory without an owner cannot be corrected when the user reports a problem.

The best system makes uncertainty visible. It tells the user which memory it used, when it was updated, and whether the answer came from authoritative state or an approximate retrieval. That transparency improves trust without requiring a magical memory feature.

It also makes correction possible.

That is what makes memory useful in production rather than merely impressive in a demo.

Reliable state beats theatrical recall.

That is the engineering standard.

Make it observable.

Then test correction.

Before launch.