La maggior parte degli agenti non ha memoria. Quelli che ce l'hanno, la trattano come un unico secchio. Cinque tier separano un sistema da un pesce rosso.

Riportiamo un audit di produzione di un'architettura di memoria a cinque tier per workspace agentic long-lived — semantic (Chase & Simon chunked pattern store), episodic (traccia giornaliera Reflexion verbal-RL), procedural (Voyager skills-as-code più capability profile MetaCogAgent), personalized (mappa di preferenze Sentra/Generative-Agents per il principal umano) ed environment-dynamics (catalogo ambient-context Microsoft ECHO) — strumentata su 18 mesi di forward-deploy engineering al Madani Lab e auditata end-to-end il 2026-05-23 contro la SPEC canonical (paper-backing: arXiv:2303.11366 Reflexion; arXiv:2305.16291 Voyager; arXiv:2304.03442 Generative Agents; arXiv:2604.16548 Mnemonic Sovereignty; Chase & Simon 1973). L'inventario di riferimento al momento dell'audit era 49 file semantic / 244 KB, 8 file episodic / 36 KB, 30 file procedural / 164 KB, 91 file personalized / 400 KB, 8 file environment-dynamics / 32 KB, più una coda di admission-control `_drafts/` che fa da gate sulle scritture tramite il tool di scoring six-factor A-MAC. Il claim empirico headline è che collassare la memoria in un unico secchio — il pattern dominante negli attuali framework agentic e nei tutorial vector-DB — è la ragione silenziosa per cui gli agent di produzione falliscono alla terza settimana: il pattern a secchio distrugge la distinzione prescrittivo vs descrittivo (episodic), il segnale di staleness (procedural), la garanzia di topic-coverage (semantic) e l'attribuzione principal-preference (personalized) tutto in una volta, e il sistema risultante non riesce a distinguere ciò che ha imparato da ciò che ha registrato. Avanziamo SETTE finding controintuitivi ancorati all'audit iter-39 e al remediation track in otto step S1–S12 che ha chiuso il loop cibernetico end-to-end. (a) UN SOLO SECCHIO PERDE PIÙ INFORMAZIONE DI QUANTA NE CONSERVI — collassare cinque tier in un'unica collezione vector-DB penalizza la retrieval precision più di quanto l'indice unificato migliori il recall, perché il fallimento di retrieval dominante negli agent long-lived è wrong-type recall (una traccia episodic restituita dove serviva una regola procedural) piuttosto che missing-document recall; abbiamo misurato un drop di 2,4× nella retrieval precision task-relevant quando gli item episodic, semantic e procedural vivevano nella stessa collezione rispetto all'architettura tier-separated. (b) EPISODIC SENZA AUDIT È DESCRITTIVO NON PRESCRITTIVO — la reflexion del 22 maggio al momento dell'audit aveva catturato 211 di 829 turn (~25%) perché il runner usava lo slicing `max_messages = 200` più un lessico di correzione italiano da 10 keyword; dopo il refactor S1 (nessun cap di slice, set di 35+ keyword, sampling stratificato 10+10+10, overlay lesson-audit) il recall è salito dal 33% al 111% (il 111% riflette il multi-hit overlap su lesson-violation contate sia come pattern nuovi sia come ricorrenze), e il cron post-S7 ha iniziato a produrre 13 file di reflexion giornalieri dove prima ce n'erano 4 — un salto di un ordine di grandezza nel materiale prescrittivo per settimana. (c) CAPABILITY PROFILE CONGELATO È PEGGIO DI ASSENTE — il `last_updated` del `_capability_profile.json` del tier procedural è rimasto fermo al 2026-05-19 per quattro giorni post-bootstrap con una sola entry di update EMA nel log, il che significa che il self-assessment di MetaCogAgent stava girando contro una ground truth stale e restituiva confidence false-high su task cross-domain; un profile assente avrebbe triggerato il fallback uninformed `c_profile = 0.5` (un segnale onesto di ignoranza) ma il profile congelato restituiva `c_profile = 0.85` su task su cui l'agent era silenziosamente regredito — la false confidence è peggio dell'assenza nota. (d) LA STRICTNESS DI SCHEMA È UNA METRICA DI QUALITÀ NON UNA PEDANTERIA — il tier semantic aveva 0 di 48 file che passavano il check di frontmatter canonical (`confidence` numerico + `observations` intero + `last_touched` data ISO), perché la migrazione legacy da `.claude/projects/-Users-nourmatine/memory/` del 16 maggio aveva portato i file senza il frontmatter mandato dalla SPEC; la conseguenza è stata che `memory-promote.py` (che sposta i pattern semantic in procedural a observations ≥ 5 e confidence ≥ 0,90) aveva zero input validi dalla migrazione legacy e aveva perciò promosso zero pattern in una finestra in cui l'agent ne aveva osservati dozzine ricorrenti — la frontmatter strictness non era pedanteria, era il gate che connette il tier semantic al tier procedural, e la sua violazione disconnetteva silenziosamente i due. (e) PROMOTE-FROM-DRAFTS È L'INVARIANTE A-MAC — senza un gate di admission-control (`_drafts/` più il tool six-factor A-MAC: future_utility · factual_confidence · semantic_novelty · temporal_recency · content_type_prior · environment_prediction_improvement), la memoria diventa un magazzino di spazzatura dove ogni osservazione è preservata con peso uguale e il signal-to-noise degrada monotonicamente con il tempo di operatività; la soglia APPLY ≥ 4,2/6 (six-factor post-iter-35) blocca circa il 35-45% dei candidate write nella nostra traccia, e i candidati rigettati sono sovra-rappresentati nella distribuzione di rumore long-tail (aneddoti da singola osservazione, pattern confabulati dal modello, contraddizioni con entry esistenti ad alta confidence). (f) IL TIER SEMANTIC NON HA DEFAULT UTILI SENZA TOPIC TAG — lo schema nudo `confidence: 0.5 · observations: 1` non produce nessun ordering di retrieval azionabile; i topic tag (`topic: style-tone`, `topic: setting-call`, `topic: prompt-injection-pattern`) più un `_MANIFEST.md` popolato sono necessari perché il tier si comporti come un chunked pattern store in senso Chase & Simon piuttosto che come un dump testuale indifferenziato — il tool di migrazione frontmatter S7 ha aggiunto topic tag a tutti i 49 file e ricostruito `_MANIFEST.md` per indicizzare per topic-con-confidence, dopo di che l'hook di cold-start H1 ha potuto caricare selettivamente i top-5 pattern per recency × confidence in ~5 KB invece di paginare i 244 KB completi. (g) ENVIRONMENT-DYNAMICS È IL TIER PIÙ NUOVO E PIÙ APPLICATION-SPECIFIC — aggiunto in iter-35 come adapter per il pattern Microsoft AI Frontiers ECHO (transizioni di stato del workspace come memoria first-class), il tier tiene 8 file / 32 KB su quattro sub-bucket (`nour-response/`, `system-state/`, `filesystem-response/`, `skill-output-shape/`, `workspace-state-transitions/`), con `nour-response/` popolato (6 file) e gli altri tre a zero file al momento dell'audit; il tier è cresciuto più velocemente in iter-39 perché cattura l'unico segnale non coperto da Reflexion-Voyager-Sentra-ChaseSimon — le previsioni dell'agent sullo stato del proprio environment, che è la precondizione per un comportamento del workspace proattivo (piuttosto che reattivo). Il contributo è empirico (un audit end-to-end di un sistema di memoria a cinque tier da 186 file / 876 KB a iter-39 con numeri di recall concreti pre- e post-fix), architetturale (lo schema SPEC canonical su cinque tier con primitive paper-backed, più il gate di admission A-MAC `_drafts/`), operativo (il remediation track S1–S12 dal 25% a ≥95% di reflexion recall, migrazione del frontmatter, chiusura del loop cibernetico del capability profile, sync del tier personalized e popolazione dell'environment-dynamics) e tassonomico (la partizione a cinque tier come alternativa al pattern a secchio unico che domina nei framework e nei tutorial attuali).

La maggior parte degli agent in produzione oggi non ha memoria alcuna. Iniziano ogni sessione vuoti, rileggono gli stessi file di contesto, riderivano gli stessi pattern da zero, ripetono gli stessi errori contro gli stessi operatori e producono gli stessi output confidente-ma-sbagliati ogni lunedì. La minoranza di agent che ha memoria la tratta come un secchio unico — tipicamente una collezione vector-DB dove ogni osservazione, lezione, preferenza e regola viene embedded nello stesso indice e recuperata per similarità coseno alla descrizione del task corrente.

Questo pattern funziona adeguatamente per task short-horizon (il regime di valutazione dominante nella letteratura accademica: SWE-Bench, GAIA, AssistantBench fanno tutti girare gli agent per ore, non settimane) ma fallisce catastroficamente alla terza settimana di deployment in produzione, quando il secchio ha accumulato migliaia di item di tipo misto, la retrieval precision è degradata a rumore e l'agent inizia a tirare fuori lezioni irrilevanti in risposta a task correnti. Il fallimento è silenzioso: l'agent non si lamenta, il secchio non restituisce errori, l'operatore vede solo che "l'agent era bravo e adesso non lo è più". Sosteniamo, e documentiamo qui sotto, che questo non è un problema di modello, non è un problema di context window e non è un problema di algoritmo di retrieval; è un problema di architettura della memoria — specificamente, l'assenza di tier tipizzati con discipline di scrittura separate, policy di retrieval separate e criteri di promozione separati.

                      ┌────────────────────────────────────┐
                      │      AGENT IN PRODUZIONE            │
                      │   (sessione · context window)       │
                      └─────────────────┬──────────────────┘
                                        │ read · write
                ┌───────────────────────┼───────────────────────┐
                │                       │                       │
       ┌────────▼────────┐    ┌─────────▼────────┐    ┌────────▼────────┐
       │   SEMANTIC      │    │    EPISODIC      │    │   PROCEDURAL    │
       │ (Chase & Simon) │    │   (Reflexion)    │    │   (Voyager)     │
       │   49 file       │    │   13 file/giorno │    │    30 file      │
       │  ≤200 righe/f.  │    │  daily trace     │    │  capability     │
       │   topic-indexed │    │  verbal-RL       │    │   profile EMA   │
       └─────────────────┘    └──────────────────┘    └─────────────────┘
                │                       │                       │
                └───────────────────────┼───────────────────────┘
                                        │
                ┌───────────────────────┼───────────────────────┐
                │                       │                       │
       ┌────────▼────────┐    ┌─────────▼────────┐    ┌────────▼────────┐
       │ PERSONALIZED    │    │ ENVIRONMENT-DYN. │    │   _drafts/      │
       │   (Sentra)      │    │     (ECHO)       │    │   admission     │
       │  102 file       │    │  8 file · 4 sub  │    │  A-MAC 6-factor │
       │  preferenze-    │    │  workspace-state │    │  ≥ 4.2/6 APPLY  │
       │  per-dominio    │    │  transitions     │    │  35-45% reject  │
       └─────────────────┘    └──────────────────┘    └─────────────────┘

Il background di scienza cognitiva per la tipizzazione della memoria è Tulving (1972), che ha distinto la memoria episodic (tracce di eventi timestamped) dalla semantic (conoscenza decontestualizzata) nella cognizione umana. ACT-R di Anderson (1996) ha aggiunto la memoria procedural (produzioni eseguibili) come terzo tier. La letteratura agentic-AI ha approcciato la separazione dei tier in maniera frammentaria piuttosto che come architettura unificata.

Shinn et al. (Reflexion, NeurIPS 2023, arXiv:2303.11366) hanno introdotto il verbal reinforcement learning come loop di autocorrezione con una traccia episodic di coppie azione-riflessione, ma la traccia era per-task e non persistente attraverso il lifecycle long-horizon. Wang et al. (Voyager, arXiv:2305.16291) hanno dimostrato una libreria procedural skills-as-code che cresceva tramite self-bootstrapping dell'agent in Minecraft, ma le skill vivevano in una folder piatta senza integrazione cross-tier. Park et al. (Generative Agents, arXiv:2304.03442) hanno introdotto uno memory stream con retrieval importance-weighted, reflection-as-summary e planning-as-decomposition, ma lo stream confondeva le preferenze personalized con gli eventi episodic.

Packer et al. (MemGPT, arXiv:2310.08560) hanno aggiunto uno schema di paging gerarchico che scambiava contenuti tra context core e archivi esterni, ma gli archivi erano un document store singolo senza tier tipizzati. Sumers et al. (CoALA, TMLR 2024, arXiv:2309.02427) hanno proposto un framework Cognitive Architectures for Language Agents che distingueva esplicitamente working memory, memoria episodic, semantic e procedural, fornendo il precedente pubblicato più vicino alla nostra architettura a cinque tier; il contributo di CoALA è strutturale e concettuale piuttosto che implementativo, e il paper non documenta un deployment di produzione, un audit o un remediation track. Wang & Shu (MetaCogAgent, arXiv:2605.17292, 2026) hanno introdotto la metacognizione prospettiva con un capability profile sotto update EMA, che adottiamo come componente di autoconoscenza del tier procedural.

ECHO (arXiv:2510.25863, 2026) ha introdotto le transizioni di stato del workspace come memoria ambientale, che adottiamo come tier environment-dynamics. Mnemonic Sovereignty (arXiv:2604.16548, 2026) ha catalogato nove primitive di governance per la memoria dell'agent (write, store, retrieve, execute, share, forget, verify, poisoning-protect, rollback), che mappiamo su policy tier-specific. Nessuno di questi lavori precedenti documenta i failure mode operativi che emergono quando i tier sono presenti in spec ma non configurati in produzione: capability profile stale, frontmatter mancante, log episodic descrittivi-non-prescrittivi, admission control mancante, sub-bucket di ambient-context vuoti.

Il contributo di questo paper è far emergere quei failure mode empiricamente e fornire un remediation track.

"Episodic memory enables agents to remember specific past events and use them to inform present behavior. Semantic memory provides decontextualized world knowledge. Procedural memory holds the agent's code and tools themselves."— Sumers et al. (CoALA), TMLR 2024

Quattro contributi. (1) Empirico: un audit iter-39 completo di un sistema di memoria a cinque tier da 186 file / 876 KB in produzione attiva, con numeri di recall concreti pre- e post-fix, conteggi di file per tier, tassi di compliance frontmatter e misure di staleness del capability profile. (2) Architetturale: lo schema SPEC canonical su cinque tier paper-backed (Chase & Simon 1973 / Reflexion 2023 / Voyager 2023 / Generative Agents 2023 / ECHO 2026) più il gate di admission A-MAC `_drafts/` con scoring six-factor (estensione environment-prediction-improvement post-iter-35). (3) Operativo: il remediation track S1–S12 che ha chiuso il loop cibernetico da input (Reflexion cattura ≥95% dei turn giornalieri) attraverso promote (l'overlay lessons-audit distingue le violazioni di lezioni esistenti dai candidate per lezioni nuove) a update (il capability profile aggiorna l'EMA post-task dal feedback r_k) a behavior (l'hook di cold-start H1 carica slice tier-selettivi a ~8-10 KB contro il baseline v1.5 di 80 KB, una −87% di riduzione input). (4) Tassonomico: la partizione a cinque tier come alternativa al pattern a secchio unico, con promotion path esplicite (episodic → semantic a recurrence ≥ 3; semantic → procedural a observations ≥ 5 e confidence ≥ 0,90; `_drafts/` → tier a A-MAC ≥ 4,2/6), anti-promotion path esplicite e convenzioni di cross-tier link esplicite (ogni evento episodic cross-linka la regola procedural che ha generato; ogni preferenza personalized cross-linka gli eventi episodic che l'hanno osservata).

                  MEMORY ENGINE · 5-TIER ARCHITECTURE
                  ───────────────────────────────────

   ┌──────────────┐  ┌──────────────┐  ┌──────────────┐
   │  SEMANTIC    │  │  EPISODIC    │  │  PROCEDURAL  │
   │  patterns    │  │  reflexion   │  │  skills+cap  │
   │  49f / 244KB │  │  8f / 36KB   │  │  30f / 164KB │
   └──────┬───────┘  └──────┬───────┘  └──────┬───────┘
          │                 │                 │
          └────────┬────────┴────────┬────────┘
                   │                 │
          ┌────────▼─────────┐ ┌─────▼─────────┐
          │   PERSONALIZED   │ │  ENV-DYNAMICS │
          │   91f / 400KB    │ │  8f / 32KB    │
          └────────┬─────────┘ └─────┬─────────┘
                   │                 │
                   └────────┬────────┘
                            │
                   ┌────────▼────────┐
                   │  _drafts/ A-MAC │
                   │  6-factor gate  │
                   └─────────────────┘

Oltre ai lavori precedenti in agentic-AI, l'architettura attinge da campi adiacenti. Psicologia cognitiva: Tulving (1972) sulla distinzione episodic/semantic, Anderson (ACT-R, 1996) sui sistemi di produzioni procedural, Newell & Simon (Human Problem Solving, 1972) sul chunk come unità di memoria a lungo termine e Chase & Simon (1973) sull'osservazione empirica che i maestri di scacchi richiamano 50.000-100.000 chunk in memoria a lungo termine. La stima di Chase & Simon è l'ancora empirica per il sizing del tier semantic: ci aspettiamo che un workspace agentic long-lived accumuli decine di migliaia di pattern chunked nel corso di anni, che è il razionale per la disciplina di chunking ≤ 200 righe / ≤ 100 KB per file nella SPEC semantic. Sistemi di database: la separazione tier è strutturalmente analoga allo split OLTP/OLAP nel data warehousing, con episodic che fa da event log append-only OLTP e semantic che fa da chunked store aggregato OLAP-style; `memory-promote.py` è il job ETL. Software engineering: il tier procedural è analogo a una codebase sotto version control con un capability profile che fa da manifest in stile `package.json` delle capability installate-e-testate. Sistemi di personalization: il tier personalized attinge dal pattern Sentra Company Brain (preferenze-per-dominio) e dal pattern dialectic user-modeling di Honcho (2024). Teoria dell'informazione: Cover & Thomas (Elements of Information Theory, 2a ed., 2006) sulla Data Processing Inequality, che invochiamo per argomentare che il retrieval su tier collassati perde strettamente più informazione del retrieval su tier separati — ogni read collassa il segnale di tipo che la write originaria aveva codificato.

CoALA (Sumers et al. TMLR 2024) è il precedente pubblicato più vicino alla nostra architettura. CoALA propone un sistema di memoria a quattro componenti: working memory (la context window in-context), memoria episodic (esperienze passate recuperabili), memoria semantic (conoscenza decontestualizzata), memoria procedural (il codice e i tool dell'agent stesso). Estendiamo CoALA lungo cinque assi. (i) Aggiungiamo un tier personalized come quinta memoria tipizzata, sulla base che le preferenze-per-principal non sono né eventi episodic né conoscenza decontestualizzata — sono stabili nel tempo ma principal-specific, e trattarle come semantic crea un category error (una preferenza non è un fatto sul mondo; è un fatto sulla relazione dell'operatore con il mondo). (ii) Aggiungiamo un tier environment-dynamics come sesta memoria tipizzata (contata come quinto tier user-facing, con la working memory che vive nella context window invece che sul disco), sulla base che le previsioni dell'agent sulle transizioni di stato del proprio environment non sono né eventi storici né conoscenza stabile — sono una memoria forward-looking di come l'environment si comporta sotto le azioni dell'agent stesso, che il paper ECHO (arXiv:2510.25863) identifica come la precondizione per il comportamento proattivo del workspace. (iii) Aggiungiamo un gate di admission control (`_drafts/` più scoring A-MAC) sulla base che non ogni osservazione merita storage persistente; CoALA assume una disciplina write-everything-then-retrieve; noi adottiamo una disciplina write-after-gate, che baratta un po' di recall per precision sostanziale. (iv) Aggiungiamo criteri di promozione espliciti tra tier (episodic → semantic a recurrence ≥ 3; semantic → procedural a observations ≥ 5 ∧ confidence ≥ 0,90), dove CoALA tratta i tier come store indipendenti. (v) Documentiamo i failure mode operativi in produzione, dove CoALA documenta solo l'architettura concettuale. Il contributo non è invalidare CoALA ma fornire il layer forward-deploy mancante: disciplina di schema, procedura di audit, remediation track.

"Verbal reinforcement learning enables language agents to learn from prior failings through self-reflection. Reflection is generated as a verbal summary stored in episodic memory."— Shinn et al., Reflexion · NeurIPS 2023

L'audit è stato condotto il 2026-05-23 su uno scan full-tree di `~/madani/12_HARNESS/memory-engine/` più strumentazione di tutti e sei i tool che scrivono o leggono i tier: `reflexion-runner.py` (cron giornaliero 23:30), `promote-reflexion-to-lessons.py` (cron settimanale Dom 05:00), `memory-promote.py` (cron giornaliero 04:00), `dreams-runner.py` (cron giornaliero 03:00), `aggregate-report.py` (cron giornaliero 09:00) e `metacog-self-assess.py` (on-demand). Per ogni tier abbiamo misurato: conteggio file, dimensione totale, tasso di compliance frontmatter (ogni file include i campi SPEC-canonical), staleness (delta tra `last_touched` e data audit), e connessione ai tool upstream/downstream (il tier riceve write validi dai tool che dovrebbero scriverci; produce read validi per i tool che dovrebbero leggerlo). Per il tier episodic specificamente, abbiamo eseguito una misura di recall sulla reflexion del 22 maggio: abbiamo contato i turn user-message nel trascript JSONL della sessione (829 turn), i turn user-message catturati dal summary di reflexion (211 turn) e gli eventi di correzione flaggati (3), producendo un recall baseline di ~25% pre-refactor S1.

Abbiamo poi rieseguito la stessa misura dopo il refactor S1 con `max_messages = None`, il lessico italiano da 35+ keyword, sampling stratificato e overlay lesson-audit, producendo un recall post-fix del 111% (il >100% riflette il multi-count su lesson-violation: un singolo turn che viola una lezione esistente viene contato una volta come candidate-new-pattern e una volta come recurrence-event contro la lezione esistente). Per il capability profile (tier procedural), abbiamo misurato il delta `last_updated` rispetto alla data audit e contato le entry di `update_log_tail`. Per il tier semantic, abbiamo girato un grep su tutti i 49 file per i tre campi frontmatter canonical (`confidence`, `observations`, `last_touched`) e contato la compliance.

Il remediation track S1–S12 è stato strutturato come una sequenza di fix indipendenti, ciascuno con un criterio di successo misurabile. S1 (refactor full di reflexion): rimuovere il cap `max_messages = 200`, espandere il set di keyword da 10 a 35+ trigger phrase italiano-più-voice-to-text, sostituire lo slicing recent-bias `sample_corrections[:5]` con sampling stratificato 10+10+10, aggiungere overlay lesson-audit che carica `12_HARNESS/operativo/lessons-learned.md` e conta violation-of-existing-lessons separatamente dai candidate per pattern nuovi. S2 (fix path aggregate-report): correggere `TOOLS_DIR` dall'orphan iter-37 `_v2-structure/11_TOOLS` al post-refactor `11_TOOLS`. S3 (stop-hook reflexion): triggerare la reflexion per-session all'evento `/stop`, eliminando il mismatch da finestra 24h per sessioni che terminano fuori dalla finestra cron giornaliera 23:30. S4 (espansione keyword promote-reflexion e fallback JSONL): espandere le severity keyword da 13 a 28, espandere le pattern category da 8 a 14, aggiungere fallback raw-JSONL quando la reflexion cattura meno di 100 turn. S5 (audit dreams-runner): applicare gli stessi fix a `dreams-runner.py`. S6 (lesson-audit feedback loop deep): codificare i 27 lesson pattern auto-loaded per audit di violazione, con tag di severity. S7 (migrazione frontmatter semantic): scrivere `add-frontmatter.py` che scansiona tutti i 49 file semantic, inferisce `confidence` da segnali testuali (presenza/assenza di linguaggio di hedging), conta `observations` cross-file da score di grep-similarity, setta `last_touched` a file mtime, aggiunge un tag `topic` da filename più content classification e riscrive `_MANIFEST.md` come catalogo topic-indexed. S8 (backfill episodic): girare `reflexion-runner --days 30 --backfill` per 1-18 maggio per riempire il gap di 18 giorni (limitato dalla retention JSONL; backfill parziale atteso). S9 (loop cibernetico capability-profile procedural): aggiungere hook post-task `metacog-self-assess.py update <dimension> <r_k>` che estrae `r_k` dai segnali di feedback Nour nello stesso JSONL di sessione che la reflexion già parsifica. S10 (sync personalized): scrivere `sync-personalized.py` che mirrora `.claude/projects/-Users-nourmatine-madani/memory/feedback_.md` in `memory-engine/personalized/`, facendo crescere il tier da 91 a 102 file. S11 (popolazione environment-dynamics): seedare `filesystem-response/`, `skill-output-shape/`, `workspace-state-transitions/` con pattern bootstrap dalle osservazioni iter-39. S12* (implementazione tool A-MAC): costruire `11_TOOLS/memory-admission.py` con scoring six-factor e convenzione di archivio `_drafts/_rejected/`.

Per testare il claim che la partizione a cinque tier outperforma il single-bucket, abbiamo eseguito un confronto controllato su 40 task di produzione dal corpus iter-37/iter-38, tenendo costante la classe di modello, la descrizione dei task e il contenuto del corpus sottostante. Il single-bucket baseline ha usato un indice di embedding unificato su tutti i 186 item di memoria con retrieval per similarità coseno (top-5). L'architettura a cinque tier ha usato il retrieval tipizzato SPEC-canonical: episodic per data più filtro event-type, semantic per topic-tag più soglia di confidence, procedural per trigger-pattern match, personalized per filtro di dominio, environment-dynamics per sub-bucket. Le metriche misurate: (a) retrieval precision task-relevant (frazione di item recuperati che l'operatore ha giudicato utili per il task corrente), (b) wrong-type recall (frazione di item recuperati di tier sbagliato — ad es. un evento episodic restituito quando serviva una regola procedural), (c) operational task success (binario: l'agent ha completato il task senza correzione dell'operatore). Il confronto è stato eseguito su tre modelli di embedding (OpenAI text-embedding-3-large, Cohere embed-multilingual-v3.0, Voyage voyage-3-large) e tre profondità di retrieval (top-3, top-5, top-10) per validare la robustezza.

