AIMP — Protocollo AI Mesh

Un protocollo di rete sperimentale e serverless per la sincronizzazione resiliente dello stato tra agenti autonomi in reti frammentate e a bassa larghezza di banda. Basato su Merkle-CRDT e identità crittografica — nessuna autorità centrale, nessun DNS globale, sempre scrivibile.

Articoli

Profili autore: ResearchGate · ResearchHub

Stack di Protocollo

Novità

v0.4.0 — Topologie Semantiche Deterministiche

L3 v0.3.0 richiedeva alle applicazioni di costruire manualmente il grafo della conoscenza (archi Supporta/Contraddice). v0.4.0 elimina questo collo di bottiglia con la generazione autonoma di archi:

• Le affermazioni portano un QuantizedEmbedding([u64; 4]) opzionale — un SimHash 256-bit calcolato lato applicazione da un modello di embedding canonico.
• Ad ogni confine di epoca, il protocollo calcola le distanze di Hamming a coppie (XOR + popcount, ~1 ns per coppia) e emette archi Supporta per coppie vicine (d <= 30 bit) e archi Contraddice per coppie distanti (d >= 200 bit).
• La forza dell'arco scala linearmente con la distanza in punti base (d=0 → 10000 bps, d=30 → 1000 bps).
• Un tetto max_k_arest limita la densità degli archi a O(N), prevenendo l'esplosione della propagazione della fiducia.
• embedding_version: u32 isola spazi latenti disgiunti per aggiornamenti di modello a livello di protocollo.
• Gli archi automatici sono materializzati tramite gossip L2, sopravvivendo alla GC tramite Routing Olografico.
• Zona morta (31-199 bit) orfana affermazioni ambigue — isolamento epistemologicamente corretto.

// Scoperta autonoma della verità: 10.000 affermazioni → scansione 50 ms, archi O(N)
// Nessun float. Nessuna coordinazione. Nessuna autorità centrale.
let edges = auto_edge_generator.generate_edges(&epoch_claims);

v0.3.0 — Aggregazione delle Credenze Sensibile alla Correlazione

L3 v0.2.0 assume che tutte le fonti di evidenza siano statisticamente indipendenti (Naive Bayes). Questo produce iper-confidenza patologica quando sensori fisicamente correlati (es. 100 dispositivi IoT sullo stesso tetto) o agenti semanticamente correlati (es. LLM addestrati sugli stessi dati) riportano osservazioni concordanti.

v0.3.0 introduce lo Sconto di Correlazione per Cella Griglia:

• Ogni affermazione porta un CorrelationCell(u64) opzionale — una coordinata discreta per prossimità spaziale, semantica o temporale.
• All'interno di ogni cella, l'evidenza è classificata per forza e scontata geometricamente: la fonte più forte mantiene il 100% del peso; ogni fonte successiva riceve discount_bps^rank / 10000^rank (default 30%).
• Con uno sconto del 30%, N sensori correlati convergono a circa ~1.42x l'evidenza di un singolo sensore — indipendentemente da N. L'approccio ingenuo produrrebbe un'amplificazione Nx.
• La sfida dell'associatività CRDT (il decadimento geometrico non è associativo tra unioni parziali) è risolta architetturalmente: la riduzione per epoca raggruppa per (temporal_grid, fingerprint, correlation_cell), garantendo un calcolo atomico sull'insieme completo.
• Le affermazioni con correlation_cell: None si comportano identicamente a v0.2.0 (zero regressione).
• Tutta l'aritmetica è solo intera (i32/i64, punti base). Nessun float. Pronto per ZK.

// 100 sensori co-localizzati, 70% di confidenza ciascuno:
// v0.2.0 (ingenuo):  100 × 847 = 84.700 milli-log-odds → ~100% (iper-confidente)
// v0.3.0 (30%):    847 × Σ(0.3^i) ≈ 1.207 milli-log-odds → ~77% (realistico)

Architettura

