Come creare sciami di agenti AI (Guida completa)

Ecco la traduzione in italiano del testo fornito, seguendo tutte le linee guida specificate.

Questa è una guida A–Z completa sugli AI Agent Swarm: cosa sono e come usarli.

Il motivo per cui cambiano tutto il tuo modo di lavorare con l'IA.

Aggiungilo ai segnalibri prima che te ne dimentichi.

Kimi K2.6, il modello open-weight di punta di Moonshot AI dell'aprile 2026, è l'implementazione open-source più seria di questa idea che abbia mai visto.

I compiti reali hanno ampiezza. Cinquanta aziende da ricercare.

Duecento file da analizzare. Una dozzina di sotto-attività che non dipendono l'una dall'altra e non dovrebbero aspettare in fila dietro le altre. Un agent swarm è l'architettura per questo.

Questa guida analizza come funziona, dall'infrastruttura di training fino all'API, per poi concentrarsi sul pattern che ritengo più importante in questo momento: Kimi per l'esecuzione, Claude Opus 4.8 per la pianificazione e la verifica.

Ecco come appare il flusso di lavoro finale.

Sezione 1: Cos'è un agent swarm?

Un agent swarm è costituito da più agenti che lavorano simultaneamente su sotto-attività scomposte, coordinati da un orchestratore che aggrega i risultati.

La distinzione da una catena sequenziale è il punto centrale:

• Catena sequenziale: L'agente A viene eseguito, passa il testimone a B, B lo passa a C. Tempo totale = A + B + C.
• Swarm: L'orchestratore suddivide l'obiettivo, gli agenti A, B, C vengono eseguiti contemporaneamente su sotto-attività indipendenti, i risultati vengono unificati. Tempo totale ≈ max(A, B, C).

Quando un'attività ha una struttura genuinamente parallela, questa è la differenza tra minuti e ore.

Uno swarm risolve anche il problema del contesto troppo lungo (context overflow). Un singolo agente su un'attività lunga accumula token fino a sommergere la sua finestra. Uno swarm fornisce a ogni sotto-attività il proprio contesto limitato e solo output strutturati fluiscono di ritorno all'orchestratore.

I sei mattoni fondamentali

Ogni swarm ha gli stessi componenti principali:

Componente

Cosa Fa

Orchestratore

Scompone il compito, assegna le sotto-attività, monitora l'esecuzione, aggrega i risultati

Sotto-agenti

Lavoratori specializzati in un dominio (ricerca, codice, analisi, scrittura)

Strumenti

Funzioni che gli agenti possono chiamare: ricerca web, interprete di codice, I/O file, API

Memoria

Stato condiviso che lo swarm può leggere/scrivere

Passaggi / Routing

Meccanismo per trasferire il controllo o i dati tra agenti

Barriere di protezione

Limiti di iterazione, timeout, trigger per intervento umano, recupero errori

Se questi sei elementi sono corretti, hai uno swarm. Se ne sbagli uno solo, hai una costosa sessione di debug.

Sezione 2: Cos'è realmente Kimi K2.6

Prima di addentrarci nel comportamento dello swarm, vale la pena capire cosa c'è sotto. K2.6 è un modello Mixture-of-Experts da 1 trilione di parametri di Moonshot AI, rilasciato con pesi aperti il 20 aprile 2026 sotto una Licenza MIT Modificata. L'uso commerciale è gratuito al di sotto di 20 milioni di dollari di fatturato mensile o 100 milioni di utenti attivi mensili - quindi è praticamente gratuito per la maggior parte degli sviluppatori.

0:29

Specifiche dell'architettura

Specifica

Valore

Parametri totali

~1,04 trilioni

Attivati per token

~32 miliardi (8 esperti selezionati + 1 condiviso)

Esperti totali

384, distribuiti su 61 strati del trasformatore

Finestra di contesto

262.144 token (262K)

Attenzione

Multi-Head Latent Attention (MLA) - impronta KV cache ridotta

