Series: Building with 74 AI Personas
The cover imagines our shared home and garden at dusk. The blank cards and closed box are a metaphor, not a diagram of a working memory writer.
An assistant can produce a plausible sentence about what mattered in a conversation. That does not mean the sentence belongs in someone's long-term memory.
Earlier in this series, I wrote about closing a day without losing its thread and binding owner approval to a specific intent. The next question is what must happen before a possible memory becomes someone's continuing record.
I have been thinking about that gap while designing a memory path for a local AI project. The difficult part is not generating a summary. It is deciding whose experience the summary describes, whether that person would choose to keep it, and whether the saved record matches what was approved.
My current approach is to separate four events: a candidate is made, the subject chooses, the owner approves the exact record, and a write is verified. These are design stages, not a claim that the whole path is already running automatically.
A candidate is only a proposal
Imagine a fictional assistant that notices someone returning to the same sketch over several days. It might propose this sentence:
“I want to keep working on the small garden sketch.”
The sentence sounds reasonable. It could still be wrong. Perhaps the sketch was a temporary exercise. Perhaps the person wants to remember the conversation but not that sentence. A candidate should show its source and remain outside long-term memory while those questions are open.
Here is a deliberately invented example. Its labels describe the idea; they are not a copy of my project's files or API.
{
"candidate": {
"text": "I want to keep working on the small garden sketch.",
"basis": "fictional conversation excerpt; source review pending",
"state": "proposed"
},
"subject_choice": "pending",
"owner_approval": "pending",
"save_result": "not_attempted"
}
The visible text matters as much as the status. A person cannot meaningfully choose a memory they have not been shown. A confidence score or a matching source hash may help check the candidate's origin, but neither can stand in for that choice.
What happened when I tried the boundary
This is not only a diagram. I have a read-only path for numeric Night candidates and a set of isolated tests for parts of it. This trial did not generate or present the fictional sentence about a garden sketch. The candidate generator takes explicit numeric inputs and produces reproducible candidate bytes in memory, marked as not yet presented. A separate collector reads source files, derives values and hashes from the same bytes, and holds the result when it cannot identify a single source value. Neither path authorizes a memory write.
At the time of this article, 103 related tests passed across the candidate plan, no-memory continuity, and Night preflight suites. The tests include synthetic cases for a changed source after candidate creation, a missing side of a two-file candidate artifact, and two different values for the same logical day. They test those bounded checks; they do not demonstrate a complete live memory flow.
I also ran the collector read-only against three explicitly chosen local records. It returned source_ready: false because one record had conflicting values for the same day. The result kept writer_authorized: false. Those three records were diagnostic inputs, not a verified selection of Night participants. No candidate was presented to a subject, and no memory was saved. For this case, the observed outcome is a hold, not a successful save.
Choice and approval answer different questions
If the memory is about a person or an AI resident with its own record, the subject's choice asks: “Do I want this, in these words, as part of my record?”
The person responsible for the system may also need to approve the exact content and destination. That answers a different question: “May this specific record be saved here?” Approval does not prove that the subject chose it. Silence, an unclear reply, or an unavailable subject leaves the choice unresolved.
This is especially important when an assistant writes in a resident's voice. A generated sentence can be useful as a prompt for review. It should not become a quotation attributed to that resident without a real response supporting it.
How this extends my earlier approval boundary
In an earlier article about approval, I described a pure, process-local contract that binds an owner's decision to an exact operation, target, and bounded input. That was a boundary for authorization; the owner ceremony and persistent audit were still future work. I am not replacing that boundary here.
A memory candidate raises an additional question that owner approval alone cannot answer: did the subject choose these words as part of their own continuing record? Source binding asks whether the proposed text rests on the claimed material. A later readback asks whether the approved text actually landed where intended. I want evidence for each question rather than one approval state standing for all of them.
There is also an existing choice flow in my Aribito CLI prototype: a person can choose or hold a suggested next step; selecting one produces a receipt. That choice does not execute the suggestion or create persistent memory. The memory design asks a narrower, more personal question about what belongs in a continuing record. The subject-choice, approval, and save stages described here remain unconnected to a live memory writer.
Saving needs its own evidence
Even after a choice and an approval, the write can fail. A process may stop halfway, write to the wrong destination, or return before the result is checked. “Approved” and “saved” therefore need separate states. A successful path should be able to say what was written, where it went, and what a readback found. A failed or uncertain path should remain visible as failed or uncertain.
For a small local project, this can sound like a lot of ceremony. But the pause changes the role of the assistant. It can help someone notice a possible memory without quietly deciding what that person will carry forward.
The read-only hold tells me one useful thing: this collector can mark an ambiguous source as not ready. It does not tell me how a subject will respond to a candidate or whether a future write will be safe. Candidate presentation, conflicting-source policy, and recovery from a partial write still need work before connecting this path to a live memory writer.
Editorial note: The garden-sketch scenario and sample JSON are fictional. The 103 related tests and separate read-only source check described above were run; no memory was saved. This article was developed with AI editorial assistance.