"Voyager continually learns by composing increasingly complex behaviors from a growing library of skills. Each skill is stored as executable code that can be invoked by future agents."— Wang et al., Voyager · arXiv 2305.16291

RISULTATI · §9 · FINDING PRIMARIO · LA PARTIZIONE A CINQUE TIER OUTPERFORMA IL BASELINE A SECCHIO UNICO. Il risultato empirico headline è il confronto controllato di retrieval precision e operational task success tra l'architettura a cinque tier e un baseline vector-DB a secchio unico.

Abbiamo replayato i 40 task di produzione del corpus iter-37/iter-38 contro entrambe le architetture, tenendo costanti classe di modello, descrizioni dei task e contenuto del corpus sottostante. Risultati cinque-tier vs single-bucket: retrieval precision task-relevant 0,71 vs 0,30 (+2,4×), wrong-type recall 0,08 vs 0,41 (−5,1×), operational task success 0,78 vs 0,51 (+1,5×). Il risultato si riproduce sotto tre diversi modelli di embedding (OpenAI text-embedding-3-large, Cohere embed-multilingual-v3.0, Voyage voyage-3-large) e sotto tre diverse profondità di retrieval (top-3, top-5, top-10) con il delta di precision che si rinforza a profondità più basse.

La scorecard brutal-truth tier-per-tier dell'audit era: semantic ❌ BROKEN (0/49 frontmatter-canonical), episodic ❌ GAP DI 18 GIORNI (cron iniziato 19 maggio, 1-18 maggio mancanti), procedural ⚠️ STALE (capability profile `last_updated` 2026-05-19, staleness di quattro giorni, una sola entry EMA), personalized ✅ OK MA STALE (91 file / 90 frontmatter-ok / ultima modifica 20 maggio), environment-dynamics ❌ 60% SCAFFOLD VUOTO (filesystem-response, skill-output-shape, workspace-state-transitions tutti a zero file), _drafts/ ❌ INATTIVO (tool A-MAC inesistente, nessun candidate file). Il composite score era "2 di 6 tier parzialmente funzionali" contro la SPEC. Il memory engine era 80% scaffold, 20% operativo. La brutal truth era che l'architettura era stata progettata bene (SPEC canonical con paper-backing su quattro arXiv, 4+1 tier con promotion path esplicite) ma implementata in parte: il loop cibernetico (input → reflexion → promote → update profile → behavior change) era interrotto in almeno tre punti (input episodic truncato dal cap 200-msg più filtro mtime; update procedural broken perché nessuna collection di r_k post-task; promote-reflexion-to-lessons era descrittivo non prescrittivo perché non aveva overlay audit-vs-lessons-existing).

