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

Context & memory

Shared Memory Write Rules for Company AI Agents: Owners and Change Logs

Set write permissions, fact owners and change logs for shared AI agent memory so one agent's mistake never becomes the company's stored truth.

Be Human typographic cover with the title: Shared Memory Write Rules for Company AI Agents: Owners and Change Logs
Conceptual illustration created with AI · Be Human

Shared memory for an AI agent team works when every stored fact has a named owner, a short list of agents allowed to write it, and a change log that records who changed it, from what source, and why. Without those controls, one agent that misreads a supplier email or a customer note can save the error as company truth, and every other agent will retrieve it with the same confidence. The rules below show how to set write permissions, fact owners and change logs before the shared memory grows.

Key takeaways

  • Give every shared fact one accountable owner who can accept, correct or retire it.
  • Separate reading from writing, and let most agents write only to their own scratch memory.
  • Require a source reference and a timestamp for any entry that leaves scratch memory.
  • Keep an append-only change log so a bad entry can be traced and reverted quickly.
  • Treat conflicting facts as a stop signal for that field, not as something to average.

Why shared memory needs write rules

Reading and writing carry different risks. A reader that retrieves a wrong fact gives one wrong answer, which a person may catch. A writer that stores a wrong fact changes the input for every future answer, including answers from other agents that never saw the original conversation. Shared memory therefore amplifies mistakes in a way a single chat does not.

Most failures start with a reasonable-looking summary. An agent finishes a call and writes that the customer prefers Thursday deliveries. That line then sits beside verified contract terms. Later, a scheduling agent treats it as a commitment. Nobody decided that the preference was a fact, and nobody can easily see where it came from.

The fix is not to stop agents from writing. It is to separate memory into tiers with different write rules, so that the cost of an error depends on which tier it lands in.

Define fact owners before agents write anything

A fact owner is a person or role accountable for a domain: supplier terms for the purchasing lead, delivery policy for the operations manager, product specifications for the technical lead. The owner is not the agent. Agents can propose entries, but the owner decides whether an entry becomes verified company truth. The NIST AI Risk Management Framework treats clear accountability as part of managing AI risk, and fact ownership is the most practical form of that idea for shared memory.

Start with a short register, not a full ontology. For each domain, record the owner, the backup owner, the fields they approve (for example, lead times, pricing rules or warranty terms), and the review cadence. If a domain has no owner who will answer questions about it, that domain should not feed shared memory yet. This sounds strict, but it prevents the most common situation: a fact everyone uses and nobody is responsible for.

Owners also define acceptable evidence. A signed contract, a current price list, or a policy document with a version number can be verified. A message from a sales representative in a chat thread is useful as a lead, but it is not verified until an owner confirms it against a current source.

Set write permissions by memory tier

Write permissions should follow the tier of memory, not the agent's job title. A practical model has four tiers:

  • Scratch memory: the agent may write freely, entries expire, and other agents do not retrieve them by default.
  • Team notes: the agent may write with a source reference, and the entry is visible to agents in the same workflow but marked as unverified.
  • Verified facts: only the fact owner's approval can write or change an entry. Agents submit proposed changes to a review queue.
  • Restricted records: no agent writes. Humans update these records, and agents read them only where their role allows.

Default to denial. The OWASP authorization guidance makes the general point clearly: access decisions should be checked on every request against the permission rules, not assumed from the interface a user came through. For memory, the check belongs in the memory layer itself, so an agent cannot write to verified facts simply because it can reach the storage. Role-based access to AI agent memory goes deeper on how to map roles to tiers.

Keep the permission map short enough to read in one sitting. If a reviewer needs more than one page to understand who can write what, the rules will drift away from what the system actually does.

Build a change log that answers who, what and why

Every write to team notes or verified facts should produce a log entry. The minimum fields are an entry identifier, the field or fact name, the previous value, the new value, the writer (agent identity or named person), the source reference, the approver if one was required, a timestamp, and a one-line reason.

The log should be append-only. Agents and their operators can add entries but cannot edit or delete them. If an entry was wrong, the correction is a new entry that references the original. This keeps the history honest and lets you answer questions like when a lead time changed and which agent changed it, without reconstructing events from memory.