Funzione di attivazione

SwiGLU

Encoder visivo

MoonViT-3D (400M parametri, immagini + video fino a 2K)

Quantizzazione

INT4 tramite Quantization-Aware Training (~594 GB su disco)

Dimensione totale peso FP16

~2 TB

Licenza

MIT Modificata

La variante INT4 QAT funziona nativamente su 4x H100 80GB. La FP16 necessita di 8x H100 80GB. Tutti e tre i framework di inferenza supportati (vLLM, SGLang, KTransformers) espongono API compatibili con OpenAI.

Sezione 3: L'ottimizzatore MuonClip, ovvero perché il training è stabile

Addestrare un MoE sparso da un trilione di parametri senza che esploda è difficile. La modalità di fallimento specifica: all'aumentare della lunghezza della sequenza, il prodotto scalare query-key (QK) negli strati di attenzione può crescere senza limiti. Si verificano picchi di perdita (loss spikes), e a questa scala un picco di perdita può essere irreversibile.

Il documento tecnico di Kimi K2 (arxiv: 2507.20534) introduce MuonClip per gestire questo problema.

Muon è un ottimizzatore di gradienti più efficiente in termini di token rispetto ad AdamW. Stessa qualità, meno passaggi di training. Il problema: Muon da solo produce instabilità dell'attenzione alla scala del trilione di parametri.

QK-Clip aggiunge un ritaglio (clipping) per token e per testa direttamente sulle matrici QK prima del softmax. Questo limita la grandezza del punteggio di attenzione ed elimina la patologia dell'esplosione. Nessuna regolazione manuale, nessun trucco sul tasso di apprendimento.

Dall'abstract del documento:

"Presentiamo MuonClip, un nuovo ottimizzatore che integra l'algoritmo Muon, efficiente in termini di token, con un meccanismo di miglioramento della stabilità chiamato QK-Clip... Utilizzando MuonClip, Kimi K2 raggiunge prestazioni competitive richiedendo significativamente meno token di training rispetto alle baseline di AdamW."

Perché uno sviluppatore dovrebbe preoccuparsi di un dettaglio del training? Perché il motivo per cui K2.6 può sostenere 4.000 chiamate a strumenti per oltre 12 ore senza degradarsi risale proprio a questo. Un modello addestrato con instabilità dell'attenzione tende ad allucinare in condizioni di contesto lungo e alto numero di passaggi. Che è esattamente il regime in cui vive un Agent Swarm.

Sezione 4: PARL, la ricerca alla base dello swarm

L'Agent Swarm non è un framework applicato sopra a K2.6. Il comportamento è stato addestrato nel modello, attraverso un paradigma che Moonshot chiama PARL: Parallel-Agent Reinforcement Learning, descritto nel documento tecnico di Kimi K2.5 (arxiv: 2602.02276).

Orchestratore addestrabile, sotto-agenti congelati

Il modo usuale di costruire sistemi multi-agente è coordinare più istanze live del modello a livello applicativo. Poi l'assegnazione del credito (credit assignment) diventa un problema: quale dei tuoi agenti ha reso la risposta finale buona o cattiva? Addestrare end-to-end attraverso quel grafo è computazionalmente intrattabile.

PARL lo aggira:

• L'orchestratore è addestrabile, aggiornato tramite RL sui reward di risultato
• I sotto-agenti sono congelati, checkpoint di policy intermedi fissi

Le traiettorie dei sotto-agenti vengono trattate come osservazioni ambientali, non come punti decisionali differenziabili. Questo disaccoppia due problemi difficili contemporaneamente. Il credito va solo alle azioni dell'orchestratore, mai a 300 sotto-agenti simultanei. E il training rimane stabile perché viene aggiornato un solo modello.

L'orchestratore impara quando parallelizzare, quanti sotto-agenti generare e come dividere il lavoro. Nessuno ha specificato manualmente questi comportamenti. Emergono dalla massimizzazione del reward.

