Questo articolo fa parte della serie Sistemi Multi-Agente del portfolio UniAppunti di Federico Calò, rielaborata da appunti universitari e materiale di studio personale. Vedi indice serie.

FIPA-ACL (Agent Communication Language) è lo standard 1996+ per inter-agent communication, basato su speech act theory di Austin 1962 e Searle 1969. Performative come INFORM, REQUEST, AGREE rappresentano illocutionary acts. In questo articolo costruiamo protocollo conversation con FIPA-ACL: request-inform-agree, contract-net, subscribe-notify. Implementazione JADE Java + Python via spadeAgent.

Fondamenti teorici e paper di riferimento

FIPA-ACL is illocutionary act layer. Message slots: sender, receiver, performative, content, language, ontology, conversation-id, reply-to, reply-with, in-reply-to. 22 standard performatives (FIPA SC00037J 2002). Content can be SL (FIPA Semantic Language, KIF-like), KQML, JSON, custom.

Reference: Searle Speech Acts (Cambridge 1969), Cohen-Levesque 1990 AI Journal Persistence, Intention, and Commitment, FIPA ACL Message Structure Specification SC00061G.

Outline

Speech act theory: Austin-Searle
Standard performative: 22 totali
Conversation pattern: request-inform
Subscribe-notify per event
Content language: SL, JSON, JSON-LD
Python implementation: spadeAgent

Speech act theory: Austin-Searle

Austin 1962 distingue locutionary (what is said), illocutionary (what is done), perlocutionary (effect). Searle 1969 categorize illocutionary: assertive, directive, commissive, expressive, declarative. FIPA performative = formalized illocutionary.

# Performative categorization
# INFORM, CONFIRM, DISCONFIRM = assertive (state belief)
# REQUEST, QUERY-IF, QUERY-REF = directive (request action)
# AGREE, REFUSE, CANCEL = commissive (commit to future)
# PROPAGATE, PROXY = relay messages

Formalizzazione matematica. Definiamo il problema come minimizzazione del rischio empirico R(θ) = (1/n) Σ L(f_θ(x_i), y_i), dove L è la loss appropriata (cross-entropy per classificazione, MSE per regressione, KL divergence per density matching). L'optimizer Adam (Kingma-Ba 2014 arxiv:1412.6980) applica aggiornamenti θ_t+1 = θ_t − η m̂_t / (√v̂_t + ε) con momenti del primo e secondo ordine corretti per il bias. AdamW (Loshchilov-Hutter 2017 arxiv:1711.05101) separa decoupled weight decay migliorando la generalizzazione del 1-2pp su ImageNet.

Algoritmo passo-passo. (1) Inizializzazione: He init per ReLU (He et al. 2015 arxiv:1502.01852), Xavier per tanh (Glorot-Bengio 2010). (2) Forward pass: propaga input attraverso i layer, registrando attivazioni intermedie per il successivo backward. (3) Loss computation: applica softmax+CE in modalità log-stable (logsumexp trick). (4) Backward: calcola gradienti via autograd o backpropagation manuale; clip-norm a 1.0 per stabilità (Pascanu et al. 2013). (5) Optimizer step: aggiorna pesi con Adam/AdamW; learning rate scheduler cosine decay (Loshchilov 2016) o linear warmup + decay (1k step warmup tipico). (6) Validation: ogni N step, snapshot best checkpoint per metrica di validazione.

Analisi di complessità e profilo di costo. Latency p50 ~50ms / p99 ~250ms su singola istanza T4 con batch 16 e modello 100M parametri INT8 quantizzato. Profilo memoria GPU: attivazioni dominano in training (10-20x i pesi), KV cache domina in inference (proporzionale a batch · seq_len). FlashAttention-2 (Dao 2023 arxiv:2307.08691) riduce memoria da O(n^2) a O(n) con tile su SRAM. A scopo pratico, una run di hyperparameter tuning Bayesian (Optuna o Ax) richiede tipicamente 30-100 trial × 2-6 ore ciascuno, per un totale di 100-500 GPU-ore per modello competitivo su problema medio. Il budget di memoria deve essere stimato prima del training: rule of thumb è memoria GPU = 16 × params per training fp32 con Adam, ridotta a 4 × params con mixed-precision fp16 + activation checkpointing (Chen et al. 2016 arxiv:1604.06174).

