Che cos'è un modello di decisione?

Per tre anni, l'industria dell'IA ha trattato ogni problema di calcolo come un problema di generazione di testo.

Quando un agente autonomo deve scegliere uno strumento, verificare una transazione finanziaria, smistare una vulnerabilità di sicurezza, regolare un attuatore robotico o stabilire se un'azione richiede l'approvazione di una persona, lo standard di settore è stato interrogare un modello linguistico da 70 miliardi di parametri e attendere che generi un flusso aperto di token. Gli sviluppatori mettono poi in campo motivi regex fragili, parser JSON speculativi e cicli di nuovo tentativo per estrarre dalla risposta una sola parola o un booleano.

Quell'approccio non è solo uno spreco di calcolo: spende centinaia di passi di decodifica autoregressiva in serie per ottenere un'uscita che starebbe in due bit. È, alla radice, un disallineamento di architettura.

I modelli linguistici generativi sono stati addestrati per massimizzare la verosimiglianza del token successivo su una distribuzione testuale infinita. Sono discorsivi, conversazionali e, per struttura, inclini ad allucinare quando c'è incertezza. Ma il 95% del flusso di controllo nei sistemi software non ha bisogno di un saggio.

Ha bisogno di una decisione.

---

I modelli linguistici ragionano. I modelli di decisione decidono.

Per capire la differenza, guarda le funzioni obiettivo sottostanti.

Un grande modello linguistico (LLM) ottimizza la verosimiglianza autoregressiva dei token su una sequenza aperta:

Loss_LLM = - Σ log P(w_t | w_<t)

Genera una sequenza di token w_1, w_2, ..., w_n campionata da un vocabolario senza vincoli di oltre 100,000 possibilità. Il modello non può dichiarare che gli manca l'evidenza per rispondere senza generare frasi in linguaggio naturale che imitano la modestia; non può emettere una distribuzione di probabilità nativa su uno spazio di stati operativo; e i numeri di confidenza che dichiara da sé sono notoriamente poco calibrati.

Un modello di decisione ottimizza un obiettivo del tutto diverso. Dato uno stato di evidenza esplicito E e uno spazio di decisione strutturato D, un modello di decisione calcola una proiezione diretta verso un'uscita delimitata e tipizzata y:

y_hat = argmax_y P(y | E, D)

Dotato di una distribuzione a posteriori strettamente calibrata P(y | E) e di una primitiva operativa di prima classe per l'astensione motivata (DEFER).

