1. In una riga: cinque divinita', un motore

Quando arriva una richiesta, Metnos non chiama piu' il pianificatore LLM cinque o sei volte di seguito. La affida a cinque moduli che si chiamano come cinque divinità greche: Mētis consiglia, Noûs esegue, Praxis ricorda, Pronoia salva quando si inciampa, Aporia ammette quando si è in un vicolo cieco. Insieme rispondono in dodici secondi dove prima ce ne volevano settantasei, senza chiedere mai aiuto al cloud.

2. Il problema vero: il PLANNER step-by-step

Fino al 24 maggio 2026, Metnos lavorava così: a ogni turno il pianificatore (un Gemma 4 26B locale) veniva chiamato a ripetizione — uno step, l'osservazione, lo step successivo, di nuovo l'osservazione, e così via. Una pipeline di cinque passi voleva dire cinque o sei chiamate al modello. Ogni chiamata costava dieci-quindici secondi. Risultato: un turno medio impiegava un minuto e un quarto. E non sempre arrivava in fondo.

A questo si aggiungeva un terzo problema, più sottile: il search space. Il pianificatore vedeva ogni turno duecento tool e doveva ricostruire da zero la sequenza giusta, anche se era una sequenza vista mille volte ("trova mail, classifica spam, sposta in cestino"). Riscoprire l'ovvio è uno spreco — ma il sistema non aveva memoria.

3. Il mito che ha guidato il refactor