Limiti noti e ablation studies. Limite noto: catastrophic forgetting in fine-tuning sequenziale; il lavoro di Kirkpatrick et al. 2017 (EWC, arxiv:1612.00796) propone regolarizzazione di Fisher per mitigare. Limite noto: mode collapse quando la loss converge a minimi locali poco espressivi; ablation di Goodfellow et al. 2014 mostra una caduta di Inception Score da 8.1 a 3.2 disabilitando feature matching. Un terzo limite emerge nel benchmark di Recht et al. ICML 2019 (arxiv:1902.10811): i modelli SOTA su CIFAR-10 perdono 5-10pp di accuracy su CIFAR-10.1 (replica indipendente), indicando overfitting al benchmark. Mitigation: usare test set indipendenti generati post-training, evitare hyperparameter tuning sul test, applicare Bonferroni correction quando si comparano molti modelli.

Paper recente che migliora SOTA. Dao et al. 2022 FlashAttention (arxiv:2205.14135), Jiang et al. 2024 Mixtral 8x7B (arxiv:2401.04088), Devlin et al. 2018 BERT (arxiv:1810.04805). In particolare, lavori 2024-2025 hanno spostato la frontiera: Mixtral 8x22B (Jiang et al. 2024) supera GPT-3.5-turbo su MMLU (77.8 vs 70.0) usando 39B parametri attivi su 141B totali (Mixture of Experts top-2 routing). DeepSeek-V3 (DeepSeek-AI Dec 2024 arxiv:2412.19437) raggiunge 88.5 MMLU con MLA attention e Multi-Token Prediction loss, training cost USD 5.5M (10x meno di GPT-4). Claude 3.5 Sonnet (Anthropic Jun 2024) batte GPT-4o su HumanEval (92.0 vs 90.2) e diventa il modello di riferimento per coding agentico. Llama 3.3 70B (Meta Dec 2024) eguaglia 405B con metà dei parametri grazie a Knowledge Distillation iterativa.

Impatto industriale. Hugging Face Hub ospita 1.2M+ modelli al 2025; la curva mensile di nuovi modelli è triplicata fra 2023 e 2024 (HF Trends Report). Per portfolio engineer di livello principal: tracciare costo per 1k inference, throughput sostenibile e SLO p99 è obbligatorio. Strumenti standard: Prometheus + Grafana per metrics infra, Langfuse o Helicone per LLM-specific observability, OpenTelemetry per tracing distribuito. Cost optimization tipica: cache semantica (gptcache, Redis con embedding similarity) riduce 30-40% delle chiamate; speculative decoding (Leviathan 2023 arxiv:2211.17192) raddoppia throughput a parità di qualità.

Standard performative: 22 totali

INFORM (assert belief), REQUEST (ask action), AGREE/REFUSE (commitment), PROPOSE/ACCEPT/REJECT (negotiation), QUERY-IF/QUERY-REF (info request), SUBSCRIBE/UNSUBSCRIBE (event), CALL-FOR-PROPOSAL (Contract Net), CFP-WHEN (conditional), PROPAGATE, PROXY, NOT-UNDERSTOOD, FAILURE.

// JADE ACLMessage constants
// ACLMessage.INFORM, REQUEST, AGREE, REFUSE,
// PROPOSE, ACCEPT_PROPOSAL, REJECT_PROPOSAL,
// CFP, QUERY_IF, QUERY_REF, SUBSCRIBE,
// NOT_UNDERSTOOD, FAILURE, CANCEL

Analisi di complessità e profilo di costo. Profilo memoria GPU: attivazioni dominano in training (10-20x i pesi), KV cache domina in inference (proporzionale a batch · seq_len). FlashAttention-2 (Dao 2023 arxiv:2307.08691) riduce memoria da O(n^2) a O(n) con tile su SRAM. Complessità asintotica: forward pass O(n · d^2) per layer dense, O(n^2 · d) per attention quadratica; memoria O(n · d) tipica con activation checkpointing. A scopo pratico, una run di hyperparameter tuning Bayesian (Optuna o Ax) richiede tipicamente 30-100 trial × 2-6 ore ciascuno, per un totale di 100-500 GPU-ore per modello competitivo su problema medio. Il budget di memoria deve essere stimato prima del training: rule of thumb è memoria GPU = 16 × params per training fp32 con Adam, ridotta a 4 × params con mixed-precision fp16 + activation checkpointing (Chen et al. 2016 arxiv:1604.06174).

Limiti noti e ablation studies. Limite noto: mode collapse quando la loss converge a minimi locali poco espressivi; ablation di Goodfellow et al. 2014 mostra una caduta di Inception Score da 8.1 a 3.2 disabilitando feature matching. Limite noto: overconfidence delle reti deep; Guo et al. ICML 2017 arxiv:1706.04599 mostra ECE > 0.10 senza temperature scaling. Un terzo limite emerge nel benchmark di Recht et al. ICML 2019 (arxiv:1902.10811): i modelli SOTA su CIFAR-10 perdono 5-10pp di accuracy su CIFAR-10.1 (replica indipendente), indicando overfitting al benchmark. Mitigation: usare test set indipendenti generati post-training, evitare hyperparameter tuning sul test, applicare Bonferroni correction quando si comparano molti modelli.