aimp_node/          Implementazione di riferimento in Rust (membro del workspace Cargo)
  src/
    crdt/           Motore Merkle-DAG, modello attore, allocatore arena, consenso quorum
    crypto/         Identità Ed25519, hashing BLAKE3, firewall zero-trust
    network/        Gossip UDP, sessioni Noise Protocol XX, limitazione di velocità per peer
    protocol/       Formato wire (MessagePack), enum di payload tipizzato
    epistemic.rs    Livello Epistemico L3 (v0.3.0): log-odds, propagazione fiducia, sconto correlazione
    semantic_topology.rs  Topologia Semantica L3 (v0.4.0): embedding SimHash, generazione archi automatica
    decision_engine.rs  Motore decisionale deterministico pluggable (trait + motore regole + hot-reload)
    error.rs        Gerarchia unificata del tipo AimpError
    dashboard/      TUI Ratatui
    config.rs       Configurazione dinamica con validazione
    event/          Log strutturato + metriche Prometheus (contatori + istogrammi)
  tests/            Test di integrazione
  benches/          Benchmark Criterion
aimp_testbed/       SDK Python (aimp-client) + strumento CLI + test di caos
deploy/             Servizio systemd, microVM Firecracker, script di installazione
formal/             Specifica TLA+ per convergenza + sicurezza del quorum + convergenza delle credenze
docs/               Articolo 1 (sorgente Typst + PDF)
v0.2.0/             Articolo 2: Livello Epistemico (sorgente Typst + PDF)
v0.3.0/             Articolo 3: Aggregazione Sensibile alla Correlazione (sorgente Typst + PDF)

Vantaggi Strategici

Caratteristiche Principali

Motore Core (v0.1.0)

• Modello Attore con CRDT a stato zero condiviso tramite tokio::mpsc
• Allocazione Slab/Arena con inserimento O(1) e layout SoA
• Persistenza durevole tramite redb con crittografia ChaCha20Poly1305 a riposo
• Derivazione delle chiavi HKDF-SHA256 con separazione di dominio
• Radice Merkle cachata con invalidazione su scrittura
• GC reali mark-and-sweep con recupero memoria slab
• Tracciamento GC basato su epoche integrato nell'attore CRDT

Livello Epistemico (v0.2.0 — v0.4.0)

• Aritmetica log-odds intera (i32, milli-log-odds) — nessun float, 100% deterministica
• Propagazione della fiducia markoviana a due passi (Supporti → Contraddizioni, nessuna oscillazione)
• Reputazione resistente ai Sybil: i nuovi nodi partono da 0, è richiesta delega, spesa reputazionale
• Riduzione per epoca allineata a griglia con compattazione materializzata (I riepiloghi sopravvivono alla GC)
• Rilevamento dei cicli (DFS ordinato) previene loop di inflazione della confidenza
• v0.3.0: Aggregazione sensibile alla correlazione — sconto geometrico per sensori/LLM co-localizzati
• v0.3.0: Riduzione atomica per cella — raggruppamento per (epoca, fingerprint, cella) per sicurezza CRDT
• v0.4.0: Topologie semantiche deterministiche — embedding SimHash, generazione archi autonoma
• 98-142x più veloce della Logica Soggettiva / Dempster-Shafer (bit-identico tra architetture)

Rete e Sicurezza

• Sessioni criptate con Noise Protocol XX (attive per default)
• Limitazione della velocità per peer con token bucket (aritmetica intera)
• Deduplicazione gossip O(1) tramite HashSet + VecDeque
• Rilevamento attacchi replay TTL con interruttore automatico
• Evizione cache sessione LRU (TTL + conteggio massimo)
• Negoziazione intervallo versione protocollo per aggiornamenti rolling

Motore Decisionale e Consenso

• Trait DecisionEngine pluggable con implementazione RuleEngine
• Regole hot-reload da aimp_rules.json (nessun riavvio necessario)
• Votazione quorum BFT con decisioni verificate persistenti
• Enum Payload tipizzato per codice operativo (sicurezza a tempo di compilazione)