Dimensione architetturale	Modelli linguistici generativi (LLM)	Modelli di decisione (ad es. Hanzo Kai)
Obiettivo primario	Sintesi e generazione di testo aperto	Transizioni di stato discrete e verificabili
Spazio di uscita	Sequenze di token senza vincoli (vocabolario di 100k+)	Schemi delimitati e rigorosamente tipizzati (Choice, Score, Predicate, Defer)
Confidenza e calibrazione	Non calibrata; softmax confabulata sui token	Probabilità calibrate in modo empirico (P = 0.90 implica un'accuratezza del 90%)
Rappresentazione dello stato	Finestra di contesto effimera, fatta di stringhe di token	Piano di evidenza multimodale strutturato, con provenienza crittografica
Topologia di esecuzione	Decodifica autoregressiva in serie (latenza O(N))	Risoluzione di grafi in parallelo e diffusione delle decisioni (passo in avanti O(1))
Gestione dell'incertezza	Allucina completamenti plausibili	Astensione motivata (DEFER verso una politica o un revisore umano)
Verificabilità	Spiegazioni verbali non deterministiche	Pacchetti di decisione immutabili e rieseguibili, con prove di hash crittografico

Quando separi il ragionamento dalla decisione, l'architettura del sistema diventa più semplice, più veloce e più affidabile, di ordini di grandezza.

---

I cinque pilastri architetturali di un modello di decisione

Un vero modello di decisione non è un LLM a cui si chiede «Rispondi con JSON valido». È un'architettura neurale dedicata, progettata da zero per una valutazione delimitata. Il modello di decisione a pesi aperti di Hanzo, Kai 1, poggia su cinque pilastri architetturali:

1. Uscite delimitate e tipizzate (zero analisi di stringhe)

Nel software di produzione, ogni interfaccia tra sistemi deve essere rigorosamente tipizzata. Chiedere a un modello linguistico di produrre una decisione e sperare che rispetti uno schema regex introduce un rischio di coda catastrofico.

I modelli di decisione eliminano del tutto l'analisi del testo. Ogni uscita è tipizzata in modo nativo in una di quattro primitive:

• Choice<T>: una selezione da un insieme esplicito ed enumerato di candidati, accompagnata dalla distribuzione di probabilità completa su tutte le alternative (p_1, p_2, ..., p_k, dove Σ p_i = 1.0).
• Score[min, max]: una valutazione quantitativa delimitata entro limiti operativi fissi, completa di intervalli di confidenza.
• Predicate: una verifica booleana pura (true o false) con certezza calibrata.
• Defer: un rifiuto esplicito di indovinare quando l'evidenza è insufficiente o in conflitto, e l'esecuzione passa a una politica di riserva già definita o a una persona nel ciclo.

Poiché lo strato di uscita è vincolato allo schema valido a livello dei logit, un modello di decisione non può fisicamente produrre un risultato fuori dai limiti, un valore di enumerazione illegale o un payload malformato.

// Calling Hanzo Kai 1 via the unified SDK:
const decision = await kai.decide({
  question: "deploy_canary_to_production",
  schema: {
    type: "choice",
    options: ["promote", "rollback", "quarantine", "defer_to_sre"],
  },
  evidence: [
    { type: "p99_latency_ms", value: 142, threshold: 150 },
    { type: "error_rate_delta", value: "+0.002%", threshold: "+0.01%" },
    { type: "canary_health_score", value: 0.98 },
  ],
});

// The result is directly typed, validated, and calibrated:
console.log(decision.result);      // "promote"
console.log(decision.probability); // 0.964
console.log(decision.entropy);     // 0.12 (low uncertainty)

---

2. Il piano di evidenza multimodale unificato

Nel mondo reale le decisioni dipendono di rado dal solo testo. Nei domini critici — finanza sovrana, manipolazione robotica, triage medico automatizzato e telemetria industriale — bisogna valutare segnali eterogenei nello stesso momento.

Un modello di decisione non serializza dati tabulari, flussi di sensori e schiere radar in tabelle Markdown goffe perché un LLM le legga. Kai, invece, usa encoder di modalità specializzati:

• Telemetria e serie temporali: finestre mobili vettorializzate e tratti del dominio di frequenza.
• Visivo e termico: token visivi densi provenienti da backbone di visione.
• Stato strutturato: proiezioni di entità a grafo e relazionali, dal Hanzo Datastore.
• Codice e specifiche: embedding semantici a livello di AST e matrici di requisiti formali.

Tutte le modalità si proiettano in un piano di evidenza unificato. Soprattutto, l'evidenza conserva la provenienza crittografica: ogni tensore di ingresso viene sottoposto a hash e riceve un'impronta. Se una decisione viene verificata sei mesi dopo, lo stato esatto dell'ingresso si può ricostruire bit per bit.

---

3. Risoluzione di grafi in parallelo e diffusione delle decisioni

Il collo di bottiglia più grande degli agenti autonomi moderni è l'esecuzione in serie. Un ciclo di agente che richiede 50 decisioni intermedie chiama di solito un LLM 50 volte di seguito. A 500ms fino a 2s per completamento, l'agente passa minuti soltanto ad attraversare il proprio flusso di controllo.

Inoltre, la propagazione degli errori nelle catene seriali di LLM è catastrofica. Se ogni passo ha un tasso di successo del 95%, una catena di 20 passi riesce soltanto in:

0.95 ^ 20 ≈ 35.8%

I modelli di decisione risolvono questo tramite la diffusione delle decisioni su grafi aciclici orientati (DAG).

Invece di valutare le decisioni in serie, l'intero programma di decisione viene inviato in una volta. In un solo passo in avanti:

1. Passaggio 1 (convergenza immediata): l'80–90% dei nodi con evidenza non ambigua si risolve subito, con alta confidenza (P > 0.99).
2. Passaggio 2 (diffusione condizionale): i nodi dipendenti ricevono gli stati già bloccati dei genitori e raffinano le proprie distribuzioni di probabilità.
3. Passaggio 3 (soddisfacimento dei vincoli): i nodi che restano ad alta entropia, o in conflitto, vengono valutati rispetto a vincoli di frontiera formali.

Un flusso complesso, con 100 decisioni operative interdipendenti, si risolve in millisecondi, non in minuti.

---

4. Calibrazione rigorosa e astensione motivata

Se un modello di IA ti dice di essere sicuro al 99%, quanto spesso ha davvero ragione?

Nei modelli generativi da scaffale, la confidenza che dichiarano da sé è notoriamente poco correlata con la verità. Soffrono di una grave sovraconfidenza sugli ingressi fuori distribuzione e allucinano volentieri giustificazioni convincenti di uscite errate.

Nelle applicazioni industriali, aerospaziali e finanziarie, una risposta sbagliata e troppo sicura è fatale. Un modello di decisione deve essere calibrato in modo empirico:

E[ Indicator(y_pred == y_true) | P(y_pred) = p ] = p

Quando Kai emette una probabilità di 0.85, quella decisione è empiricamente corretta esattamente l'85% delle volte.

       Uncalibrated LLM (Overconfident)            Calibrated Decision Model (Kai)
  1.0 |                    /                 1.0 |                     /
      |                   /                      |                   /
A 0.8 |             _____/                 A 0.8 |                 /
C     |            /                       C     |               /
C 0.6 |           /                        C 0.6 |             /
      |          /                         |          /
  0.4 |    _____/                          0.4 |        /
      |   /                                      |      /
  0.2 |  /                                   0.2 |    /
      | /                                        |  /
  0.0 +----------------------                0.0 +----------------------
      0.0  0.2  0.4  0.6  0.8  1.0               0.0  0.2  0.4  0.6  0.8  1.0
             CONFIDENCE                                 CONFIDENCE

Quando l'entropia supera una tolleranza al rischio parametrizzata τ, il modello non indovina. Invoca l'astensione motivata:

Entropy(P(y | E)) = - Σ p_i * log(p_i) > τ  ==>  DEFER

Il sistema restituisce l'esecuzione a specialisti umani o a regolamenti deterministici, e fornisce un gradiente di sensibilità esplicito che indica quale pezzo di evidenza mancante ridurrebbe di più l'entropia.

---

5. Pacchetti di decisione rieseguibili (la traccia di audit)

Negli ambienti aziendali regolati, «l'IA ha generato questo testo» non è una difesa legale valida né una postura di conformità.

Ogni decisione valutata da Kai produce un pacchetto di decisione immutabile e sigillato crittograficamente:

{
  "decision_id": "dec_8f0a2c91b4",
  "program_version": "fraud_triage_v2.4",
  "timestamp": "2026-09-30T19:00:00Z",
  "model": {
    "name": "kai-1-core",
    "weights_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855"
  },
  "evidence_fingerprints": {
    "transaction_context": "sha256:7c9e...",
    "biometric_telemetry": "sha256:4a1d...",
    "historical_risk_profile": "sha256:9f8b..."
  },
  "posterior_distribution": {
    "approve": 0.012,
    "step_up_mfa": 0.976,
    "terminate_session": 0.009,
    "defer_to_fraud_desk": 0.003
  },
  "selected_action": "step_up_mfa",
  "entropy": 0.098,
  "signature": "ed25519:3b7a8f..."
}

Se un auditor o un ingegnere di risposta agli incidenti consulta una transazione anni dopo, può rieseguire il pacchetto di decisione contro la revisione esatta del modello e verificare che l'uscita fosse matematicamente deterministica, a prova di manomissione e conforme alla politica.

---

Dove stanno i modelli di decisione nel tuo stack

I modelli di decisione non sostituiscono i modelli generativi. Liberano i modelli generativi dai lavori per cui non sono mai stati progettati.

Nelle architetture aziendali moderne, i sistemi rendono quando i compiti sono separati in modo netto tra generazione e controllo:

                          ┌──────────────────────────┐
                          │   Incoming Workload      │
                          └─────────────┬────────────┘
                                        │
                                        ▼
                          ┌──────────────────────────┐
                          │       Enso Router        │
                          │  (Task Intent & Triage)  │
                          └──────┬────────────┬──────┘
                                 │            │
             Generative Tasks    │            │   Control & Decision Tasks
       (Code, Research, Content) │            │   (Routing, Approvals, Safety)
                                 ▼            ▼
                     ┌───────────────┐    ┌───────────────┐
                     │  Zen Models   │    │  Kai Models   │
                     │ (LLM / Reason)│    │ (Decision Mod)│
                     └───────────────┘    └───────┬───────┘
                                                  │
                                                  ▼
                                          ┌───────────────┐
                                          │Typed Decision │
                                          │    Package    │
                                          └───────────────┘

• Zen: i modelli generativi di frontiera di Hanzo, fatti per ragionare. Usa Zen quando ti serve ricerca testuale profonda, prove a catena di pensiero in più passi, sintesi creativa e stesura di documenti.
• Kai: la famiglia di modelli di decisione a pesi aperti di Hanzo. Usa Kai quando ti servono instradamento deterministico, selezione degli strumenti, soglie di sicurezza, esecuzione di operazioni, triage e controllo del ciclo dell'agente.
• Enso: il meta-router ad alto throughput che ispeziona i compiti in arrivo allo strato del microsecondo, indirizza i compiti generativi a Zen e quelli di decisione a Kai.

---

Pesi aperti. Infrastruttura sovrana.

Un'infrastruttura di decisione affidabile non può restare chiusa in un'API di terzi che cambia comportamento senza preavviso. Quando un modello governa deploy di produzione, sistemi fisici o rischio finanziario, devi avere piena sovranità sui suoi pesi, sul suo runtime e sulla privacy dei dati.

Kai 1 ha i pesi aperti. Puoi eseguirlo:

1. Sul cloud sovrano di Hanzo: scalato a livello globale, con garanzie di egress nullo e latenze sotto il millisecondo.
2. Nella tua VPC o on-premises: distribuibile con Docker o Kubernetes, su GPU NVIDIA, AMD ROCm o nodi CPU ad alta densità.
3. Al bordo: del tutto disconnesso, per robotica, aerospazio e ambienti di difesa sovrana.

Smetti di chiedere ai modelli linguistici di scrivere saggi quando il tuo software ha solo bisogno di una decisione.

Benvenuto nell'era dell'intelligenza di decisione.

---