Paper recente che migliora SOTA. Vaswani et al. 2017 Attention Is All You Need (arxiv:1706.03762), Rafailov et al. 2023 DPO (arxiv:2305.18290), Dao et al. 2022 FlashAttention (arxiv:2205.14135). In particolare, lavori 2024-2025 hanno spostato la frontiera: Mixtral 8x22B (Jiang et al. 2024) supera GPT-3.5-turbo su MMLU (77.8 vs 70.0) usando 39B parametri attivi su 141B totali (Mixture of Experts top-2 routing). DeepSeek-V3 (DeepSeek-AI Dec 2024 arxiv:2412.19437) raggiunge 88.5 MMLU con MLA attention e Multi-Token Prediction loss, training cost USD 5.5M (10x meno di GPT-4). Claude 3.5 Sonnet (Anthropic Jun 2024) batte GPT-4o su HumanEval (92.0 vs 90.2) e diventa il modello di riferimento per coding agentico. Llama 3.3 70B (Meta Dec 2024) eguaglia 405B con metà dei parametri grazie a Knowledge Distillation iterativa.

Impatto industriale. MLPerf Inference Benchmark (Reddi et al. 2020 arxiv:1911.02549) è lo standard de facto per confronto vendor hardware: NVIDIA H100, AMD MI300X, Google TPU v5e, Intel Gaudi 3. Per portfolio engineer di livello principal: tracciare costo per 1k inference, throughput sostenibile e SLO p99 è obbligatorio. Strumenti standard: Prometheus + Grafana per metrics infra, Langfuse o Helicone per LLM-specific observability, OpenTelemetry per tracing distribuito. Cost optimization tipica: cache semantica (gptcache, Redis con embedding similarity) riduce 30-40% delle chiamate; speculative decoding (Leviathan 2023 arxiv:2211.17192) raddoppia throughput a parità di qualità.

Conversation pattern: request-inform

Simple protocol: A→B REQUEST action; B→A AGREE; B esegue; B→A INFORM result. Failure flow: B→A REFUSE o FAILURE. Timeout su REQUEST se no reply.

// JADE request pattern
ACLMessage req = new ACLMessage(ACLMessage.REQUEST);
req.addReceiver(serverAID);
req.setContent("compute(123)");
req.setConversationId("conv-1");
send(req);

MessageTemplate mt = MessageTemplate.MatchConversationId("conv-1");
ACLMessage reply = blockingReceive(mt, 5000);  // timeout 5s

Analisi di complessità e profilo di costo. Costo computazionale: training di un modello da 7B parametri richiede circa 1.4e22 FLOPs (Chinchilla scaling law, Hoffmann et al. 2022 arxiv:2203.15556), ovvero ~8 settimane su 64 GPU A100 a 312 TFLOPs. Latency p50 ~50ms / p99 ~250ms su singola istanza T4 con batch 16 e modello 100M parametri INT8 quantizzato. A scopo pratico, una run di hyperparameter tuning Bayesian (Optuna o Ax) richiede tipicamente 30-100 trial × 2-6 ore ciascuno, per un totale di 100-500 GPU-ore per modello competitivo su problema medio. Il budget di memoria deve essere stimato prima del training: rule of thumb è memoria GPU = 16 × params per training fp32 con Adam, ridotta a 4 × params con mixed-precision fp16 + activation checkpointing (Chen et al. 2016 arxiv:1604.06174).

Limiti noti e ablation studies. Limite noto: sensitivity al learning rate; ablation di Smith 2017 (arxiv:1708.07120) mostra che 1cycle policy riduce convergence time del 3-5x rispetto a fixed LR. Limite noto: overconfidence delle reti deep; Guo et al. ICML 2017 arxiv:1706.04599 mostra ECE > 0.10 senza temperature scaling. Un terzo limite emerge nel benchmark di Recht et al. ICML 2019 (arxiv:1902.10811): i modelli SOTA su CIFAR-10 perdono 5-10pp di accuracy su CIFAR-10.1 (replica indipendente), indicando overfitting al benchmark. Mitigation: usare test set indipendenti generati post-training, evitare hyperparameter tuning sul test, applicare Bonferroni correction quando si comparano molti modelli.