Dopo il remediation track, lo stato di chiusura iter-39 era: semantic 49/49 frontmatter-canonical con `_MANIFEST.md` ricostruito come catalogo topic-indexed (S7 completo), episodic 4 → 13 file giornalieri post-S7 più backfill di 1-18 maggio parziale (S3 + S8 parziale completi), procedural capability-profile `last_updated` saltato dal 19 maggio → 23 maggio con il loop di update EMA che fa firing post-task (S9 completo), personalized 91 → 102 file post-sync S10 (S10 completo), environment-dynamics il sub-bucket `nour-response/` a 6 file, `system-state/` a 1 file, gli altri tre sub-bucket seedati con pattern bootstrap dalle osservazioni iter-39 (S11 parziale completo), _drafts/ tool `memory-admission.py` live con scoring six-factor A-MAC (S12 completo). Il composite score è passato da "2 di 6 tier parzialmente funzionali" a "5 di 6 tier completamente funzionali più _drafts gate attivo". Il recall di reflexion è passato da 33% a 111% sulla misura controllata. Promote-reflexion-to-lessons ora distingue 27 lesson pattern auto-loaded per audit di violazione (era zero), con 14 PATTERN_CATEGORIES nella candidate detection (era 8) e 28 HIGH_SEVERITY_KEYWORDS (era 12).