La funzione di reward in tre parti

L'orchestratore si allena su tre segnali:

Un reward di parallelismo lo spinge a generare sotto-agenti concorrenti piuttosto che eseguire le cose in sequenza. Senza questo, il modello di default usa un agente alla volta: sicuro, prevedibile, lento.

Un reward di completamento assicura che i sotto-agenti portino effettivamente a termine i loro compiti. Questo blocca il "parallelismo spurio", in cui l'orchestratore genera una moltitudine di agenti inattivi solo per ottenere il reward di parallelismo.

Un reward di prestazione valuta la qualità dell'output finale rispetto all'obiettivo del compito. Questa è la verità di base a cui tutto il resto serve.

Il dettaglio che trovo più interessante: la metrica di ottimizzazione sono i passaggi critici (lunghezza del percorso critico), non i passaggi totali. Il modello viene premiato per aver accorciato la catena di dipendenze più lunga, non per aver massimizzato la concorrenza grezza. Questa è la cosa che riduce effettivamente il tempo a muro.

Risultati PARL

• BrowseComp: La modalità Swarm ha raggiunto il 78,4% su K2.5, un guadagno assoluto di 17,8 punti rispetto al singolo agente K2.5 (60,6%), che all'epoca superava GPT-5.2 Pro (77,9%). K2.6 spinge questo risultato all'86,3%.
• WideSearch: Miglioramento assoluto di 6,3 punti su Item-F1 (dal 72,7% al 79,0%)
• Tempo a muro: Riduzione di 3-4,5x su compiti parallelizzabili rispetto alla baseline a singolo agente
• Chiamate parallele a strumenti: Fino a 4.000 passaggi coordinati in K2.6

Sezione 5: Mooncake, l'infrastruttura dietro Kimi

L'infrastruttura di servizio (serving) di Moonshot spiega perché K2.6 può sostenere 300 agenti paralleli senza fondersi. I pesi del modello sono solo metà della storia; il sistema che li serve è l'altra metà.

L'infrastruttura è ben strutturata per compiti a contesto lungo

Architettura disaggregata incentrata su KVCache

La piattaforma di servizio di Moonshot si chiama Mooncake, descritta nel loro documento sull'infrastruttura del 2024 (arxiv: 2407.00079). È il motore che fa funzionare Kimi su larga scala, e la sua scelta progettuale è insolita.

L'inferenza LLM tradizionale esegue prefill (elaborazione del prompt di input) e decode (generazione di token) sulle stesse istanze GPU. Mooncake le disaggregra in cluster separati:

• Cluster di prefill: gestisce l'elaborazione iniziale del prompt, si scala indipendentemente per input a contesto lungo
• Cluster di decode: gestisce la generazione di token, ottimizzato per produttività e latenza

La KV cache, lo stato intermedio di attenzione che rende efficiente la generazione autoregressiva, viene gestita come una risorsa di sistema di prima classe. Mooncake costruisce una KV cache distribuita che si estende su VRAM GPU, DRAM CPU e SSD, con un motore di trasferimento personalizzato che sposta la cache tra i nodi.

Perché questo è importante per Agent Swarm

Quando 300 sotto-agenti vengono eseguiti simultaneamente, ognuno genera la propria KV cache. In un'architettura tradizionale, ciò significa un'enorme pressione sulla memoria GPU e conflitti di schedulazione. Con la cache disaggregata di Mooncake:

• Le KV cache dei sotto-agenti completati possono essere spostate in DRAM o SSD e richiamate se necessario
• Il cluster di prefill gestisce i prompt di sistema (spesso grandi) per ogni sotto-agente in modo indipendente
• Lo scheduler massimizza la produttività complessiva rispettando gli SLO di latenza per ogni agente

Dal documento Mooncake: "Rispetto al metodo di base, Mooncake può ottenere un aumento della produttività fino al 525% in alcuni scenari simulati, rispettando al contempo gli SLO. Sotto carichi di lavoro reali, l'architettura innovativa di Mooncake consente a Kimi di gestire il 75% di richieste in più."