Observability practice offers useful vocabulary here. The OpenTelemetry observability primer describes telemetry as the data that helps you understand what a system did and why. The same idea applies to memory: each event needs enough context attached to be traced later. Store the change log where your operations team already reviews system events, not inside the agent's own memory, where a faulty agent could alter its own record.

Illustrative scenario: a quoting agent records that a supplier's lead time is shorter than the one in the current price list, based on a chat message from a sales representative. Under these rules, the entry lands in team notes with the chat reference attached and is flagged as unverified. The purchasing owner checks the signed supplier terms, finds a longer lead time, and approves a correction. The log shows the original proposal, the rejection reason and the verified value, so the quoting agent's behavior can be reviewed without guesswork.

Roll out write rules in four steps

Do not configure everything at once. Start with one domain that already produces disputes or rework, and proceed in this order:

  • Name the fact owner and backup for that domain, and write down the fields they will approve.
  • Map the memory tiers for those fields and set the write permission for each tier, denying writes by default.
  • Turn on the change log for every write, including rejected proposals, and confirm that operators can search it by field name.
  • Review the first two weeks of entries with the owner, checking which proposals were accepted, which were rejected, and whether any agent wrote where it should not have.

Only after this loop works should you extend the rules to a second domain. Each new domain brings its own owner, its own evidence standards and its own failure modes.

What to do when memories conflict or a bad write is already in use

Conflicts need a rule before they happen. When two sources give different values for the same verified field, the system should not pick the newer value automatically or average the two. It should mark the field as contested, route both values to the owner, and hold high-risk answers that depend on that field until the owner decides. The decision rules for which fact wins are covered in When AI Agent Memories Conflict.

When a bad write has already been used, act in this order: stop new retrievals of the field if the risk is high, use the change log to list every entry derived from the bad value, restore the previous verified value with a new log entry, and review the writer's permissions. If an agent wrote outside its tier, narrow its permissions before investigating the cause. A pause that halts actions while preserving logs and queued work is often the right first move, and the kill switch pattern for business agents describes how to do that without losing evidence.

Periodic review catches what real-time checks miss. Read the log by writer, not only by field. An agent that proposes many corrections to the same domain may be working from a stale source, and that pattern is more useful than any single entry. The memory audit guide gives a review structure you can repeat each cycle.

How Be Human handles shared memory in managed operations

Be Human designs shared memory with these controls from the first engagement. The first phase defines one useful role, the memory and tools it needs, the fact owners, the write tiers, the approval boundaries and an observable success criterion, so the rules are written before the memory grows. In managed operations, the team monitors write activity, runs recurring reviews of the change log with the named owners, reviews permissions when roles or systems change, and handles incidents such as a bad write reaching a customer-facing answer. Changes to the rules themselves go through the same log, so the company can see how its memory policy evolved.

If your team is still deciding which facts should never be written without an owner, the free Be Human AI diagnostic will help you find the first task worth handing to an agent.

Frequently asked questions

Can one shared memory serve every agent in the company? Yes, but only if the shared layer holds verified facts and each agent's working notes stay separate. Agents read from the shared layer by default and write to it only through the permissions for their tier. Task-specific context belongs in scratch memory that expires.

Who should own a fact that an agent learned from a conversation? The owner is the person accountable for that domain, such as the purchasing lead for supplier terms or the operations manager for delivery policy. The agent can propose the fact with its source, but the owner decides whether it becomes verified. If no one is accountable, the fact stays in team notes until someone claims it.

Does an approval step and a change log slow the agents down? Writes to verified facts are much less frequent than reads, so the approval step usually adds little delay to daily work. An append-only log is inexpensive to keep. The slowdown that matters comes from agents reconciling contradictory facts when no owner has been named.

What should happen when a bad entry is already in use? If the field is high risk, stop new retrievals of it, use the change log to find every entry derived from the bad value, and restore the previous verified value with a new log entry. Then review the writer's permissions and the cause, so the same mistake is easier to recognize next time.

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 →