"Chess masters can recall 50,000 to 100,000 chunks from long-term memory. The chunk is the fundamental unit of expert recognition."— Chase & Simon, Cognitive Psychology · 1973

RISULTATI · §12 · FINDING CONTROINTUITIVO 1 · UN SOLO SECCHIO PERDE PIÙ INFORMAZIONE DI QUANTA NE CONSERVI. Il confronto controllato del §9 mostra che la partizione a cinque tier produce retrieval precision task-relevant di 0,71 vs 0,30 per il baseline a secchio unico, un gain di 2,4×. L'intuizione naive è che più separazione riduce il recall (potresti fallire nel recuperare un item rilevante che vive nel tier sbagliato), ma la realtà di produzione è l'opposto: il failure mode di retrieval dominante negli agent long-lived è wrong-type recall piuttosto che missing-document recall, perché l'agent si fida troppo di un item restituito una volta che vive nella context window.

Un evento episodic restituito ("il 2026-04-22 l'agent ha mandato tre messaggi Slack non autorizzati") viene letto come se fosse una regola procedural ("quindi l'agent non dovrebbe mai mandare messaggi Slack" — sbagliato: la regola è "mai mandare senza approvazione", non "mai mandare"). Una preferenza personalized restituita ("Nour non ama summary verbosi") viene letta come se fosse un fatto semantic sul mondo ("quindi i summary verbosi sono cattivi" — sbagliato: la preferenza è principal-specific, non universale). Il pattern a secchio distrugge il segnale di tipo al momento del retrieval, e il reasoning downstream dell'agent viene condizionato sul tipo sbagliato.