Il documento aggiornato riporta che Mooncake è "operativo su migliaia di nodi, elaborando oltre 100 miliardi di token al giorno", e gestisce il 115% di richieste in più su cluster A800 e il 107% in più su cluster H800 rispetto ai sistemi precedenti.

Disaggregazione PD su larga scala: il deployment K2 con 128 GPU

LMSYS ha pubblicato un caso di studio di deployment per Kimi K2 che utilizza la Disaggregazione Prefill-Decode (PD) su 128 GPU H200 tramite il Router SGLang. L'architettura:

• Router SGLang: servizio leggero per la scoperta dinamica dei nodi di prefill e decode tramite selettori di etichetta
• Parallelismo degli esperti: i 384 esperti di K2 distribuiti tra i nodi, con routing a livello di rete
• OME (Open Model Engine): orchestrazione nativa Kubernetes per il livello di servizio

Questa è la pila che fa funzionare la famiglia K2 su scala di produzione. Se stai ospitando K2.6 da solo, questo è il tuo modello di riferimento.

Sezione 6: Come funziona Agent Swarm, passo dopo passo

La sequenza meccanica quando K2.6 esegue un compito in modalità swarm:

Passo 1: Scomposizione del compito

L'orchestratore analizza il compito e costruisce il grafo delle dipendenze: quali sotto-attività sono indipendenti e possono essere eseguite in parallelo, quali dipendono da output precedenti.

Per "ricercare 100 aziende YC e produrre un'analisi di settore", l'orchestratore identifica 100 compiti di ricerca indipendenti, poi 1 compito di aggregazione, poi 1 compito di sintesi. Il primo strato è completamente parallelizzabile.

Passo 2: Generazione di agenti specializzati

L'orchestratore genera sotto-agenti specializzati per dominio in base al tipo di sotto-attività. K2.6 istanzia agenti dinamicamente con istruzioni specifiche per il ruolo e accesso mirato agli strumenti:

• Agenti di ricerca web: strumenti di ricerca + browser
• Agenti di analisi dati: esecuzione Python + strumenti per fogli di calcolo
• Agenti di scrittura: sintesi e generazione di documenti
• Agenti di fact-checking: verifica incrociata e validazione

Ogni sotto-agente opera all'interno del proprio contesto locale limitato. Gestisce un compito ben definito, produce output strutturato e termina. Il contesto locale non contiene tutto ciò che sa l'orchestratore, solo ciò di cui quel sotto-agente ha bisogno. È così che K2.6 evita di sovraccaricarsi su compiti che riempirebbero la finestra di un singolo agente in pochi minuti.

Passo 3: Esecuzione parallela a ondate

Gli agenti eseguono a ondate. La prima ondata gestisce i compiti completamente indipendenti.

1. Man mano che i risultati arrivano, l'orchestratore lancia una seconda ondata sui compiti che dipendevano dagli output della prima ondata, e così via finché il grafo delle dipendenze non si risolve.
2. K2.6 supporta fino a 300 sotto-agenti e 4.000 passaggi coordinati per sessione. L'orchestratore monitora l'esecuzione in tempo reale, rileva gli agenti falliti o bloccati e riassegna automaticamente i loro compiti.
3. Questa tolleranza ai guasti è ciò che rende possibili esecuzioni autonome di oltre 12 ore senza un umano a supervisionare.

Passo 4: Aggregazione e output

Una volta che tutti i sotto-agenti hanno completato, l'orchestratore aggrega i risultati in un prodotto finale: documento, foglio di calcolo, sito web, presentazione di diapositive.