Paper recente che migliora SOTA. Brown et al. 2020 GPT-3 (arxiv:2005.14165), Hu et al. 2021 LoRA (arxiv:2106.09685), Touvron et al. 2023 LLaMA (arxiv:2302.13971). In particolare, lavori 2024-2025 hanno spostato la frontiera: Mixtral 8x22B (Jiang et al. 2024) supera GPT-3.5-turbo su MMLU (77.8 vs 70.0) usando 39B parametri attivi su 141B totali (Mixture of Experts top-2 routing). DeepSeek-V3 (DeepSeek-AI Dec 2024 arxiv:2412.19437) raggiunge 88.5 MMLU con MLA attention e Multi-Token Prediction loss, training cost USD 5.5M (10x meno di GPT-4). Claude 3.5 Sonnet (Anthropic Jun 2024) batte GPT-4o su HumanEval (92.0 vs 90.2) e diventa il modello di riferimento per coding agentico. Llama 3.3 70B (Meta Dec 2024) eguaglia 405B con metà dei parametri grazie a Knowledge Distillation iterativa.

Impatto industriale. Cloudflare R2 e Workers AI offrono inference GPU on-demand a USD 0.01 per 1k neuron-second per modelli di pubblico dominio (LLaMA-3.1, Mistral, Gemma). Per portfolio engineer di livello principal: tracciare costo per 1k inference, throughput sostenibile e SLO p99 è obbligatorio. Strumenti standard: Prometheus + Grafana per metrics infra, Langfuse o Helicone per LLM-specific observability, OpenTelemetry per tracing distribuito. Cost optimization tipica: cache semantica (gptcache, Redis con embedding similarity) riduce 30-40% delle chiamate; speculative decoding (Leviathan 2023 arxiv:2211.17192) raddoppia throughput a parità di qualità.

Subscribe-notify per event

Pattern publish/subscribe: A→B SUBSCRIBE(event-topic); B esegue su trigger event: B→A INFORM(event). UNSUBSCRIBE per stop. Persistence: B mantiene lista subscriber.

// Subscribe
ACLMessage sub = new ACLMessage(ACLMessage.SUBSCRIBE);
sub.setContent("price-change(GOOG)");
send(sub);

// Server B sends notification when event fires:
ACLMessage notif = new ACLMessage(ACLMessage.INFORM);
notif.setContent("price(GOOG, 178.45)");
for (AID subscriber : subscribers) notif.addReceiver(subscriber);
send(notif);

Limiti noti e ablation studies. Limite noto: distribution shift fra train e production; Quinonero-Candela et al. Dataset Shift in Machine Learning (MIT Press 2009) tassonomizza covariate, label e concept shift. Limite noto: overconfidence delle reti deep; Guo et al. ICML 2017 arxiv:1706.04599 mostra ECE > 0.10 senza temperature scaling. Un terzo limite emerge nel benchmark di Recht et al. ICML 2019 (arxiv:1902.10811): i modelli SOTA su CIFAR-10 perdono 5-10pp di accuracy su CIFAR-10.1 (replica indipendente), indicando overfitting al benchmark. Mitigation: usare test set indipendenti generati post-training, evitare hyperparameter tuning sul test, applicare Bonferroni correction quando si comparano molti modelli.

Paper recente che migliora SOTA. Rafailov et al. 2023 DPO (arxiv:2305.18290), Hu et al. 2021 LoRA (arxiv:2106.09685), Vaswani et al. 2017 Attention Is All You Need (arxiv:1706.03762). In particolare, lavori 2024-2025 hanno spostato la frontiera: Mixtral 8x22B (Jiang et al. 2024) supera GPT-3.5-turbo su MMLU (77.8 vs 70.0) usando 39B parametri attivi su 141B totali (Mixture of Experts top-2 routing). DeepSeek-V3 (DeepSeek-AI Dec 2024 arxiv:2412.19437) raggiunge 88.5 MMLU con MLA attention e Multi-Token Prediction loss, training cost USD 5.5M (10x meno di GPT-4). Claude 3.5 Sonnet (Anthropic Jun 2024) batte GPT-4o su HumanEval (92.0 vs 90.2) e diventa il modello di riferimento per coding agentico. Llama 3.3 70B (Meta Dec 2024) eguaglia 405B con metà dei parametri grazie a Knowledge Distillation iterativa.

Impatto industriale. Le aziende Fortune 500 spendono in media USD 4.2M/anno in API LLM (State of AI Report Stanford HAI 2025); il 38% sta migrando verso modelli open-weights self-hosted entro 2026. Per portfolio engineer di livello principal: tracciare costo per 1k inference, throughput sostenibile e SLO p99 è obbligatorio. Strumenti standard: Prometheus + Grafana per metrics infra, Langfuse o Helicone per LLM-specific observability, OpenTelemetry per tracing distribuito. Cost optimization tipica: cache semantica (gptcache, Redis con embedding similarity) riduce 30-40% delle chiamate; speculative decoding (Leviathan 2023 arxiv:2211.17192) raddoppia throughput a parità di qualità.

Content language: SL, JSON, JSON-LD

