Skip to content
be-human.ai
← Back to the journal

Context & memory

Memory Write Gates for Superintelligent Agents: Who Saves a Fact

A memory write gate decides which agent, employee or system may save a fact to company memory, what gets checked first, and who approves changes.

Be Human typographic cover with the title: Memory Write Gates for Superintelligent Agents: Who Saves a Fact
Conceptual illustration created with AI · Be Human

A memory write gate is the set of rules that decides which agent, employee or system may save a fact to company memory, what must be checked before the fact is stored, and who can correct or remove it later. Without gates, an agent that summarizes a call or reads a supplier email can turn a guess into a company fact that every later answer repeats. The working approach is to separate proposing a memory from approving it, give each memory type a named owner, and log every accepted write.

Key takeaways

  • A write gate separates proposing a fact from storing it, so an agent can suggest a memory without silently committing it.
  • Each type of fact needs its own owner, because a policy change, a customer preference and a safety note carry different risks.
  • Gates check the source, the scope, the sensitivity and possible conflicts before anything enters memory.
  • Every accepted write needs a record of who approved it, when, and which source supports it.
  • Start with two or three memory types and widen the scope only after reviews show the gate catches real errors.

Why every saved fact is a decision

Company memory is not a notebook. Once a fact is stored, retrieval makes it look authoritative. An agent answering a customer or a technician repeats a stored fact with the same confidence whether it came from a signed contract or from a message typed in a hurry. That is why the useful question is not only how memory is stored, but who is allowed to store each kind of fact.

Write access is often granted too broadly in early deployments because it is convenient. If a tool can call a memory update function and nothing checks the caller, any conversation can change what the company believes. OWASP's authorization guidance makes the general point that access decisions should be checked on every request, not assumed because a caller sits inside the system. The same discipline applies to memory writes. The NIST AI Risk Management Framework also treats accountability as part of managing AI risk, which in practice means someone must be named for each decision the system can make on its own.

A gate is therefore not a technical detail for the engineering team to settle later. It is a business rule that says which facts the company accepts from which sources, and who answers for them.

Who may write, and to what

There are three kinds of writers in most company setups, and each should have a different level of trust.

  • People: staff members writing about their own role, their own accounts or their own decisions, within the memory types their role covers.
  • Integrations: systems of record such as a scheduling tool or a billing export, which may write structured fields only after a schema check.
  • Agents: the assistant itself, which should normally propose memories into a queue rather than commit them to shared memory.

The permission should be defined per memory type, not per user. A front-desk employee may be allowed to correct an appointment note but not to change a cancellation policy. A supervisor may approve policy changes but may not add personal details about a customer to a shared profile. Writing these boundaries as a short matrix, with memory types on one axis and writer roles on the other, is usually enough to start. The matrix should say for each cell whether the writer may commit directly, may only propose, or may not write at all.

Separating memory into scopes helps here. A fact about one customer should not be writable by the same rule that governs a company-wide procedure. The memory scopes article describes how account, team and company-wide rules can be kept apart so each gets its own gate.

A decision guide for each proposed fact

When a proposal arrives, the gate should answer a short set of questions in order. The decision guide below is a starting point that can be adapted to your memory types.

  • If the fact comes from a system of record, such as a signed document or a billing export, the integration may write it after a schema check, and the owner is notified.
  • If the fact is a staff member's statement about their own responsibility, it may be stored after that person confirms it and the memory owner accepts it.
  • If the fact is a customer's stated preference, it stays pending until a staff member confirms it, because customers can be wrong, mistaken about who they are speaking to, or testing the system.
  • If the fact changes a policy, a price table, a service rule or a safety instruction, the named owner must approve it before it is stored, with no exceptions for speed.
  • If the fact contradicts an existing memory, the write is held and a conflict item is opened. The gate should never overwrite silently.
  • If the fact contains sensitive personal or financial data that the memory type was not designed to hold, the gate rejects it and says why.
  • If the source of the fact cannot be identified, the proposal is rejected or kept in a review queue with a fixed expiry, never stored as an unlabeled fact.

The order matters. Source and sensitivity checks come before ownership, because a sensitive fact should not reach an owner in the first place if it does not belong in memory at all.

Step by step: setting up the gate