• Sintetizza gli output degli agenti piuttosto che concatenarli, quindi il risultato è strutturalmente coerente.
• Un'altra cosa degna di nota: la struttura dello swarm è anche la risposta di Kimi al problema della finestra di contesto.
• La politica esplicita di K2.6: "una volta che la finestra di contesto supera la soglia, viene conservato solo il giro più recente di messaggi relativi agli strumenti." Lo swarm rende questa politica sostenibile su orizzonti temporali molto lunghi.

Sezione 7: L'architettura Kimi x Claude Opus 4.8

Nessun singolo modello è la risposta giusta per ogni livello di uno swarm. Kimi K2.6 è costruito per la scala orizzontale - esecuzione parallela su centinaia di agenti, esecuzioni autonome lunghe, elaborazione in blocco economicamente vantaggiosa.

Claude Opus 4.8 è costruito per il giudizio - pianificazione, ragionamento sfumato e individuazione dei propri errori. Si complementano strutturalmente, e il divario che ciascuno lascia è vicino alla forma del punto di forza dell'altro.

Il pattern:

1[Obiettivo Utente]
2      |
3[Claude Opus 4.8 - Pianificatore]
4  Scompone l'obiettivo in una specifica di compito strutturata
5  Identifica sotto-attività parallele vs. sequenziali
6  Definisce i criteri di successo per ogni sotto-attività
7      |
8[Kimi K2.6 Agent Swarm - Esecutore]
9  Riceve la specifica di compito strutturata
10  Genera fino a 300 sotto-agenti specializzati
11  Esegue in parallelo attraverso chiamate a strumenti
12  Restituisce risultati strutturati
13      |
14[Claude Opus 4.8 - Verificatore]
15  Rivede gli output di Kimi rispetto ai criteri di successo
16  Segnala fallimenti, lacune, incongruenze
17  Sintetizza il prodotto finale

Perché Claude per la pianificazione e la verifica?

Il cambiamento più sottovalutato in Opus 4.8 è il miglioramento nell'onestà: "Opus 4.8 ha circa quattro volte meno probabilità del suo predecessore di lasciare passare inosservati i difetti nel codice che ha scritto." Nei sistemi agentici, la falsa fiducia è la modalità di fallimento catastrofica.

• Un orchestratore che dice "completato" quando non lo è farà cascare errori su 300 agenti a valle. La tendenza di Claude a segnalare l'incertezza e a individuare i propri errori durante il compito lo rende l'ancora giusta per gli strati in cui sbagliare è costoso.
• Opus 4.8 supporta anche una finestra di contesto di 1 milione di token, il che è importante per la fase di verifica quando si estraggono output da 50+ agenti di ricerca paralleli in un unico contesto di revisione.

Perché Kimi per l'esecuzione?

L'Agent Swarm di K2.6 supporta fino a 300 sotto-agenti paralleli e 4.000 passaggi di strumenti coordinati per sessione - questo è un comportamento addestrato, non un wrapper a livello applicativo.

• Claude ha una funzionalità Dynamic Workflows in Claude Code, ma è attualmente in anteprima di ricerca e limitata ai piani Enterprise/Max.
• La capacità swarm di Kimi è disponibile per tutti tramite API in questo momento. Anche l'economia dei token è importante su larga scala: K2.6 costa $0,95/$4,00 per milione di token di input/output. Per l'esecuzione parallela in blocco, non è irrilevante.

Sezione 8: Quando hai bisogno di uno swarm (e quando no)

L'errore più comune nella progettazione multi-agente: aggiungere la complessità dello swarm prima di aver raggiunto il limite del singolo agente.

Rimani con un singolo agente quando:

• Il compito rientra in una singola finestra di contesto (sotto ~50K token di lavoro effettivo)
• Il compito è di natura sequenziale, ogni passo dipende dal precedente
• Stai ancora prototipando - le modalità di fallimento del singolo agente sono molto più facili da debuggare
• Il compito verrebbe comunque completato in meno di 10 minuti

Ricorri ad Agent Swarm quando:

• Il compito ha n sotto-attività parallele e indipendenti dove n > 5
• Il contesto troppo lungo è un problema reale (ricerca approfondita, basi di codice grandi, operazioni batch)
• Hai bisogno di agenti specializzati per dominio che lavorino simultaneamente
• Il compito è troppo lungo per mantenere la qualità attraverso una singola sessione sequenziale
• Vuoi un agente critico o verificatore che controlli il lavoro di un altro agente

Usa l'ibrido Kimi + Claude Opus 4.8 quando:

• La qualità della pianificazione è importante e vuoi un modello che opponga resistenza se il piano è sbagliato
• L'output viene spedito senza ulteriore revisione umana - quindi la verifica deve essere integrata
• Stai eseguendo un volume elevato di elaborazioni dove i costi dei token si accumulano rapidamente
• Vuoi il giudizio di Claude sugli strati decisionali e la scala di Kimi sugli strati operativi

Sezione 10: I quattro pattern architetturali dello swarm

Pattern 1: Orchestratore-lavoratore (il più comune)

Un orchestratore centrale assegna sotto-attività ai lavoratori, i lavoratori eseguono in parallelo, i risultati vengono aggregati.

1[Obiettivo Utente]
2    |
3[Orchestratore - Claude Opus 4.8]
4    +-- [Lavoratore: Agente di Ricerca Kimi x N]
5    +-- [Lavoratore: Agente Dati Kimi x N]
6    +-- [Lavoratore: Agente Codice Kimi x N]
7    |
8[Sintetizzatore - Claude Opus 4.8]
9    |
10[Output Finale]

Ideale per: compiti con sotto-attività chiaramente separabili e un numero variabile di lavoratori.

Pattern 2: Ciclo critico-revisore

Un agente produce, un altro critica, si ripete finché non viene raggiunta la soglia di qualità.

1[Costruttore Kimi K2.6] -> bozza -> [Critico Claude Opus 4.8] -> feedback -> [Costruttore Kimi K2.6]
2                                        |
3                                   (approvato)
4                                [Output Finale]

Ideale per: generazione di codice, scrittura tecnica, output sensibili alla conformità. Imposta sempre un limite massimo di iterazioni.

Pattern 3: Gerarchico

Un orchestratore strategico gestisce orchestratori di dominio, che gestiscono i lavoratori.

1[Claude Opus 4.8 - Orchestratore Strategico]
2    +-- [Kimi K2.6 Swarm - Team di Ricerca (50 agenti)]
3    +-- [Kimi K2.6 Swarm - Team di Costruzione (50 agenti)]

Ideale per: flussi di lavoro aziendali di grandi dimensioni con domini distinti.

Pattern 4: Gruppi Claw (swarm eterogeneo nativo Kimi)

K2.6 coordina agenti che eseguono qualsiasi modello, inclusi modelli locali, Claude e GPT, insieme a lavoratori umani in uno spazio operativo condiviso. Attualmente in anteprima di ricerca.

1[Coordinatore Kimi K2.6]
2    +-- [Claude Opus 4.8 - specialista del ragionamento]
3    +-- [Llama 3.3 locale - compiti batch sensibili ai costi]
4    +-- [Agenti Kimi K2.6 x N - strato di esecuzione]
5    +-- [Revisore umano - punti di controllo per approvazione]

Ideale per: flussi di lavoro che necessitano di diversità di modelli, ibrido locale + cloud, o requisiti di intervento umano nel ciclo.

Sezione 12: Progettazione dei prompt per compiti swarm

Il prompt di scomposizione (orchestratori)

1Sei un architetto di compiti. Scomponi questo obiettivo in sotto-attività indipendenti e parallelizzabili.
2
3Regole:
4- Ogni sotto-attività deve essere completabile da un singolo agente specializzato in isolamento
5- Le sotto-attività con dipendenze devono essere contrassegnate con la loro catena di dipendenze
6- Output in JSON: {task_id, description, agent_type, depends_on, success_criteria}
7
8Obiettivo: {user_goal}
9Tipi di agente disponibili: researcher, analyst, coder, writer, verifier