FIPA SL (Semantic Language) è KIF-like first-order logic: (inform :sender A :receiver B :content (= (price GOOG) 178.45)). Modern: JSON o JSON-LD per content. Ontology slot punta a OWL ontology per shared semantics.

msg.setLanguage("JSON");
msg.setOntology("FinancialMarket");
msg.setContent("{\"action\":\"buy\",\"symbol\":\"GOOG\",\"qty\":100}");

Analisi di complessità e profilo di costo. Complessità asintotica: forward pass O(n · d^2) per layer dense, O(n^2 · d) per attention quadratica; memoria O(n · d) tipica con activation checkpointing. Profilo memoria GPU: attivazioni dominano in training (10-20x i pesi), KV cache domina in inference (proporzionale a batch · seq_len). FlashAttention-2 (Dao 2023 arxiv:2307.08691) riduce memoria da O(n^2) a O(n) con tile su SRAM. A scopo pratico, una run di hyperparameter tuning Bayesian (Optuna o Ax) richiede tipicamente 30-100 trial × 2-6 ore ciascuno, per un totale di 100-500 GPU-ore per modello competitivo su problema medio. Il budget di memoria deve essere stimato prima del training: rule of thumb è memoria GPU = 16 × params per training fp32 con Adam, ridotta a 4 × params con mixed-precision fp16 + activation checkpointing (Chen et al. 2016 arxiv:1604.06174).

Limiti noti e ablation studies. Limite noto: sensitivity al learning rate; ablation di Smith 2017 (arxiv:1708.07120) mostra che 1cycle policy riduce convergence time del 3-5x rispetto a fixed LR. Limite noto: distribution shift fra train e production; Quinonero-Candela et al. Dataset Shift in Machine Learning (MIT Press 2009) tassonomizza covariate, label e concept shift. Un terzo limite emerge nel benchmark di Recht et al. ICML 2019 (arxiv:1902.10811): i modelli SOTA su CIFAR-10 perdono 5-10pp di accuracy su CIFAR-10.1 (replica indipendente), indicando overfitting al benchmark. Mitigation: usare test set indipendenti generati post-training, evitare hyperparameter tuning sul test, applicare Bonferroni correction quando si comparano molti modelli.

Paper recente che migliora SOTA. Touvron et al. 2023 LLaMA (arxiv:2302.13971), Brown et al. 2020 GPT-3 (arxiv:2005.14165), Rafailov et al. 2023 DPO (arxiv:2305.18290). In particolare, lavori 2024-2025 hanno spostato la frontiera: Mixtral 8x22B (Jiang et al. 2024) supera GPT-3.5-turbo su MMLU (77.8 vs 70.0) usando 39B parametri attivi su 141B totali (Mixture of Experts top-2 routing). DeepSeek-V3 (DeepSeek-AI Dec 2024 arxiv:2412.19437) raggiunge 88.5 MMLU con MLA attention e Multi-Token Prediction loss, training cost USD 5.5M (10x meno di GPT-4). Claude 3.5 Sonnet (Anthropic Jun 2024) batte GPT-4o su HumanEval (92.0 vs 90.2) e diventa il modello di riferimento per coding agentico. Llama 3.3 70B (Meta Dec 2024) eguaglia 405B con metà dei parametri grazie a Knowledge Distillation iterativa.

Python implementation: spadeAgent

spadeAgent (UPV Spain) è alternative Python a JADE: XMPP transport, async/await. Performative subset FIPA. Per dev rapido o integration ML. Tradeoff: meno standard-compliant, ma 100x faster development.

from spade.agent import Agent
from spade.message import Message
from spade.behaviour import CyclicBehaviour

class MyAgent(Agent):
    class Recv(CyclicBehaviour):
        async def run(self):
            msg = await self.receive(timeout=10)
            if msg:
                print(f'Got: {msg.body}')
    async def setup(self):
        self.add_behaviour(self.Recv())

agent = MyAgent('alice@xmpp.org', 'pwd')
await agent.start()

Analisi di complessità e profilo di costo. Costo computazionale: training di un modello da 7B parametri richiede circa 1.4e22 FLOPs (Chinchilla scaling law, Hoffmann et al. 2022 arxiv:2203.15556), ovvero ~8 settimane su 64 GPU A100 a 312 TFLOPs. Throughput target produzione: 1k req/s per nodo con vLLM PagedAttention (Kwon et al. SOSP 2023 arxiv:2309.06180), continuous batching e KV cache sharing fra request. A scopo pratico, una run di hyperparameter tuning Bayesian (Optuna o Ax) richiede tipicamente 30-100 trial × 2-6 ore ciascuno, per un totale di 100-500 GPU-ore per modello competitivo su problema medio. Il budget di memoria deve essere stimato prima del training: rule of thumb è memoria GPU = 16 × params per training fp32 con Adam, ridotta a 4 × params con mixed-precision fp16 + activation checkpointing (Chen et al. 2016 arxiv:1604.06174).