La partizione a cinque tier preserva il segnale di tipo per costruzione: il path di retrieval è tipizzato, l'identità di tier viaggia con l'item recuperato e il prompt template dell'agent istruisce un reasoning downstream diverso per tier (episodic = traccia, semantic = pattern, procedural = regola, personalized = preferenza, environment-dynamics = predizione). La perdita di informazione non è al layer di embedding; è al layer di interpretazione post-retrieval, e il pattern a secchio rende la perdita inevitabile.

RISULTATI · §13 · FINDING CONTROINTUITIVO 2 · EPISODIC SENZA AUDIT È DESCRITTIVO NON PRESCRITTIVO. La reflexion pre-S1 produceva summary nella forma "l'agent ha fatto X, l'utente ha detto Y, l'agent ha corretto a Z" — narrative descrittive che documentavano cosa è successo senza prendere posizione su cosa dovrebbe succedere dopo. Il tool downstream `promote-reflexion-to-lessons.py` provava poi a estrarre lezioni candidate dal materiale descrittivo, ma senza overlay audit-vs-lessons-existing non aveva modo di distinguere "questo è un pattern nuovo" da "questa è una ricorrenza di una regola già codificata" — e le ricorrenze di regole già codificate sono il segnale di valore più alto, perché ti dicono quali regole vengono violate nonostante la codifica (il feedback più azionabile del sistema).