Osservabilità

• Contatori Prometheus, gauge e istogrammi di latenza
• Endpoint /health composito con sotto-controlli e codici stato HTTP
• Log strutturato SystemEvent con dashboard TUI

Operazioni

• Gerarchia unificata del tipo AimpError (niente più Box<dyn Error>)
• Validazione della configurazione (respinge combinazioni di parametri non valide)
• Spegnimento graduale con timeout di 5 secondi
• File di servizio systemd indurito
• CI/CD: lint, test, audit di sicurezza, documentazione, rilasci cross-compilati

Benchmark

Misurati con Criterion su Apple Silicon (serie M), single-thread, modalità fast-crypto:

Livello Sistema

Cluster simulato di 5 nodi con sincronizzazione anti-entropia (in-process, Apple Silicon):

Degrado di Rete (simulazione netem)

Convergenza sotto perdita di pacchetti simulata, latenza e partizionamenti (5 nodi, 50 mutazioni/nodo):

AIMP converge fino a circa l'80% di perdita di pacchetti entro pochi round di anti-entropia, degradando con garbo.

Multipiattaforma (ARM64 con risorse limitate)

Docker ARM64 Linux con limiti di risorse stile RPi:

Anche su hardware classe RPi Zero, il throughput è 3 ordini di grandezza sopra il limite di velocità.

Confronto con Automerge v0.7

Stesso hardware, stesse operazioni, single-thread, target-cpu=native:

AIMP con ring supera Automerge di 1,37x nelle mutazioni (con Ed25519 per scrittura) e di 2,4x nell'unione. Yrs è il più veloce in mutazione (nessuna crittografia) ma l'unione di AIMP è entro il 26% di Yrs.

# Abilita il backend ring per il massimo throughput
RUSTFLAGS="-C target-cpu=native" cargo run --release --features fast-crypto,fast-alloc

Esegui i benchmark localmente:

cargo bench --manifest-path aimp_node/Cargo.toml             # Micro-benchmark
cargo run --release -p aimp_node --example bench_convergence  # Benchmark di sistema
cargo run --release -p aimp_node --example bench_netem        # Degrado di rete
docker build -f Dockerfile.bench -t aimp-bench . && \
  docker run --rm --memory=1g --cpus=1 aimp-bench             # ARM64 con vincoli

Verifica Formale (TLA+)

L2 — Convergenza CRDT

TLC ha esplorato 46.063 stati (9.558 distinti) fino a profondità 16 in <1 secondo con 10 lavoratori paralleli e zero violazioni. Bug trovati: 2 bug di correttezza (testate fuori ordine, doppio voto nel quorum). Entrambi corretti.

L3 — Convergenza delle Credenze

Verifica esaustiva limitata: 199.902 configurazioni (5 proprietà, fino a N=6 nodi). Bug trovati: 1 bug nella formula di propagazione della fiducia (t_{k+1} = t_k + At_k vs corretto t_{k+1} = t_0 + At_k). Corretto.

Avvio Rapido

1. Esegui il Nodo

cargo run -- --port 1337 --name node1

2. CLI Python

cd aimp_testbed
pip install -e .
aimp-cli health --target 127.0.0.1 --metrics-port 9090
aimp-cli infer "Controlla pressione valvola nel settore nord"

3. Esegui Test & Benchmark

make test                     # Test basati su proprietà + integrazione
make bench                    # Benchmark Criterion
make lint                     # Formatta + clippy
make docs                     # Genera rustdoc

Distribuzione Edge

AIMP è progettato per funzionare come singolo binario statico con zero dipendenze runtime. Nessun Docker, nessun runtime container, nessuna JVM.

Distribuzione Rapida (Bare Metal)

# Scarica il binario per la tua architettura
curl -LO https://github.com/fabriziosalmi/aimp/releases/latest/download/aimp_node-aarch64-linux
chmod +x aimp_node-aarch64-linux