The setup does not need to be large. A useful first version can be defined in a few working sessions with the people who own the work.

  • List the memory types the agent may touch. Begin with no more than three, usually the ones that cause the most repeated questions.
  • For each type, name one owner who approves changes and one backup who can act when the owner is away.
  • Define which people, which integrations and which agent actions may commit writes and which may only propose them.
  • Require every write to carry a source reference, a timestamp and the identity of the proposer.
  • Route proposals into a review queue during the first weeks, so owners see what the agent wants to remember before it does.
  • Add conflict checks so that a new fact disagreeing with an existing one opens a review item instead of replacing it.
  • Log every accepted and rejected proposal with the reason, so the decisions can be audited later.
  • Review the queue on a fixed cadence and record which rules caught real errors. Tighten the rules that catch errors and relax the ones that only add delay.

For teams that share memory across departments, the shared memory write rules article covers owner assignment and change logs in more detail.

Illustrative scenario: a site access change

Illustrative scenario: a facilities coordinator manages several managed buildings. A technician sends a short message in a chat saying that the side gate code at one building was changed that morning. The agent drafts a proposal to update the site record. The gate sees three things: the source is an informal message, the memory type is site access, and site access changes require the coordinator's approval. The write is held, and the coordinator receives the proposal with the original message attached.

The coordinator confirms the change with the building contact and approves the update. Meanwhile, the agent tells anyone who asks that the site record is under review and that they should confirm with the coordinator. The gate also flags that access codes do not belong in general memory at all. The code should live in a restricted secret store with its own access rules, and the memory should record only that the access procedure changed and who confirmed it. The sensitive data article explains which items should never be stored in agent memory.

The scenario shows the pattern. The agent is useful because it notices the change quickly. The gate is useful because the company, not the agent, decides when that change becomes a fact.

How Be Human handles write gates

In Be Human's managed approach, the write gate is defined in the first engagement, alongside the role the agent plays, the memory and tools it needs, its approval boundaries and the success criterion. The gate rules are written with the client's memory owners, not inferred by the agent. During managed operations, permissions are reviewed on a recurring schedule, incidents are handled when a wrong fact reaches memory, and changes to gate rules are logged and approved by the client before they take effect. The goal is that every stored fact can be traced to a source and to an approver, and that the client's team can see the review queue without reading code.

Reviewing, correcting and removing saved facts

A gate controls entry, but memory also needs maintenance after entry. Facts go stale, staff change roles, and some records were accepted under rules that no longer apply. A periodic review should check a sample of stored facts against their sources, looking for expired items, orphaned owners and entries whose approver has left. The memory audit article describes a review routine that fits this purpose.

When a fact is wrong, the owner should choose between three actions. A correction replaces the value and keeps the history. An expiry sets a date after which the fact is no longer used. A removal deletes the record when it should never have been stored. Each action should go into the same change log that recorded the original write. The deletion guide covers how to carry out these actions so the agent stops using a fact everywhere it appears. If you are not sure which memory your first agent should write to, the free Be Human AI diagnostic can help you find the first task worth handing to an agent.

Frequently asked questions

Can an AI agent save a fact to company memory without approval? It can, if the system is built that way, but it is rarely the right default for shared memory. A safer pattern lets the agent propose facts into a queue and allows direct writes only for narrow, low-risk memory types with a clear source. Anything that changes a policy or a customer-facing rule should wait for the named owner.

Who should own a memory type? The owner should be the person accountable for the business area the facts describe, such as operations for site procedures or sales for pricing rules. Each owner should have a backup, so approvals do not stop when one person is unavailable. Ownership should be written down and reviewed whenever roles change.

What should a write gate reject first? The first rejections should cover facts with no identifiable source, facts that contain sensitive data the memory was not designed to hold, and facts that silently overwrite an existing record. These three cases cause the most damage when they pass unnoticed. Once they are handled, the gate can address finer distinctions such as customer statements versus staff confirmations.

How is a write gate different from document access control? Document access control decides who may read a file, while a write gate decides who may change what the company's assistant believes. Both are needed, and a person who can read a policy may still be forbidden from changing it in memory. Role-based rules for memory access cover the read side, and the write gate covers the other half.

Your next step

See where an AI agent fits in your company first.

Take the free Be Human AI diagnostic. A few questions about your work show which task to hand to an agent first, what it needs to know and where a person approves.

Be Human editorial guidance. Examples are illustrative unless explicitly attributed. Sources provide background; implementation choices depend on your workflow.

Less busywork. More room for you.

Bring us the work you wish you had time for.

Book a call to try a personalized AI agent free for 7 days ↗Or take the free AI diagnostic →