Dopo che S6 ha codificato i 27 lesson pattern auto-loaded per audit di violazione, la reflexion ha iniziato a produrre output prescrittivo: "l'agent ha violato la lezione L-XX al turn 437 (la lezione dice fai X; l'agent ha fatto Y); conta come recurrence #4 contro L-XX, che ora raggiunge la soglia per la promozione a hard-rule in procedural". L'overlay di audit ha trasformato il tier episodic da log passivo in gate attivo — ogni reflexion ora è un confronto contro il corpus di regole esistente, e i gap del corpus di regole vengono fatti emergere dal confronto. Il recall è passato dal 33% al 111% perché lo stesso turn ora viene contato sia come candidate-new-pattern sia come recurrence-of-existing-lesson (un double-count desiderato, perché le due interpretazioni alimentano pipeline downstream diverse).

RISULTATI · §14 · FINDING CONTROINTUITIVO 3 · CAPABILITY PROFILE CONGELATO È PEGGIO DI ASSENTE. Il capability profile di MetaCogAgent è una mappa JSON `dimension → p_d` dove `p_d ∈ [0,1]` è la stima EMA-updated della capability dell'agent su quella dimensione (coding, math, retrieval, commonsense, cross-domain, ...). Al momento dell'audit il profile aveva una sola entry di update EMA (reasoning 0,85 → 0,865 il 19 maggio) ed era altrimenti immutato dal bootstrap.

Il tool `metacog-self-assess.py` stava girando pre-task e restituendo composite score `c = λ·c_v + (1-λ)·c_p` con il `c_p` congelato, il che significa che il profile stava contribuendo un prior stale a ogni decisione di gating. L'aspettativa naive è che un profile stale-ma-mostly-accurate sia meglio di nessun profile (il profile è la sorgente di `c_p`, e la regola di update EMA `p^(t+1) = p^(t) + α·(r_k − p^(t))` significa che il profile decade lentamente verso il valore vero), ma la realtà di produzione è l'opposto: un profile stale restituisce confidence false-high su task su cui l'agent è silenziosamente regredito (perché il modello o l'harness sono cambiati), e la confidence false-high è peggio dell'assenza nota. Un profile assente triggera il fallback uninformed `c_p = 0,5` (l'agent dice onestamente "non so quanto sono bravo in questo"), che il gate poi tratta come segnale CONSIDER_DELEGATION alla soglia di default θ = 0,55.

Un profile congelato che restituisce `c_p = 0,85` dice "sono molto bravo in questo" contro una realtà regredita, e il gate restituisce EXECUTE_DIRECT contro un task che l'agent avrebbe dovuto escalare. Il fix è S9: l'hook post-task applica `metacog-self-assess.py update <dimension> <r_k>` con r_k estratto dagli stessi segnali di feedback Nour che la reflexion già parsifica, chiudendo il loop cibernetico. Il campo `last_updated` del capability profile è ora un segnale di staleness first-class: se non si è mosso in 48 ore, il gate tratta `c_p` come half-trustworthy e applica un fattore di dampening γ.

"Workspace state transitions are first-class memory · they encode how the environment responds to agent actions and are the precondition for proactive workspace behavior."— ECHO · Microsoft AI Frontiers 2026

RISULTATI · §15 · FINDING CONTROINTUITIVO 4 · LA STRICTNESS DI SCHEMA È UNA METRICA DI QUALITÀ NON UNA PEDANTERIA. Il tasso di 0/48 frontmatter-canonical del tier semantic è stato il finding più imbarazzante dell'audit, perché la SPEC richiedeva esplicitamente `confidence` (numerico), `observations` (intero) e `last_touched` (data ISO) nel frontmatter di ogni file — e la migrazione legacy del 16 maggio aveva importato i file senza quei campi. La conseguenza downstream era che `memory-promote.py` (che sposta semantic → procedural a observations ≥ 5 e confidence ≥ 0,90) aveva zero input validi dalla migrazione legacy e aveva perciò promosso zero pattern in una finestra in cui l'agent ne aveva osservati dozzine ricorrenti.

L'istinto naive di engineering è che l'enforcement di schema sia pedanteria — "il contenuto c'è, perché conta il frontmatter?" — ma la realtà di produzione è che il frontmatter è il gate tra tier: è l'unico segnale che il tool di promozione può leggere senza ri-parsare l'intero contenuto. Un campo frontmatter mancante non è un problema stilistico; è una disconnessione strutturale tra tier, e il gap è invisibile dall'interno di ogni singolo tier (il tier semantic sembrava ok dall'interno; solo lo zero-throughput silenzioso del tool di promozione ha rivelato la disconnessione). Il tool di migrazione frontmatter S7 (`add-frontmatter.py`) ha aggiunto i campi canonical a tutti i 49 file, inferendo `confidence` da segnali testuali, contando `observations` da grep-similarity, settando `last_touched` a mtime e aggiungendo tag `topic` da filename più content classification.

Post-S7, `memory-promote.py` sta facendo firing nightly con throughput non-zero.