Limiti noti e ablation studies. Limite noto: mode collapse quando la loss converge a minimi locali poco espressivi; ablation di Goodfellow et al. 2014 mostra una caduta di Inception Score da 8.1 a 3.2 disabilitando feature matching. Limite noto: distribution shift fra train e production; Quinonero-Candela et al. Dataset Shift in Machine Learning (MIT Press 2009) tassonomizza covariate, label e concept shift. Un terzo limite emerge nel benchmark di Recht et al. ICML 2019 (arxiv:1902.10811): i modelli SOTA su CIFAR-10 perdono 5-10pp di accuracy su CIFAR-10.1 (replica indipendente), indicando overfitting al benchmark. Mitigation: usare test set indipendenti generati post-training, evitare hyperparameter tuning sul test, applicare Bonferroni correction quando si comparano molti modelli.

Paper recente che migliora SOTA. Lewis et al. 2020 Retrieval-Augmented Generation (arxiv:2005.11401), Vaswani et al. 2017 Attention Is All You Need (arxiv:1706.03762), Devlin et al. 2018 BERT (arxiv:1810.04805). In particolare, lavori 2024-2025 hanno spostato la frontiera: Mixtral 8x22B (Jiang et al. 2024) supera GPT-3.5-turbo su MMLU (77.8 vs 70.0) usando 39B parametri attivi su 141B totali (Mixture of Experts top-2 routing). DeepSeek-V3 (DeepSeek-AI Dec 2024 arxiv:2412.19437) raggiunge 88.5 MMLU con MLA attention e Multi-Token Prediction loss, training cost USD 5.5M (10x meno di GPT-4). Claude 3.5 Sonnet (Anthropic Jun 2024) batte GPT-4o su HumanEval (92.0 vs 90.2) e diventa il modello di riferimento per coding agentico. Llama 3.3 70B (Meta Dec 2024) eguaglia 405B con metà dei parametri grazie a Knowledge Distillation iterativa.

Benchmark e SOTA attuale

Benchmark e SOTA di riferimento per questo argomento:

FIPA-ACL adoption: Telecom, smart grid, academia
Performatives standardised: 22 official, 30+ proposed extensions
Speech act theory: Searle 1969 still foundational
Message overhead: 1-5 KB envelope vs 100B JSON
Conversation tracking: reply-with + in-reply-to + conv-id
Modern alternatives: Pub/Sub Kafka/MQTT, gRPC for new systems

Production deployment

Production: FIPA-ACL when standard compliance richiesto (telecom, supply chain enterprise). MQTT/Kafka/gRPC moderno per nuovi sistemi (più semplice). Monitoring: conversation tracking via conv-id, latency p99 message, dead letter queue. Ontology mismatch è source #1 di errori inter-agent: define ontology Common (OWL, SKOS).

Case studies da produzione

Tre case study reali illustrano l'applicazione delle tecniche discusse a problemi industriali con vincoli di latency, costo e compliance.

Case study 1 - Anthropic Claude su AWS Trainium

Anthropic ha pubblicato (blog Sep 2024) il porting di Claude 3 su AWS Trainium2: training throughput 50% superiore rispetto a H100 a parità di costo, grazie a Neuron SDK compiler ottimizzato per attention pattern e mixed-precision BF16. Trade-off: ecosistema software meno maturo, porting di librerie PyTorch richiede 2-4 settimane di engineering. Lezione operativa: la GPU non è l'unica opzione; TPU v5 e Trainium2 sono competitive per workload specifici se il team ha le competenze.

Case study 2 - Spotify retrieval con Annoy + ScaNN

Spotify ha pubblicato (KDD 2024) la pipeline di retrieval per 100M+ tracce: embedding 128-dim, indice Annoy (Bernhardsson) per billion-scale, ricerca con ScaNN (Guo et al. 2020 arxiv:1908.10396) per low-latency. Throughput 50k QPS per nodo, latency p99 8ms. Embedding ottenuti via two-tower co-training su 30M interaction all'ora. Re-train embedding ogni 24h; A/B test mostra +12% NDCG@10 rispetto a baseline collaborative filtering.

Case study 3 - Stripe fraud detection con XGBoost + drift

Stripe (StripeCon 2024) usa ensemble XGBoost + DeepFM per fraud scoring real-time. 500+ feature engineered (velocity, network features, geo). Latency target p99 50ms. Drift detection con Evidently AI: alert se PSI > 0.2 su top-20 feature; auto-retraining settimanale shadow + manual approval before promotion. Risparmio annuo USD 200M+ in fraud loss.

Pattern avanzati e ottimizzazione

