Eleventh page in Operation Scarecrow. If you haven't read the argument page and the four memory-type pages yet, start there. Source citations at the foot of this piece.
Everything covered so far in this section treats AI as the thing reading the four memory tiers. A different, increasingly real question: where is AI already the thing writing and maintaining them, and how much should each tier's self-maintenance actually be trusted right now.
The single most directly relevant paper found in this research
Before the tier-by-tier picture, one finding deserves to lead. A paper — "When Not to Write Memory: Governing False Promotion from Correlated Agent Traces" — formalizes, as its entire subject, the exact problem this section has been calling "an echo, not a confirmation" since the Meridian worked example's reconsolidation walkthrough and the poisoning page's promotion-gate finding: that repeated confirmation across agent traces can look like independent evidence while actually being correlated noise, and that a promotion mechanism which can't tell the difference will confidently promote things that were never actually confirmed. This isn't adjacent research that happens to be useful. It's the same claim, arrived at independently, with a name for the failure mode this section has been describing from the start. Treat it as the anchor citation for that entire argument going forward, not just a footnote here.
Working memory: mature, and the gains are quantified
This is the tier where AI self-maintenance is furthest along. Compaction — compressing prior context into a denser working state for long-running tasks — is now a standard pattern across agent systems, with one reported evaluation showing an 86% reduction in input tokens with no measurable change in task quality. A more autonomous version, the Focus architecture, has the agent itself decide when to consolidate key learnings into a persistent "Knowledge" block and actively prune the raw interaction history that produced it — the agent managing its own working-memory lifecycle rather than a fixed threshold triggering it. This tier's self-maintenance works, is measured, and doesn't carry much governance risk, which tracks with what this section has argued from the start: working memory is the one tier where low ceremony is correct, whether a human or the agent itself is the one doing the housekeeping.
Episodic memory: common practice, with an admitted trust gap
Auto-summarizing session history into a persistent record is already routine. Approaches that trigger a summarization pass whenever a buffer exceeds capacity are one of five mechanism families a 2026 survey identifies across the field, alongside retrieval-augmented stores, reflective self-improvement, hierarchical virtual context, and policy-learned management. What's notable is that the same survey names "trustworthy reflection" as one of the field's open challenges, unresolved as of this research — an admission that nobody has actually established how much an AI-generated summary of what happened should be trusted relative to a human-witnessed account of the same event. That's exactly the question this section would need answered before treating an auto-generated episodic record as equivalent to one a human filed deliberately.
A genuinely new wrinkle is worth surfacing here. Once a fact gets extracted from many conversations and promoted into durable memory, it becomes a derived artifact rather than a raw record, which complicates honoring a right-to-forget request under GDPR — deleting the original conversation doesn't necessarily unwind a fact that was synthesized from it and dozens of others. Nothing in this research resolves that. It's a real, live legal question sitting directly underneath the consolidation mechanism this section depends on.
Semantic memory: the propose-don't-commit pattern already exists, named and standardized
This is the best news in this page, because it's a direct, independent confirmation of something this section argued for without knowing the pattern already existed in production. The "diff-and-approve" pattern — an agent proposes a memory write, the system computes a structured diff against current state, a human reviews that diff, and the write commits only on approval — is real, named, and standardized at the wire-protocol level: a project called memorywire defines the governance JSON schema for exactly this exchange, with a reference UI any backend can inherit. That's this section's semantic-tier steward-approval argument, already built, already has a name, and doesn't require anyone to invent the mechanism from scratch — only to adopt it.
Procedural memory: the least mature, and currently the weakest self-generation case
The Procedural Memory page in this section already covers this finding in full, so this is the short version rather than a repeat. Voyager remains the reference model — an agent writes a code-based skill, validates it through actual execution, and adds only verified skills to a persistent library — and real follow-on work has extended that pattern to general-purpose agents. But a direct benchmark of the approach found self-generated skills currently average 1.3 percentage points worse than not having a skill library at all, with success concentrated specifically in constrained environments that offer deterministic execution verification. Outside narrow, checkable domains, an agent writing its own procedural memory is not yet a clear win.
There's a second wrinkle specific to this tier, and it cuts against treating that number as a fixed verdict: what counts as a "skill" worth writing down is itself a function of how capable the underlying model already is. Anthropic's own guidance on building Agent Skills splits them into two kinds — "capability uplift" skills, which teach the model something it can't yet do reliably, and "encoded preference" skills, which just sequence steps the model can already do into a team's actual workflow — and says the first kind is expected to matter less over time: "Capability uplift skills may become less necessary as models improve. Evals tell you when that's happened." They've built the corresponding test directly into their tooling: if a model starts passing an eval without the skill loaded, that's a signal the skill's technique already got absorbed into default behavior, not that the skill broke. The encoded-preference half doesn't get cheaper as models improve — a stronger model still won't invent a team's specific process unprompted. Anthropic goes a step further and predicts the file format itself will shift: a SKILL.md file today is essentially an implementation plan, detailed "how" instructions, and "over time, a natural-language description of what the skill should do may be enough, with the model figuring out the rest … Eventually, that description may be the skill itself." None of this overturns the SkillsBench finding above — self-generated skills underperforming today says nothing about whether a more capable model self-generating the same skills next year would too. It does mean the procedural tier's supporting infrastructure, the SKILL.md format, the skill libraries, the discovery layer, is best read as a snapshot of what today's models need rather than a permanent architecture.
The maturity ordering is not what intuition would predict
Working memory's self-maintenance is the most mature and best quantified. The semantic tier's propose-and-approve mechanism is the most solved as a governance pattern, even though it's the highest-stakes tier. Episodic self-summarization is the most common in practice but has an admitted, unresolved trust question sitting underneath it. Procedural self-generation — arguably the most intuitive candidate for AI authorship, since it's already code — is the least mature, and currently underperforms outside narrow domains. The tier that looks easiest for AI to build for itself turns out to be the one with the weakest evidence it should.
The tier that looks easiest for AI to build for itself — procedural, since it's already code — is the one with the weakest evidence it should.
What's still unresolved here
Two questions don't get resolved by anything above. The GDPR right-to-forget problem for derived, multiply-sourced semantic facts has no answer anywhere in this research. Whether "trustworthy reflection" gets a real resolution soon, or stays a named-but-unsolved problem indefinitely, isn't knowable from what's surfaced so far — it's a field-wide open challenge, not something specific to this section's own argument. And whether memorywire or an equivalent standard actually gets adopted widely enough to matter, versus staying one implementation among several incompatible ones, is a market question this research can't settle from outside.
Sources. The correlated-traces false-promotion paper: "When Not to Write Memory: Governing False Promotion from Correlated Agent Traces," arxiv.org/html/2607.02579. Working-memory compaction and the Focus architecture: "Context Engineering AI: How To Build Smarter LLM Agents In 2026," mem0.ai/blog/context-engineering-ai-agents-guide, and "Self-GC: Self-Governing Context for Long-Horizon LLM Agents," arxiv.org/pdf/2607.00692. Episodic auto-summarization, the five mechanism families, and the "trustworthy reflection" open challenge: "Memory for Autonomous LLM Agents: Mechanisms, Evaluation, and Emerging Frontiers," arxiv.org/abs/2603.07670. The diff-and-approve pattern and the memorywire standard, including the GDPR derived-artifact complication: "memorywire: A Vendor-Neutral Wire Format for Agent Memory Operations," arxiv.org/pdf/2606.01138. Voyager and skill distillation: "Voyager: An Open-Ended Embodied Agent with Large Language Models," arxiv.org/abs/2305.16291, and "SoK: Agentic Skills — Beyond Tool Use in LLM Agents," arxiv.org/html/2602.20867v1, which reports the SkillsBench self-generated-skill performance figures. The capability-uplift-versus-encoded-preference distinction and the skill-to-specification prediction: "Improving Skill Creator: Test, Measure, and Refine Agent Skills," Anthropic, claude.com/blog/improving-skill-creator-test-measure-and-refine-agent-skills.