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.

Multi-agent + LLM hybrid systems sono il pattern dominante 2024-2026 per task complessi: CrewAI (role-based), AutoGen (Microsoft conversation-based), LangGraph (stateful workflow). Costruiamo sistema multi-agent reale per software engineering automation: planner + coder + reviewer + tester, ognuno LLM-backed con tool specifici. Confronto con classico CNP/BDI multi-agent.

Fondamenti teorici e paper di riferimento

LLM agents reincarnano BDI: prompt history = beliefs, system prompt = desires, tool calls = intentions. Multi-agent LLM: comunicazione via natural language, role specialization, emergent coordination. Reference: Wu et al. AutoGen (arxiv:2308.08155), CrewAI documentation, Park et al. Generative Agents: Interactive Simulacra of Human Behavior (UIST 2023 arxiv:2304.03442).

Pattern: sequential (planner→coder→reviewer→tester), parallel (3 reviewers indipendenti), hierarchical (manager-worker), conversational (back-and-forth refinement). Trade-off: coordination overhead vs single-agent. Costo: 4-10x LLM call.

Outline

CrewAI: role-based pattern
AutoGen: conversation pattern
LangGraph: stateful workflow
Software engineering automation
Evaluation: SWE-Bench, HumanEval+
Safety, sandbox, observability

CrewAI: role-based pattern

CrewAI definisce Crew of Agents, ognuno con role + goal + backstory + tools. Tasks assignati ad agent, execute sequential o hierarchical. Inter-agent: delegation auto se allow_delegation=True. Reference: crewai.com docs.

from crewai import Agent, Task, Crew
planner = Agent(role='Planner', goal='Design solution', tools=[...])
coder = Agent(role='Coder', goal='Implement', tools=[code_tool])
tester = Agent(role='Tester', goal='Verify', tools=[run_tests])

tasks = [
    Task(description='Design X', agent=planner),
    Task(description='Code Y', agent=coder),
    Task(description='Test Z', agent=tester)]
Crew(agents=[planner, coder, tester], tasks=tasks).kickoff()

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. 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. 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. 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. Hu et al. 2021 LoRA (arxiv:2106.09685), Brown et al. 2020 GPT-3 (arxiv:2005.14165), Jiang et al. 2024 Mixtral 8x7B (arxiv:2401.04088). 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à.

AutoGen: conversation pattern

AutoGen (Microsoft Research 2024 arxiv:2308.08155): GroupChat di multiple agent, manager seleziona next speaker. Pattern: UserProxyAgent (human-in-loop) + AssistantAgent (LLM) + Code Executor. Code execution sandboxed in Docker.

from autogen import AssistantAgent, UserProxyAgent, GroupChat, GroupChatManager
planner = AssistantAgent('Planner', llm_config={'model':'gpt-4o'})
coder = AssistantAgent('Coder', llm_config={'model':'gpt-4o'})
user = UserProxyAgent('User', code_execution_config={'use_docker':True})
gc = GroupChat([planner, coder, user], messages=[], max_round=20)
mgr = GroupChatManager(gc, llm_config={'model':'gpt-4o'})
user.initiate_chat(mgr, message='Build a flask app')

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. 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: 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: 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. 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), Rafailov et al. 2023 DPO (arxiv:2305.18290), Lewis et al. 2020 Retrieval-Augmented Generation (arxiv:2005.11401). 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à.

LangGraph: stateful workflow

LangGraph (LangChain 2024): graph diretto di node (LLM/tool), edge conditional. State persistente cross-node. Permette loop bounded, retry, parallel branches. Standard 2026 per production agents.

from langgraph.graph import StateGraph, END
from typing import TypedDict
class State(TypedDict):
    plan: str
    code: str
    review: str
g = StateGraph(State)
g.add_node('plan', planner_fn)
g.add_node('code', coder_fn)
g.add_node('review', reviewer_fn)
g.add_edge('plan', 'code')
g.add_edge('code', 'review')
g.add_conditional_edges('review', lambda s: 'code' if 'fix' in s['review'] else END)
g.set_entry_point('plan')
app = g.compile()

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. 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. 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: 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. Hu et al. 2021 LoRA (arxiv:2106.09685), Lewis et al. 2020 Retrieval-Augmented Generation (arxiv:2005.11401), Yao et al. 2022 ReAct (arxiv:2210.03629). 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.

Software engineering automation

Devin (Cognition 2024), Claude 3.5 Sonnet Computer Use, SWE-Bench leaderboard. Pattern: read repo → understand task → write code → run tests → fix iteratively. Devin claim 14% SWE-Bench, Cognition 49% Claude 3.5. Real-world: pattern usato in Sweep, Aider, Cursor Composer.

# Aider-like pseudo-code
repo = clone_repo()
task = 'Fix bug in auth.py'
relevant_files = embed_search(task, repo)
diff = llm.generate_diff(task, relevant_files)
apply_diff(diff)
result = run_tests()
if result.failed: refine_with(llm, result)

Analisi di complessità e profilo di costo. 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. 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. 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: 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: 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), Touvron et al. 2023 LLaMA (arxiv:2302.13971), Yao et al. 2022 ReAct (arxiv:2210.03629). 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à.