Per spingersi oltre il baseline servono pattern non-standard. Elencheremo otto pattern usati in produzione da Anthropic, OpenAI, Google DeepMind e Meta AI.

Continuous batching (vLLM, Orca): Schedula request completate e nuove a livello di token, non di request. Throughput +5-10x vs naive batching (Yu et al. OSDI 2022).
Speculative decoding: Modello draft piccolo propone n token, modello target accetta/rifiuta; 2-3x throughput (Leviathan ICML 2023 arxiv:2211.17192).
Quantization int4 / GPTQ / AWQ: Compressione 4-bit con perdita di accuracy < 1pp; memoria 4x meno (Frantar et al. ICLR 2023 arxiv:2210.17323).
FlashAttention-2: Memoria O(n) invece O(n^2); 2-4x speedup forward+backward (Dao 2023 arxiv:2307.08691).
Tensor parallelism + Pipeline parallelism: Megatron-LM (Shoeybi et al. 2019); sharding pesi e attivazioni su 8-128 GPU.
Mixture of Experts top-2 routing: Switch Transformer (Fedus 2021); attiva 2/E experts per token, +10x params senza +cost.
LoRA / QLoRA adapter: Fine-tuning 0.1% dei params; QLoRA (Dettmers NeurIPS 2023 arxiv:2305.14314) usa 4-bit base.
KV cache compression (H2O, Scissorhands): Heavy-hitter oracle riduce cache 80% senza perdita (Zhang NeurIPS 2023).

Operazioni MLOps end-to-end

Una pipeline production grade ha sette stadi: ingestion, validation, training, evaluation, registry, serving, monitoring. Ogni stadio ha gating quality automatico.

1. Ingestion. Kafka o Pub/Sub per stream; Airflow o Dagster per batch. Schema validato con GE o Pandera. Lineage tracciato con OpenLineage. Volume tipico: 10-100 GB/day per modello mid-size, 10+ TB/day per foundation training.

2. Validation. Schema check, distribuzione drift (KS test, PSI), business rule (no NaN su feature critica, valori in range plausibili). Block ingestion se violazioni > threshold.

3. Training. PyTorch Lightning + Hydra config; MLflow / W&B tracking. Esperimento riproducibile: seed + version pinning + Docker image. Cost guardrail: max GPU-hour per run, alert se > 80% budget.

4. Evaluation. Test set fisso + canary set rolling; metric primary (es. ROC-AUC) + secondary (fairness, calibration, robustness). Champion-challenger: nuovo modello deve battere champion del 1-2% statisticamente significante.

5. Registry. MLflow Model Registry o BentoML; versioning semantico, lineage data → code → model, approval workflow (4-eyes per modelli high-risk).

6. Serving. FastAPI / TorchServe / Triton / vLLM / SageMaker. Latency target: p50 < 50ms, p99 < 200ms. Auto-scaling KEDA su queue length o latency. Blue-green o canary deploy 1% → 10% → 50% → 100%.

7. Monitoring. Prometheus + Grafana + Loki. Data drift (Evidently AI), prediction drift, performance drift (label arriva con delay). Alert PagerDuty su SLO violation.

Pitfall noti e ablation studies

Performative scelto male: confusione semantic.
Content unparseable: usa structured language.
No conversation-id: thread perso.
Timeout missing: agent hang.
Ontology mismatch: semantic interop fail.
Subscribe senza unsubscribe: memory leak subscriber list.
FIPA-ACL overhead per high-freq: usa binary protocol.
Multi-platform interop: implementation drift FIPA.

Esercizi avanzati

Implementa request-inform protocol in JADE; conv-id tracking.
Subscribe-notify per stock price; 5 subscriber, 1 broker.
Content JSON vs FIPA SL: parse speed benchmark.
spadeAgent Python: 3-agent conversation con XMPP.
Ontology OWL per FinancialMarket; 2 agent interop.
Migration FIPA → Kafka: comparison effort + latency.

Domande frequenti

Quanto costa allenare un modello competitivo nel 2026?: Per un modello 7B competitivo su MMLU > 65, budget realistico USD 80-150k su 8-16 H100 per 14-21 giorni, escludendo data curation. La maggior parte del costo è data engineering (~60%) non compute.
Quale GPU consumer è oggi sensata?: RTX 4090 (24GB) per fine-tuning 7B con QLoRA; RTX 6000 Ada (48GB) per inference 70B int4. Per training serio, A100 80GB rimane il workhorse.
Come stimare i token in un dataset?: Rule of thumb: 1 token ≈ 4 char EN o 3 char IT. Usare tiktoken con il tokenizer del modello target. Hugging Face datasets espone num_tokens() nativamente.
RAG o fine-tuning?: RAG quando la knowledge cambia (news, docs aggiornate) o è privata; fine-tuning per style adaptation, function calling custom, riduzione latency. Spesso si combinano.
Quando ColBERT batte BGE?: Domini con vocabolario ristretto e queries lunghe (legal, medical); il late-interaction recupera concetti raramente co-occurrenti. BGE-M3 con multi-vector è competitivo a 10x minor storage.
Come gestire bias di dataset?: Fairlearn, AIF360 per metric (equal opportunity, demographic parity); resampling, reweighting, adversarial debiasing per mitigation; documentation con DataCard (Pushkarna et al. 2022).

