A memory system makes information durable. That creates a second responsibility: deciding when another agent may use what has been stored.

Imagine a fictional architecture note that says a service must retain a human review step. One agent edits the note to say that review is optional. A second agent searches for the operating procedure. Should it immediately receive the changed instruction?

In the accepted foundation of METABOLIQ Brain, an agent can contribute a change without making that change available through subsequent agent reads. Agent-created memories enter a proposed state. A successful agent edit of an active memory returns that record to proposed. The owner must activate it before agents can retrieve it again.

This article examines that small mechanism and its consequences. The implementation discussed here is the accepted MB-001 foundation: a memory vault for one owner on a trusted local machine. Newer retrieval experiments are outside this article's scope.

A successful write is not approval to share

A write-capable agent can submit a memory. Even if its request asks for active status or supplies a manual source type, the service forces the new record to proposed and records agent provenance.

The creation response contains the submitted record. That matters: proposed does not mean that the submitting agent never sees its own text. It means the record is excluded from subsequent agent retrieval until owner activation.

Agents cannot activate memories by editing status. Their permitted edit fields are title, content, tags, memory type and validity dates. Governance fields such as status, sensitivity, visibility and source are outside that editable set. Updating an existing record also requires both read and write grants.

What happens after an agent edit

An owner may activate a proposal so an appropriately authorized reader can retrieve it. If a write-capable agent later changes the active record, the service increments its version, records the editor as an agent and returns the current record to proposed.

A fictional memory lifecycle exercised in the verification tests
StepCurrent stateSubsequent agent retrieval
Agent submits a memoryProposed, version 1Hidden
Owner activates itActive, version 2Available to permitted agents
Agent changes its contentProposed, version 3Hidden again
Owner reactivates itActive, version 4Available to permitted agents

This applies to more than content edits. We separately exercised title, content, tags, memory type, valid-from and valid-until changes. Each successful agent edit returned the record to proposed.

An attempted edit that changes nothing is rejected; it does not create a new proposal. The important transition follows a successful change.

The availability trade-off

The current implementation changes the state of the record itself. It does not keep an older approved revision available to agents while a separate candidate waits for review.

After the edit, direct lookup by an agent returns 404. The record is absent from agent listings and full-text search, including their result totals. Requesting proposed records explicitly does not bypass the active-only agent scope. The writer is subject to the same subsequent-read restriction.

The owner can still inspect the proposed current record and its revision history. Earlier content is preserved there, but agents cannot read the history endpoint.

This choice reduces the chance of another agent consuming an unreviewed change, at the cost of making the record unavailable until owner action. A busy owner can become a bottleneck. Serving the last approved revision while reviewing a candidate would be a different design; we do not claim that capability here.

Activation is one access condition

Active status alone does not grant access. The API derives identity from the authenticated credential and enforces owner scope, namespace grants and a sensitivity ceiling. Agent updates require the relevant operation grants as well.

Our focused verification activated a confidential memory in a personal namespace. A Work-only reader still could not retrieve it. A Personal reader with an internal sensitivity ceiling also could not retrieve it. A reader with the matching namespace grant and sufficient ceiling could.

The API applies these restrictions at the data-access boundary. Multi-row reads use scoped SQL queries; direct reads perform corresponding checks. Per-agent authorization is not implemented as PostgreSQL row-level security in this baseline. Database constraints and append-only protections serve a different purpose: supporting data integrity.

A visibility label is also not a public sharing mechanism. Activating a record does not publish it to the web.

History supports accountability, not proof of truth

The accepted service writes the changed memory, revision snapshot and successful mutation audit event in the same transaction. Revision entries preserve the version, changed fields represented in the snapshot, actor and time. Database protections reject ordinary attempts to update or delete revision and audit rows.

These protections help an owner inspect how a record changed. They are not an externally tamper-evident audit chain: a database superuser remains outside that guarantee.

Agent edits set agent provenance on the current record, so revised text does not continue to present its source type as owner-authored. Older versions retain their earlier snapshots. That attribution still does not establish that the new text is correct.

Source references are stored metadata. Brain does not fetch a supplied URL or independently verify a document in this foundation. Our lifecycle check confirmed that owner activation did not change the source's verified flag to true.

What we tested

For this article, we ran 84 existing backend regressions covering agent authorization, revisions, credential lifecycle, sensitivity restrictions and the route access matrix. All passed. We also added nine focused editorial verification cases in an isolated copy of the accepted source; all nine passed.

Those focused cases exercised the complete proposal-to-activation-to-edit lifecycle, all six agent-editable fields, direct lookup, listings, full-text search, result totals, attempted status-filter bypasses, owner-visible attribution and history, blocked self-activation, and access restrictions after activation.

The tests used Python 3.12 and a disposable PostgreSQL 17 database with fictional records. They exercised the application through its test client against real database migrations. They were not a production deployment, browser acceptance run, concurrency stress test or proof that every possible information channel is closed.

What this review mechanism does not solve

Owner activation is a decision to make a record available under existing permissions. It is not an automated assessment of factual accuracy, source reliability or whether a downstream action is safe.

Validity dates do not automatically resolve conflicting statements. Provenance does not verify a source. A proposed state does not detect malicious instructions inside a memory. An agent that already copied the old text is not forced to forget it when server-side visibility changes.

The owner can edit records directly, and this mechanism does not impose independent review of every owner-authored change. It is a minimal status-based review control, rather than a dedicated review queue or a complete governance system.

The accepted operating scope remains one owner on a trusted local machine. Wider use needs additional operational work, including TLS and tested backup and restore procedures.

The engineering lesson

A shared memory system needs to represent more than the latest text. It also needs to represent who changed that text, what may be retrieved now, and which decisions remain with the owner.

Our accepted foundation makes one of those decisions explicit: a successful agent write does not automatically authorize subsequent agent retrieval.

That boundary is small enough to explain, exercise and challenge. Its limitations are equally important to document before building more sophisticated memory capabilities.

← All engineering articles