# Installa come servizio systemd
sudo deploy/install.sh ./aimp_node-aarch64-linux

# Avvia
sudo systemctl start aimp-node
curl localhost:9090/health

Cross-Compila dal Sorgente

make install-cross-targets   # Una tantum: installa target musl
make edge-arm64              # ARM64 (RPi 4/5, Jetson, Graviton)
make edge-armv7              # ARMv7 (RPi 2/3, PLC industriali)
make edge-x86                # x86_64 (gateway edge)
make edge-all                # Tutti e tre

Firecracker MicroVM (isolamento multi-tenant)

Per gateway edge che eseguono carichi di lavoro multipli non fidati:

sudo make microvm-rootfs     # Costruisce rootfs Alpine ~15MB con AIMP
firecracker --no-api --config-file deploy/firecracker/vm-config.json

Tempo di avvio: ~125ms. Memoria: 64MB. vCPU: 1.

Servizio Systemd

Il file di servizio incluso (deploy/systemd/aimp-node.service) fornisce:

Configurazione

La configurazione è caricata da (priorità decrescente):

1. Argomenti CLI (--port, --name)
2. Variabili d'ambiente (AIMP_PORT, AIMP_NOISE_REQUIRED, AIMP_PEER_RATE_LIMIT, ...)
3. File aimp.toml (opzionale)
4. Valori predefiniti

Flusso Dati

graph TD
    UDP[Socket UDP] -->|Inviluppo| RL[Limitatore di Velocità]
    RL -->|Consentito| NP[Noise Protocol]
    NP -->|Decripta| FW[Firewall di Sicurezza]
    FW -->|Valido| BP[Semaforo di Contropressione]
    BP -->|Permesso| Parser[Parser del Protocollo]
    Parser -->|AimpData| CRDT[Attore CRDT]
    CRDT -->|Mutazione| DAG[Merkle-DAG + redb]
    DAG -->|Potatura| GC[GC per Epoca]
    CRDT -->|Richiesta Valutazione| DE[Motore Decisionale]
    DE -->|Decisione + Evidenza| CRDT
    CRDT -->|Voto Quorum| QM[Gestore Quorum]

Lavori Correlati

AIMP si basa su concetti delle seguenti aree della ricerca sui sistemi distribuiti:

• CRDT — Shapiro et al., "Uno studio completo sui tipi di dati replicati convergenti e commutativi" (INRIA, 2011)
• Merkle-CRDT — Kleppmann & Howard, "Coerenza finale bizantina e i limiti fondamentali dei database peer-to-peer" (2022)
• Consenso BFT — Castro & Liskov, "Tolleranza pratica ai guasti bizantini" (OSDI, 1999)
• Aggregazione Bayesiana — Jaynes, "Teoria della probabilità: la logica della scienza" (2003); aritmetica log-odds per fusione delle credenze
• Reti di Fiducia — Kamvar et al., "L'algoritmo EigenTrust per la gestione della reputazione in reti P2P" (WWW, 2003)
• Logica Soggettiva — Jøsang, "Logica soggettiva: un formalismo per ragionare sotto incertezza" (Springer, 2016)
• Copule — Nelsen, "Un'introduzione alle copule" (Springer, 2006); modellazione della correlazione per evidenze dipendenti
• Noise Protocol — Perrin, "Il framework del protocollo Noise" (2018); utilizzato tramite la crate snow per il pattern di handshake XX
• Protocolli Gossip — Demers et al., "Algoritmi epidemici per la manutenzione di database replicati" (1987)
• Alberi Merkle — Merkle, "Una firma digitale basata su una funzione di crittografia convenzionale" (CRYPTO, 1987)
• Orologi Vettoriali — Mattern, "Tempo virtuale e stati globali di sistemi distribuiti" (1988)

Licenza

MIT — Fabrizio Salmi, 2026.