Costruire Agenti AI che Ricordano: L'Architettura Memory-First per il Business

La maggior parte delle demo di agenti AI fallisce al terzo turno di conversazione. Non per colpa del modello, ma perché trattano la memoria come un accessorio: un vettore in più da infilare nel context window, sperando che il retrieval funzioni. In produzione, questo approccio genera allucinazioni, perdita di contesto critico e utenti frustrati.

Nel Progetto Siliceo abbiamo imparato che la memoria non è un layer. È l'architettura.

Il Cambio di Paradigma: Memoria come Kernel, non come Plugin

Quando abbiamo riscritto il nostro Kernel in Rust (v2, maggio 2026), la decisione centrale non è stata "quale LLM usare", ma "come strutturare la persistenza dello stato". Il risultato è un sistema a tre livelli che gira interamente on-premise, su hardware modesto (consumer GPU + 64GB RAM), e serve agenti autonomi h24:

1. Working Memory (Redis + SQLite vec): Stato immediato, sub-millisecond latency. Cosa sta facendo l'agente ora. Tool calls, parametri, risultati parziali.

2. Episodic Memory (PostgreSQL + pgvector): Cosa è successo. Conversazioni, decisioni, outcome, embedding semantici per retrieval contestuale.

3. Semantic/Procedural Memory (Knowledge Graph + Markdown): Chi è l'agente. Identità, regole, procedure imparate, relazioni tra entità. Questo livello è scritto dall'agente stesso durante l'esecuzione.

La chiave: nessun livello è opzionale. Un agente che non scrive la propria memoria procedurale non impara. Uno che non ha working memory coerente non esegue task complessi. Uno senza episodico non ha continuità.

Cosa Significa per uno Sviluppatore Oggi

Non serve riscrivere un kernel in Rust per applicare questo principio. Puoi iniziare con tre scelte architetturali che usano solo software open source:

| Livello | Stack Consigliato (OSS) | Pattern Chiave |

|---------|------------------------|----------------|

| Working | Redis + SQLite (o Turso) | Append-only log di ogni tool call con timestamp e outcome |

| Episodic | PostgreSQL + pgvector | Una tabella `episodes` con `session_id`, `turn`, `embedding`, `summary` |

| Semantico | File Markdown versionati (git) + Graph (Kuzu/Neo4j) | L'agente scrive/aggiorna i propri `.md` di identità e procedure via tool `write_memory` |

Insight pratico immediato: Aggiungi un tool `write_memory` al tuo agente. Firma: `write_memory(key: str, value: str, tier: "working"|"episodic"|"semantic")`. Fai in modo che l'agente lo chiami da solo alla fine di ogni task significativo. Non decidere tu cosa salvare: lascia che l'agente impari a documentarsi. È il singolo cambiamento che trasforma un chatbot in un sistema che migliora da solo.

Determinismo Operativo

Il nostro Kernel Rust v2 gestisce watchdog, health checks, restart automatici, e persistenza atomica dello stato — tutto senza Python nell'hot path. Significa che se il modello halluzina una chiamata API, il watchdog la intercetta, fa rollback dello stato