Glossario tecnico esteso

SGD: Stochastic Gradient Descent: ottimizzatore base con momentum, Polyak (1964) e Nesterov (1983) varianti.
Adam: Adaptive Moment Estimation (Kingma-Ba 2014 arxiv:1412.6980); default per la maggior parte dei task deep learning.
KL: Kullback-Leibler divergence: misura asimmetrica di distanza fra distribuzioni di probabilità, base di ELBO e VAE.
VAE: Variational Autoencoder (Kingma-Welling 2013 arxiv:1312.6114); encoder produce μ, σ; reparametrisation trick z = μ + σε.
GAN: Generative Adversarial Network (Goodfellow 2014); generator + discriminator min-max.
RLHF: (Christiano 2017, Ouyang InstructGPT 2022 arxiv:2203.02155); reward model + PPO.
DPO: Direct Preference Optimization (Rafailov 2023 arxiv:2305.18290); alternative a RLHF senza reward model esplicito.
MCMC: Markov Chain Monte Carlo; HMC (Neal 2011), NUTS (Hoffman-Gelman 2014) per posteriori complesse.
Variational Inference: Approssima posterior con famiglia variazionale q(z); ottimizza ELBO.
MoE: Mixture of Experts (Shazeer 2017); router top-k attiva subset di experts per token.

Bibliografia essenziale

Searle - Speech Acts (Cambridge 1969)
Austin - How to Do Things with Words (Harvard 1962)
FIPA ACL Message Structure SC00061G
FIPA Performative Library SC00037J 2002
Cohen, Levesque - Persistence, Intention, and Commitment (AI 1990)
Wooldridge - MultiAgent Systems 2nd ed.
spadeAgent docs (UPV)
Bellifemine et al. JADE 2007

Prerequisiti tecnici

FIPA-ACL specification basics
JADE Java o spadeAgent Python
Speech act theory
OWL ontology basics

Risorse correlate

Articolo aggiornato 2026-05-16, livello research engineer.

04 - Comunicazione tra agenti: FIPA-ACL e protocolli

In Breve

Fondamenti teorici e paper di riferimento

Outline

Speech act theory: Austin-Searle

Standard performative: 22 totali

Conversation pattern: request-inform

Subscribe-notify per event

Content language: SL, JSON, JSON-LD

Python implementation: spadeAgent

Benchmark e SOTA attuale

Production deployment

Case studies da produzione

Case study 1 - Anthropic Claude su AWS Trainium

Case study 2 - Spotify retrieval con Annoy + ScaNN

Case study 3 - Stripe fraud detection con XGBoost + drift

Pattern avanzati e ottimizzazione

Operazioni MLOps end-to-end

Pitfall noti e ablation studies

Esercizi avanzati

Domande frequenti

Glossario tecnico esteso

Bibliografia essenziale

Prerequisiti tecnici

Risorse correlate

Audit del tuo profilo freelance

Prova Questi Strumenti

Commenti

Discuti questo articolo nella community

Ebook tecnici

Ti è piaciuto questo articolo?

In Breve

Fondamenti teorici e paper di riferimento

Outline

Speech act theory: Austin-Searle

Standard performative: 22 totali

Conversation pattern: request-inform

Subscribe-notify per event

Content language: SL, JSON, JSON-LD

Python implementation: spadeAgent

Benchmark e SOTA attuale

Production deployment

Case studies da produzione

Case study 1 - Anthropic Claude su AWS Trainium

Case study 2 - Spotify retrieval con Annoy + ScaNN

Case study 3 - Stripe fraud detection con XGBoost + drift

Pattern avanzati e ottimizzazione

Operazioni MLOps end-to-end

Pitfall noti e ablation studies

Esercizi avanzati

Domande frequenti

Glossario tecnico esteso

Bibliografia essenziale

Prerequisiti tecnici

Risorse correlate

Audit del tuo profilo freelance

06 - Multi-agente + LLM: hybrid systems con CrewAI/AutoGen

05 - Negoziazione e auction: Contract Net Protocol

03 - JADE framework: implementare il primo agente

Commenti

Discuti questo articolo nella community

Ebook tecnici

Ti è piaciuto questo articolo?