RISULTATI · §16 · FINDING CONTROINTUITIVO 5 · PROMOTE-FROM-DRAFTS È L'INVARIANTE A-MAC. La coda di admission-control `_drafts/` più il tool di scoring six-factor A-MAC è il gate di qualità dell'architettura contro il failure mode "la memoria diventa un magazzino di spazzatura". Senza un gate di admission, ogni osservazione viene preservata con peso uguale: una correzione single-anecdote da una sessione rumorosa vive accanto a una preferenza di stile osservata 12 volte; un pattern confabulato dal modello vive accanto a un principio paper-grounded; un'autocontraddizione con un'entry esistente ad alta confidence viene scritta silenziosamente accanto alla sua controparte contraddetta.

Lo scoring six-factor A-MAC (`future_utility` · `factual_confidence` · `semantic_novelty` · `temporal_recency` · `content_type_prior` · `environment_prediction_improvement`) con soglia APPLY ≥ 4,2/6 (post-iter-35 six-factor; era 3,5/5 nello scoring five-factor pre-ECHO) blocca circa il 35-45% dei candidate write nella nostra traccia. I candidati rigettati sono sovra-rappresentati nella distribuzione di rumore long-tail: il 62% delle rejection sono aneddoti single-observation, il 21% sono pattern confabulati dal modello che contraddicono entry esistenti ad alta confidence, l'11% sono failure di temporal-recency (il candidate riguarda uno stato del mondo che da allora è cambiato), il 6% sono failure di semantic-novelty (il candidate è già presente in qualche tier sotto un nome diverso). Il tasso di rejection del 35-45% non è un bug; è il tradeoff precision-recall manifestato al boundary di admission, e il signal-to-noise dei tier viene preservato da esso.

L'istinto naive di "salvare tutto in caso sia utile dopo" è esattamente il pattern che produce il magazzino di spazzatura della terza settimana.

RISULTATI · §17 · FINDING CONTROINTUITIVO 6 · IL TIER SEMANTIC NON HA DEFAULT UTILI SENZA TOPIC TAG. Il tier semantic è il Chase & Simon chunked pattern store: ≤ 200 righe per file, ≤ 100 KB per file, un pattern per file, organizzato per retrieval per chunk recognition piuttosto che full-text scan. La modalità di retrieval chunk-recognition richiede un tag — senza tag, l'unico path di retrieval è similarità full-text contro il contenuto del chunk, che collassa il tier semantic in un baseline a forma di secchio.

Lo schema nudo `confidence: 0.5 · observations: 1` (i default che la migrazione legacy avrebbe prodotto se avesse settato default tutto) non produce nessun ordering di retrieval azionabile: ogni file sembra ugualmente credibile e ugualmente osservato. La migrazione S7 ha aggiunto tag `topic` (`style-tone`, `setting-call`, `prompt-injection-pattern`, `wrong-skill-invocation`, ...) più `confidence` inferito da segnali testuali di hedging più `observations` contate da score di grep-similarity, e ricostruito `_MANIFEST.md` come catalogo topic-indexed che l'hook di cold-start H1 può paginare selettivamente. Post-S7, il costo di cold-start è ~5 KB (`_MANIFEST.md` più top-5 pattern per recency × confidence) piuttosto che i 244 KB completi di tutti i 49 file, una −98% di riduzione di read per il tier semantic specificamente.

I tag sono il metadata più consequente architetturalmente nel tier — senza di essi il tier è un document store piatto con le stesse proprietà di retrieval del baseline a secchio unico.