Evaluation: SWE-Bench, HumanEval+

SWE-Bench (Princeton 2023 arxiv:2310.06770): 2294 real GitHub issues + tests. Frontier 2026: Claude 3.5 Sonnet 49% resolved, GPT-4o 33%, open-source LLaMA-70B 14%. HumanEval+ (Liu 2023): function-level coding, pass@1 96.3% Claude 3.5 Sonnet.

# SWE-Bench eval
# Each instance: repo SHA + test before fix + golden patch
# Agent must produce patch that passes test post-fix
# Metric: resolved % = test passes
# Lite split: 300 easier instances

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. 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: 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. Lewis et al. 2020 Retrieval-Augmented Generation (arxiv:2005.11401), Dao et al. 2022 FlashAttention (arxiv:2205.14135), 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. In produzione, OpenAI riporta costi inference di USD 0.50 per milione di token su GPT-4o-mini (Q1 2025), mentre soluzioni on-prem con vLLM su LLaMA-3.1-8B raggiungono USD 0.05 equivalenti per milione di token su singola GPU A10. 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à.

Safety, sandbox, observability

Sandbox tool execution: Docker, Firecracker, gVisor. Permission per tool (read-only vs write). Confirm step per destructive (DB write, send email, file delete). Logging immutable: Langfuse, LangSmith, custom OpenTelemetry. Cost budget per agent run.

# Cost budget enforcement
MAX_COST_USD = 5.0
total_cost = 0.0
while not done:
    cost = llm_call_estimate(prompt)
    total_cost += cost
    if total_cost > MAX_COST_USD:
        raise BudgetExceeded()
    response = llm.generate(prompt)

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: 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: 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. 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. Hu et al. 2021 LoRA (arxiv:2106.09685), Jiang et al. 2024 Mixtral 8x7B (arxiv:2401.04088), Yao et al. 2022 ReAct (arxiv:2210.03629). 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:

CrewAI GitHub stars: Q1 2026 ~20k stars
AutoGen Microsoft adoption: Used in Azure AI Studio
LangGraph: Production standard 2026
SWE-Bench Verified: Claude 3.5 Sonnet 49%, frontier 2026
Devin Cognition: 1.6x slower vs single Claude but more autonomous
Cost per SWE-Bench run: $1-10 typical agent run

Production deployment

Production stack 2026: LangGraph (stateful), Claude 3.5 Sonnet / GPT-4o (frontier), Pydantic schema validation, Firecracker sandbox, Redis state persistence, Langfuse observability, PagerDuty alerts. Cost budget: $0.05-0.50 per simple task, $5-50 per SWE-Bench-class. Safety: human confirm su destructive, audit log immutable.

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

Looping infinite: cap max iterations.
Cost unchecked: budget per run.
Hallucinated tool: schema validation.
Prompt injection multi-agent: trust boundaries.
State race condition: lock o serialise.
Emergent behavior unpredictable: extensive eval.
Latency cumulative: 10x single agent.
Debug difficile: log every step.

Esercizi avanzati

CrewAI 3-agent research/write/review on topic; faithfulness.
AutoGen UserProxy + Assistant + CodeExecutor: build flask app.
LangGraph stateful workflow: planner-coder-tester con retry.
SWE-Bench Lite eval con Claude 3.5 Sonnet; resolve %.
Cost optimization: model routing easy → mini, hard → frontier.
Multi-agent debate (Du 2023): N agent reasoning consensus.

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

Wu et al. - AutoGen (arxiv:2308.08155)
CrewAI documentation
LangGraph documentation (LangChain 2024)
Park et al. - Generative Agents (UIST 2023, arxiv:2304.03442)
Jimenez et al. - SWE-Bench (arxiv:2310.06770)
Du et al. - Improving Factuality and Reasoning via Multi-Agent Debate (arxiv:2305.14325)
Yao et al. - ReAct (ICLR 2023)
Anthropic Claude 3.5 Sonnet Computer Use docs

Prerequisiti tecnici

LLM API basics
LangChain / CrewAI / AutoGen
Docker sandboxing
Observability: Langfuse, LangSmith

Risorse correlate

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

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

In Breve

Fondamenti teorici e paper di riferimento

Outline

CrewAI: role-based pattern

AutoGen: conversation pattern

LangGraph: stateful workflow

Software engineering automation

Evaluation: SWE-Bench, HumanEval+

Safety, sandbox, observability

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

Sblocca contenuti esclusivi

Prova Questi Strumenti

Commenti

Discuti questo articolo nella community

Dataset pronti per i tuoi progetti

Ti è piaciuto questo articolo?

In Breve

Fondamenti teorici e paper di riferimento

Outline

CrewAI: role-based pattern

AutoGen: conversation pattern

LangGraph: stateful workflow

Software engineering automation

Evaluation: SWE-Bench, HumanEval+

Safety, sandbox, observability

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

Sblocca contenuti esclusivi

05 - Negoziazione e auction: Contract Net Protocol

04 - Comunicazione tra agenti: FIPA-ACL e protocolli

03 - JADE framework: implementare il primo agente

Commenti

Discuti questo articolo nella community

Dataset pronti per i tuoi progetti

Ti è piaciuto questo articolo?