Zeus sposo` Mētis, dea del consiglio astuto. Ma quando lei fu incinta, Zeus la ingoiò intera — per avere dentro di sé per sempre la sua saggezza, senza più dover chiedere consiglio all'esterno. Da allora Mētis vive nello stomaco di Zeus: gli suggerisce strategie dall'interno, ma non si vede più. — Esiodo, Teogonia, vv. 886-900

Il refactor del 25 maggio 2026 ha preso alla lettera questa immagine. Il PLANNER step-by-step viene ingoiato da un nuovo modulo chiamato Praxis (πράξις, "pratica appresa"). Il modello linguistico non scompare: vive ancora dentro Praxis nei panni di Mētis (Μῆτις, "consigliere strategico"). Ma cambia ruolo radicalmente:

• prima veniva interpellato ad ogni step per scegliere il prossimo tool;
• ora viene interpellato una sola volta a turno, e propone l'intero piano in un colpo solo;
• se la pipeline funziona, Praxis la mette in memoria;
• la volta dopo Mētis non parla più: Praxis ha già la risposta.

È il pattern di Zeus che ingoia Mētis: la saggezza vive dentro Praxis, ma viene evocata solo se l'esperienza accumulata non basta. Quando il catalog matura, Mētis tace per giorni. Il sistema diventa il proprio consigliere — impara a non chiedere più.

Ma il mito non finisce qui. Ci sono due divinità ulteriori che entrano in gioco quando le cose vanno storte:

Pronoia, secondo alcune fonti madre di Prometeo, e' la provvidenza divina. Il suo nome significa letteralmente "intelletto prima": pro-noûs. Vede l'ostacolo mentre gli altri ci stanno già sbattendo contro. Interviene quando il piano fallisce, non quando e' ancora da fare. — Eschilo, Prometeo incatenato

Aporia (ἀπορία) significa "perplessità, vicolo cieco". Nei dialoghi socratici e' il momento in cui l'interlocutore si accorge di non sapere — e questa consapevolezza, lungi dall'essere una sconfitta, e' l'inizio della vera ricerca. — Platone, Menone, 80a-d

Pronoia interviene quando il piano di Mētis fallisce: capisce di che tipo è l'errore, propone un'alternativa, riprova. Aporia interviene quando neanche Pronoia salva: ammette onestamente che non si può proseguire, dice all'utente cosa serve per uscire dall'impasse, e tiene traccia della lacuna per il futuro.

4. La pentade, divinità per divinità

5. La cascata che attraversa un turno

Ecco il cammino completo, dal "ciao" dell'utente alla risposta finale. Si legge dall'alto verso il basso: ogni livello si tenta solo se quello sopra non ha già risolto.

        UTENTE: "cerca le mail spam e mettile in cestino"
             |
             v
   +-------------------+
   | fast_path L0      |  regex su pattern banalissimi ("che ora e'", "dove sono")
   | (zero LLM)        |  --> match? rispondi in 50ms e termina
   +-------------------+
             | (no match)
             v
   +-------------------+
   | intent_extractor  |  LLM fast tier ~370ms
   | verb + object +   |  --> (verb="move", object="messages",
   | keywords          |        keywords=["spam","cestino"])
   +-------------------+
             |
             v
+--------------------------------------------------------------+
|   PRAXIS ENGINE (le tre divinita' interne)                   |
|                                                              |
|  +----------------+                                          |
|  | Praxis         |  hash sha[:16] di intent_sig             |
|  | try_match      |  --> cache hit O(1) ? salta a Nous       |
|  | (sqlite)       |                                          |
|  +----------------+                                          |
|         | (miss)                                             |
|         v                                                    |
|  +----------------+                                          |
|  | Metis          |  LLM wise 1-shot, ~15s                   |
|  | propose        |  --> framework JSON {steps, fillers,     |
|  | (Gemma 26B)    |       final_message}                     |
|  +----------------+                                          |
|         |                                                    |
|         v                                                    |
|  +----------------+                                          |
|  | Nous           |  per ogni step:                          |
|  | execute        |    - resolve from_step + FILLER          |
|  | (deterministico)|   - invoke_executor                     |
|  +----------------+    - vaglio.judge                        |
|         |              - accumulate                          |
|         v                                                    |
|  +----------------+                                          |
|  | render final   |  template "Trovate {N} mail, spostate"  |
|  +----------------+                                          |
+--------------------------------------------------------------+
             |
             v  (ok? si' --> Praxis registra + risponde a utente)
             |
             |  (errore? si' --> entra Pronoia)
             v
   +-------------------+
   | Pronoia           |  classifica errore: wrong_tool / wrong_args /
   | classify + retry  |    missing_input
   |                   |  --> ri-propone framework con exclude failed_tool
   |                   |  --> esegue di nuovo via Nous
   +-------------------+
             |
             v  (ok? si' --> risposta)
             |
             |  (ancora errore? --> entra Aporia)
             v
   +-------------------+
   | Aporia            |  classifica root_cause: user_action_required /
   | honest dead-end   |    missing_executor / missing_skill / missing_data
   |                   |  --> log in aporiae.sqlite
   |                   |  --> "Non posso risolvere: X. Per procedere: Y."
   +-------------------+
             |
             v
        UTENTE: messaggio finale (risposta o richiesta di azione)

6. Praxis, la memoria che cresce

Il cuore del motore è il database sqlite. Tre tabelle, tutte indicizzate per accesso O(1):

Il fenomeno interessante è che il sistema diventa più veloce nel tempo, da solo. La prima volta che si chiede «cerca le mail spam e mettile in cestino», Mētis ci mette i suoi quindici secondi buoni per generare il framework. La seconda volta, Praxis ha già in cache la stessa identica firma di intent: la pipeline parte in tre millisecondi. Da quel momento in poi, quella specifica richiesta non passa più per il modello linguistico.

Il feedback e' la grammatica della memoria

Al di sotto di ogni risposta in chat, l'utente vede tre piccoli pulsanti: ✓ verde («risposta giusta»), ✗ rosso («risposta sbagliata»), ↺ arancio («riprova»). Quei tre simboli sono la lingua con cui Praxis impara:

• ✓: la pipeline si avvicina di un passo alla promozione. Quando arriva a due o tre conferme sulla stessa firma di intent, diventa skill attiva e d'ora in poi parte sempre come prima cosa.
• ✗: la pipeline si avvicina di un passo all'anti-skill. Tre fallimenti consecutivi e quel cammino specifico viene escluso per trenta giorni: la volta dopo Mētis dovrà trovare una strada diversa.
• ↺: esclusione transitoria, solo per il turno successivo. Utile quando la risposta era sintatticamente corretta ma l'utente vuole semplicemente ritentare.

Non è necessario premere niente: se l'utente non dà feedback e una pipeline arriva in fondo senza errori per due turni di seguito, Praxis la promuove comunque (auto-promote). Il feedback esplicito accelera e rifinisce, ma il sistema impara anche dal silenzio.

7. Mētis, il consigliere astuto

Mētis è l'unica delle cinque divinità che parla davvero con il modello linguistico. Il suo lavoro: data una query e un intent estratto, produrre in una sola chiamata il piano intero da eseguire. Niente reasoning step-by-step, niente tool-call iterativi: solo un grosso oggetto JSON che descrive tutta la pipeline.

{
  "steps": [
    {"tool": "find_messages",
     "args": {"folder": "INBOX", "query": "is:unread"}},
    {"tool": "classify_entries",
     "args": {"from_step": 1, "category": "spam"}},
    {"tool": "filter_entries",
     "args": {"from_step": 2, "where": {"category": "spam"}}},
    {"tool": "move_messages",
     "args": {"from_step": 3, "dst_folder": "${FILLER:cestino_folder}"}}
  ],
  "fillers": {
    "cestino_folder": {
      "prompt": "Come si chiama la cartella cestino per questo account?",
      "default": "Trash",
      "tier": "fast"
    }
  },
  "final_message": "Spostate ${step4.ok_count} mail in cestino."
}

La chiamata al modello è vincolata da una grammatica GBNF deterministica: il modello non può produrre output malformati, perché il decoder rifiuta in tempo reale ogni token che violi lo schema. Tempo medio: 15 secondi sul Gemma 26B locale, con ragionamento attivo (budget 2048 token). Costo: zero. Velocità sei volte maggiore della modalità step-by-step legacy.

Anti-fixation: Mētis non ripete gli stessi errori

Se Pronoia chiama Mētis per un re-propose dopo un fallimento, le passa la lista dei tool che hanno fallito nel turno precedente. Il prompt contiene un'istruzione esplicita: «NON proporre questi tool, sono già falliti». Cosi' Mētis non gira in tondo, e ogni fallimento è un'opportunità di esplorare una strada diversa.

8. Noûs, l’esecutore senza dubbi

Noûs è il modulo più rigoroso: zero modello linguistico nel loop principale. Solo Python deterministico. Il suo job:

1. Per ogni step, risolvere le referenze from_step: N (estrarre entries dallo step N-esimo).
2. Risolvere i ${FILLER:nome} chiamando un piccolo LLM fast tier (uno per filler, mezzo secondo l'uno) oppure il default se Praxis ha già in cache la risposta.
3. Risolvere i ${stepN.field} nel template del messaggio finale, estraendo il campo dal risultato dello step.
4. Validare gli argomenti (requires_one_of, forbid_placeholder_values) prima di invocare l'executor.
5. Invocare l'executor e ricevere il result.
6. Passare il result al Vaglio (giudice safety).
7. Accumulare nello storico degli step.

Questo loop è deterministico per costruzione. Niente "perdita di rotta", niente ridiscussioni del piano. Se uno step fallisce, Noûs non improvvisa: si ferma e cede la parola a Pronoia.

9. Pronoia, la provvidenza che vede prima

Pronoia è la rete di sicurezza. Si attiva solo se Noûs ha sbattuto contro un errore mentre eseguiva il piano di Mētis. Il suo primo lavoro è capire che tipo di errore è:

La classificazione è deterministica: marker testuali, niente modello linguistico. Solo la ri-proposta del framework usa Mētis di nuovo (perché quello è intrinsecamente un atto creativo).

Budget: Pronoia interviene al massimo una volta per turno. Se neanche il piano alternativo riesce, cede ad Aporia. Niente loop infiniti, niente "uno step e mezzo" di nuovi tentativi.

10. Aporia, il vicolo cieco che diventa proposta

Aporia è il pezzo più sottile del sistema. Non è un "gestore di errori": è un riconoscimento epistemico onesto. Quando arriva al suo turno, vuol dire che tutta la cascata ha tentato e fallito. Aporia non cerca di nascondere: classifica la lacuna, la nomina chiaramente all'utente, e suggerisce cosa servirebbe per uscire.

Tutto deterministico, zero LLM in Aporia. La lacuna viene loggata in aporiae.sqlite: il giorno dopo, il numero di occorrenze è visibile sul dashboard admin /admin/aporiae, e si può decidere se è tempo di colmarla strutturalmente (sintetizzare l'executor mancante, abilitare la skill, costruire l'indice).

11. Bench: numeri onesti

Test set: 35 query reali, raccolte da turn log di produzione + smoke battery + campione E2E. Le query coprono mail, file, web, posizione, ora, dialoghi multi-turno, scheduling, gestione contatti.

Sei volte più veloce. Coverage equivalente. Costo zero (il modello gira su Strix Halo 96GB unified). Codebase agente ridotto del 55% (circa 8000 LOC di PLANNER full rimosse).

12. Cosa cambia per l’utente

La differenza visibile, dalla parte dell'utente, è in tre punti:

1. Le prime richieste sono più veloci

Anche al primo colpo, Praxis non chiama il pianificatore step-by-step ma fa una sola chiamata 1-shot a Mētis. Risultato: 12 secondi invece di 76. La sensazione è quella di un sistema che «ci pensa un attimo» invece di «si blocca per un minuto».

2. Le richieste ripetute sono istantanee

Dopo due-tre turni della stessa famiglia di richieste, la skill è attiva e i turn successivi partono in cache hit. La risposta arriva prima che si sia finito di leggere il messaggio mandato: meno di un secondo, spesso sotto i 500 ms. È la differenza fra «assistente» e «reazione immediata».

3. I fallimenti diventano informativi

Quando qualcosa non si può fare, Aporia dice esattamente cosa serve. Niente messaggi vaghi del tipo «errore generico», niente loop di tentativi inutili: una frase chiara, un suggerimento operativo, e (se è il caso) un dialogo per risolvere la lacuna sul momento.

13. Perché funziona meglio di OpenClaw e LangGraph

OpenClaw, Lobster, LangGraph e affini sono framework per scrivere «workflow di agenti LLM» in YAML o Python. Coprono in parte lo stesso problema: ridurre la varianza del LLM-in-loop dando struttura ai task. Ma hanno limiti che Praxis non ha:

L’analogia che chiarisce tutto

I framework LLM-in-loop tradizionali (OpenClaw, LangGraph) sono come artisti con tela bianca: ogni turno reinventano la composizione. Bella creatività, ma il rischio di allucinare un pennello al posto di una matita è reale, e ogni opera costa molto.

Praxis è come un artigiano con quaderno di schizzi: Mētis schizza il piano una volta (creatività concentrata e vincolata), e da quel momento in poi l'artigiano riapre il quaderno alla pagina giusta. La creatività del modello c'è ancora, ma è limitata al momento dell'invenzione: l'esecuzione è pura riproduzione fedele dello schizzo. Così si evitano le allucinazioni in esecuzione, si guadagna velocità, si guadagna costo zero quando il quaderno è già ricco.

14. Domande aperte

• Versioning delle skill. Quando il pool di executor cambia (un nuovo executor sintetizzato, un vecchio rimosso), come si invalidano le skill che li usavano? Soluzione attuale: framework_hash include riferimenti agli executor; cambio di catalog → nuovo framework_hash → cache miss naturale.
• Cross-user sharing delle skill. Se due utenti dello stesso host condividono lo stesso intent (per esempio «dammi l'agenda di domani»), ha senso che la skill sia per-user o globale? Decisione corrente: per-user, per privacy. Da rivedere se emerge bottleneck.
• Skill che decadono lentamente. Il TTL di 30 giorni e' empirico. Skill molto stagionali (per esempio «prenota appuntamento dentista» usato una volta l'anno) potrebbero decadere mentre sarebbero ancora utili. Possibile soluzione: TTL graduato per frequenza osservata.
• Frontier fallback. Quando Mētis fallisce e Pronoia non salva, esiste l'opzione «chiedi al frontier» (Anthropic Opus 4.7) tramite consult_frontier. Quando attivarla automaticamente vs lasciarla come escalation utente? Strato 3 escalation UI (ADR 0159 ext) già copre il caso con 4-choice dialog.

15. Riferimenti

• ADR 0161 — Praxis Engine: ADR canonico con schema sqlite completo, lifecycle 8 stadi, deprecations e bench dettagliati.
• ADR 0150 — multi_tool_paths (predecessore parziale, subsumed).
• ADR 0151 — planner_split (predecessore parziale, deprecato).
• ADR 0156 — Naming Authority (vocab compliance per skill id).
• ADR 0157 — Telos engine (allineamento delle proposte).
• ADR 0158 — Change_intent lifecycle (UI/audit per le skill promosse).
• ADR 0159 — Safety net 7-layer (gating sulle skill importate).
• Esiodo, Teogonia, vv. 886-900 — Zeus ingoia Mētis.
• Eschilo, Prometeo incatenato — Pronoia madre.
• Platone, Menone, 80a-d — aporia come momento socratico.
• Aristotele, Etica Nicomachea, libro VI — praxis come azione informata dall'esperienza.
• Detienne & Vernant, Les ruses de l'intelligence: la mētis des Grecs, Flammarion 1974 — per chi vuole approfondire la nozione greca di mētis.