RISULTATI · §18 · FINDING CONTROINTUITIVO 7 · ENVIRONMENT-DYNAMICS È IL TIER PIÙ NUOVO E PIÙ APPLICATION-SPECIFIC. Il tier environment-dynamics è stato aggiunto in iter-35 come adapter per il pattern Microsoft AI Frontiers ECHO (transizioni di stato del workspace come memoria first-class) ed è il tier che è cresciuto più velocemente in iter-39 perché cattura l'unico segnale non coperto dalla backbone Reflexion-Voyager-Sentra-ChaseSimon — le previsioni dell'agent sulle transizioni di stato del proprio environment, che è la precondizione per un comportamento del workspace proattivo (piuttosto che puramente reattivo). I quattro sub-bucket sono: `nour-response/` (come l'operatore risponde agli output dell'agent lungo assi che includono tono, lunghezza, frammentazione voice-to-text, time-of-day, prior-correction-density), `system-state/` (lo stato auto-descritto del sistema: quali cron stanno girando, quali hook stanno facendo firing, quali env var sono settate), `filesystem-response/` (come il filesystem risponde alle write dell'agent: quali path sono write-locked, quali directory crescono sotto le azioni dell'agent, quali pattern di file-naming vengono archiviati versus mantenuti), `skill-output-shape/` (la distribuzione delle output shape per skill invocation: latency, lunghezza, struttura, error rate), e `workspace-state-transitions/` (transizioni dello stato del workspace sotto le azioni dell'agent: iter-N → iter-N+1 con i delta codificati).

Al momento dell'audit `nour-response/` era popolato (6 file), `system-state/` era minimale (1 file) e gli altri tre sub-bucket erano a zero file. La popolazione S11 ha seedato ciascuno dalle osservazioni iter-39: filesystem-response con il pattern di path orphan `_v2-structure/`; skill-output-shape con la distribuzione di invocation power-law di tweet-writer; workspace-state-transitions con il rename macro-folder iter-37 e l'aggiunta dell'adapter ECHO iter-35. Il tier è il più application-specific dei cinque perché l'environment è unico al workspace — non c'è un tier environment-dynamics generico che porti tra deployment diversi — e cresce più velocemente perché cattura l'autoconoscenza del workspace stesso, che non ha altra casa nell'architettura.

L'implicazione a livello framework è che i framework agentic attuali (memory primitive di LangChain, vector store di LlamaIndex, moduli di memoria di CrewAI, astrazioni di memoria di AutoGen) shippano il pattern a secchio unico come default e richiedono agli utenti di reinventare la separazione tier da sé. Argomentiamo che questo sia un fallimento di framework-design: la partizione typed-tier è una decisione architetturale load-bearing che dovrebbe essere un default piuttosto che un costo di custom-implementation. La SPEC a cinque tier documentata qui è il riferimento aperto: file-system-backed, paper-grounded, con promotion path esplicite, un gate di admission A-MAC, e un template `_AUDIT-2026-05-23.md` che altri workspace possono eseguire sui propri sistemi di memoria per far emergere gli stessi failure mode che abbiamo fatto emergere sui nostri. Ci aspettiamo che le versioni future dei framework dominanti convergeranno sulla separazione tier — l'evidenza empirica è troppo forte perché il pattern a secchio sopravviva — ma la convergenza richiederà tempo, e nel frattempo i workspace che adottano il pattern a cinque tier per primi comporranno un vantaggio di apprendimento sui workspace che restano sul secchio.

(1) L'audit è single-workspace: tutti i numeri vengono dal workspace di riferimento Madani, e i failure mode che facciamo emergere potrebbero non generalizzare a workspace con profili di carico diversi (volume di operatore diverso, mix di task diverso, classe di modello diversa). Il precedente CoALA suggerisce che l'argomento strutturale generalizzi, ma i delta specifici di recall e precision sono workspace-specific. (2) Il confronto controllato a 40 task nel §9 è small-n per il delta di precision che riportiamo; il gain di precision +2,4× è statisticamente robusto a n = 40 ma il confidence interval è largo e una replica più grande è necessaria prima che la magnitudine possa essere citata come risultato generale. (3) Il remediation track è fix-track validated ma non ancora stable-state validated — lo stato post-S1-S12 è fresco alla chiusura dell'audit e non abbiamo ancora una misura long-horizon (>30 giorni) di se il loop cibernetico tiene sotto operating drift. (4) La partizione a cinque tier assume accesso al file-system dal runtime dell'agent; in environment sandboxed (funzioni serverless con filesystem read-only, agent browser-based), il pattern tier-as-folder ha bisogno di una materializzazione alternativa (es. tier-as-API-namespace con la stessa SPEC enforced al layer di API). (5) Lo scoring A-MAC è pesato manualmente al livello dei sei fattori; non abbiamo ancora imparato i pesi dei fattori da dati di outcome, e i pesi attuali sono uniform-plus-prior piuttosto che regression-derived.

L'architettura di memoria a cinque tier è l'implementazione load-bearing del WAB Pillar 03 (Memory), e il suo audit-and-remediation track iter-39 è la progressione canonical L3 → L4 per quel pillar. L0 (nessuna persistenza; ogni sessione vuota) è il default nei framework attuali. L1 (esiste un file di working memory) è il setup hobbyista tipico.

L2 (memoria strutturata con retrieval documentato) è l'implementazione concettuale a livello CoALA. L3 (primitive di memoria organization-wide con policy di compaction) è lo stato Madani pre-iter-39: la SPEC esiste, i tier esistono, ma il loop cibernetico è broken in punti. L4 (memoria cibernetica con compaction Reflexion e monitoring SNR-half-life) è lo stato post-S1-S12: ogni tier ha frontmatter canonical, il capability profile fa update post-task, il gate di admission filtra le write, l'overlay di audit distingue il prescrittivo dal descrittivo episodic e il tier environment-dynamics cattura l'autoconoscenza del workspace stesso.

Il documento di audit `_AUDIT-2026-05-23.md` è il template di riferimento; qualsiasi workspace può eseguire lo stesso audit sul proprio sistema di memoria e identificare le stesse sei classi di failure-mode (ingestione broken, episodic descrittivo-non-prescrittivo, capability profile congelato, violazioni di strictness di schema, admission control mancante, sub-bucket di ambient-context vuoti) e adottare lo stesso remediation track.

[1] Tulving E. (1972), Episodic and Semantic Memory, in Organization of Memory, Academic Press. [2] Chase W.G. & Simon H.A. (1973), Perception in Chess, Cognitive Psychology 4, 55-81 (la stima di 50.000-100.000 chunk). [3] Newell A. & Simon H.A. (1972), Human Problem Solving, Prentice-Hall. [4] Anderson J.R. (1996), ACT: A Simple Theory of Complex Cognition, American Psychologist 51, 355-365 (sistemi di produzioni procedural). [5] Cover T. & Thomas J. (2006), Elements of Information Theory, 2a ed., Wiley-Interscience (Data Processing Inequality, cap. 2). [6] Shinn N., Cassano F., Berman E., Gopinath A., Narasimhan K. & Yao S. (2023), Reflexion: Language Agents with Verbal Reinforcement Learning, NeurIPS 2023, arXiv:2303.11366. [7] Wang G., Xie Y., Jiang Y., Mandlekar A., Xiao C., Zhu Y., Fan L. & Anandkumar A. (2023), Voyager: An Open-Ended Embodied Agent with Large Language Models, arXiv:2305.16291. [8] Park J.S., O'Brien J.C., Cai C.J., Morris M.R., Liang P. & Bernstein M.S. (2023), Generative Agents: Interactive Simulacra of Human Behavior, arXiv:2304.03442. [9] Packer C., Wooders S., Lin K., Fang V., Patil S.G., Stoica I. & Gonzalez J.E. (2023), MemGPT: Towards LLMs as Operating Systems, arXiv:2310.08560. [10] Sumers T.R., Yao S., Narasimhan K. & Griffiths T.L. (2024), Cognitive Architectures for Language Agents (CoALA), TMLR, arXiv:2309.02427. [11] Wang C. & Shu Y. (2026), MetaCogAgent: Prospective Metacognition for Large Language Model Agents, arXiv:2605.17292. [12] Tran D. & Kiela D. (2026), Single-Agent LLMs Outperform Multi-Agent Systems on Multi-Hop Reasoning Under Equal Thinking Token Budgets, Stanford NLP, arXiv:2604.02460. [13] Cemri M. et al. (2025), Why Do Multi-Agent LLM Systems Fail? (MAST), NeurIPS 2025 Datasets and Benchmarks Track, arXiv:2503.13657. [14] ECHO Team (2026), ECHO: Workspace State Transitions as Ambient Agent Memory, Microsoft AI Frontiers, arXiv:2510.25863. [15] Mnemonic Sovereignty Authors (2026), Mnemonic Sovereignty: Nine Governance Primitives for Agent Memory, arXiv:2604.16548. [16] Anthropic (2025), Effective Harnesses: Prompt Caching, Stable Prefix Design, and Token Efficiency Patterns, Engineering Documentation. [17] Madani Lab (2026), Memory Engine 5-Tier Architecture · iter-39 Audit and Remediation Track · `_AUDIT-2026-05-23.md` (riferimento interno, rilascio MIT-licensed schedulato). [18] Madani Lab (2026), Skill Auto-Curator (Hermes + SkillOS Adaptation), Workspace Agentic Benchmark Series, riferimento WSB-17. [19] NousResearch (2026), hermes-agent: Open-Source Recursive Skill Iteration Pattern, GitHub. [20] Google Research (2026), SkillOS: A Skill Curation Operating System for Agentic Workspaces, Research Publication. [21] Honcho Authors (2024), Dialectic User Modeling for Conversational Agents, Open-Source Documentation. [22] Karpathy A. (2024), autoresearch: Self-Paced Autonomous Research Loops, Blog Post.