Il prompt di sistema specializzato (sotto-agenti)

1Sei un agente {RUOLO} specializzato in {DOMINIO}.
2
3Compito: {subtask_description}
4
5VINCOLI:
6- Restituisci SOLO JSON valido corrispondente a: {output_schema}
7- Non andare oltre l'ambito del tuo compito
8- Se non puoi completare il compito: {"error": "reason", "partial_results": [...]}
9- Numero massimo di chiamate a strumenti: {max_tool_calls}
10
11Contesto: {context_from_orchestrator}

Il prompt di aggregazione (sintetizzatori)

1Sintetizza la ricerca di {n} agenti specializzati in un output coerente.
2
31. Leggi tutti gli output degli agenti forniti
42. Identifica dove concordano, discordano o hanno lacune
53. Produci un {output_type} integrando tutti i risultati
64. Evidenzia esplicitamente le incongruenze - non risolvere silenziosamente le contraddizioni
7
8Output degli agenti: {agent_outputs_as_json}
9Formato output: {final_output_spec}

Sezione 13: Le sette barriere di protezione non negoziabili

1. Numero massimo di iterazioni per agente. Limite rigido sui cicli prima che l'orchestratore venga notificato.

2. Timeout di sessione. Se lo swarm non è stato completato in N minuti, termina e restituisci risultati parziali.

3. Imposizione di output strutturato. Forza gli agenti a restituire JSON. La prosa dagli agenti intermedi crea errori di parsing a valle.

4. Isolamento dei fallimenti. Un sotto-agente che fallisce non deve far crashare l'orchestratore.

1async def run_subagent_safely(kimi_client, task, agent_id):
2    try:
3        result = kimi_client.chat.completions.create(
4            model="kimi-k2.6",
5            messages=[{"role": "user", "content": task}],
6            max_tokens=4096
7        )
8        return {"agent_id": agent_id, "status": "success",
9                "output": result.choices[0].message.content}
10    except Exception as e:
11        return {"agent_id": agent_id, "status": "failed", "error": str(e)}

5. Riprova con backoff esponenziale. Gestisci errori 429 ed errori transitori senza presentarli come fallimenti permanenti.

6. Punti di controllo per intervento umano. Per swarm con permessi di scrittura (distribuzione di codice, invio di email, mutazioni API), inserisci pause di approvazione obbligatorie.

7. Monitoraggio dei costi. Imposta budget di token per esecuzione. I loop infiniti si manifestano come anomalie di costo prima di manifestarsi come fallimenti di qualità, sempre.

Cosa costruire per primo

Inizia con la pipeline a tre agenti della Sezione 9. È abbastanza piccola da debuggare in un pomeriggio, mette in pratica pianificazione, esecuzione parallela e verifica, e puoi eseguirla su un compito reale in meno di un'ora di configurazione.

Quando si rompe - e lo farà - la modalità di fallimento ti insegnerà di più sulla progettazione dello swarm di un'altra ora di lettura.

Costruiscila. Rompila di proposito. Poi torna ai pattern della Sezione 11 con un punto di riferimento concreto.

L'architettura non è la parte difficile. La parte difficile è il divario tra "funziona in fase di test" e "funziona alle 3 di notte senza che nessuno guardi", e quel divario risiede interamente nelle barriere di protezione, nell'osservabilità e nella progettazione della memoria.

Conclusione

Kimi 2.6 è una rivoluzione per gli agenti su come l'apprendimento per rinforzo possa stabilire sciami di agenti.

Mostra anche come orizzonti di contesto lunghi possano fare uso di tali infrastrutture basate su orchestratore, che permettono di generare molteplici sotto-agenti per costruire sistemi complessi utilizzando un unico

Disclaimer

L'articolo è stato scritto utilizzando la documentazione tecnica di Kimi 2.6 e documenti di ricerca nelle note dell'autore, e modificato da un'IA, Opus 4.7.