Ecco la traduzione in italiano:
La maggior parte dei tutorial sugli agent Claude si ferma al "hello world".
Ti mostrano come far chiamare uno strumento a Claude. Come impostare un loop di base. Come ottenere una risposta autonoma su un semplice compito giocattolo.
Poi provi a costruire qualcosa di reale e tutto va in frantumi.
Il compito è troppo ambiguo. L'agente si blocca. Gli output sono inconsistenti. La sessione termina e nulla è stato salvato. Ricominci da capo la volta successiva.
Il divario tra un agente Claude che funziona in un tutorial e un agente Claude che funziona in produzione non è un divario nelle capacità di Claude.
È un divario nel modo in cui l'agente è stato progettato.
Questa guida colma quel divario completamente.
Alla fine avrai un agente Claude che esegue un flusso di lavoro reale in modo affidabile. Non una demo. Non un compito giocattolo. Un flusso di lavoro che produce output consistenti, gestisce i casi limite con eleganza, migliora nel tempo e funziona senza che tu debba avviare ogni passaggio.
Cosa Rende Diverso un Agente del Mondo Reale
Prima di costruire qualsiasi cosa, capisci cosa separa un agente del mondo reale da un agente da tutorial.
Un agente da tutorial esegue un compito pulito con input puliti e produce un output pulito. Il compito è ben definito. Gli input vengono forniti nel formato esatto previsto. Non succede nulla di inaspettato. Il successo è binario e ovvio.
Un agente del mondo reale esegue compiti disordinati con input disordinati e deve comunque produrre output utili. Il compito è parzialmente definito. Gli input arrivano in formati che variano. Cose inaspettate accadono regolarmente. Il successo è una questione di grado e richiede giudizio per essere valutato.
Quattro proprietà determinano se un agente sopravvive al contatto con il mondo reale:
Definizione del compito robusta. L'agente sa non solo cosa fare, ma come gestire le venti varianti del compito che incontrerà nella pratica. Le istruzioni coprono i casi limite, non solo il percorso felice.
Memoria persistente. L'agente accumula contesto attraverso le sessioni. Il lavoro fatto la settimana scorsa informa il lavoro che fa oggi. Non ricomincia da zero ogni sessione.
Gestione elegante degli errori. Quando qualcosa va storto, l'agente si riprende invece di fermarsi. Registra cosa è successo, prova alternative e avvisa un umano solo quando il recupero è impossibile.
Auto-verifica della qualità. L'agente controlla i propri output rispetto a standard definiti prima di consegnarli. Chiude il proprio ciclo di feedback invece di restituire qualunque cosa abbia prodotto per primo.
La maggior parte degli agenti da tutorial non ha nessuna di queste proprietà. Questa guida costruisce tutte e quattro.
L'Architettura dell'Agente
L'architettura ha quattro componenti che lavorano insieme.
Il Livello di Definizione del Compito
Un file di skill strutturato che definisce il compito, il processo, la gestione dei casi limite e lo standard di qualità. Non è un prompt. È una specifica operativa completa che l'agente legge prima di ogni esecuzione.
Il Livello di Memoria
Un database persistente che memorizza cosa l'agente ha fatto, cosa ha imparato e cosa deve ricordare tra una sessione e l'altra. Costruito su SQLite tramite Hermes Agent o implementato manualmente con logging basato su file.
Il Livello di Esecuzione
Le vere chiamate API Claude che fanno il lavoro. Strutturate per utilizzare il modello giusto, il contesto giusto e gli strumenti giusti per ogni passaggio del flusso di lavoro.
Il Livello di Qualità
Il ciclo di verifica che controlla gli output rispetto a standard definiti prima di consegnarli e riprova con correzioni specifiche quando gli output sono insufficienti.
Impostare le Fondamenta
Installa gli strumenti necessari:
Installa Hermes Agent per orchestrazione e memoria
git clone https://github.com/NousResearch/hermes-agent
cd hermes-agent
npm install
Installa i server MCP per l'accesso agli strumenti
npm install -g @modelcontextprotocol/server-filesystem
npm install -g @modelcontextprotocol/server-brave-search
Configura il tuo ambiente:
Configurazione principale
MODEL_PROVIDER=anthropic
MODEL_NAME=claude-opus-4-8
ANTHROPIC_API_KEY=la-tua-chiave-api-qui
Configurazione memoria — usa percorsi assoluti
MEMORY_BACKEND=sqlite
MEMORY_PATH=/Users/tuonome/agent-data/memory.db
Configurazione scheduler
ENABLE_SCHEDULER=true
SCHEDULER_TIMEZONE=America/New_York
Configurazione output — dove finiscono i risultati
OUTPUT_PATH=/Users/tuonome/agent-outputs
Ripristino errori
SKILL_RETRY_ENABLED=true
SKILL_RETRY_MAX=3
SKILL_RETRY_DELAY=300
Notifiche
NOTIFICATION_GATEWAY=telegram
TELEGRAM_BOT_TOKEN=il-tuo-token-bot
TELEGRAM_CHAT_ID=il-tuo-chat-id
Scrivi il CLAUDE.md:
Questo è il file più importante in tutta la configurazione. Ogni sessione dell'agente inizia leggendolo. La qualità di ogni output dipende dalla specificità di ciò che è scritto qui.
Configurazione Agente — CLAUDE.md
Identità e Scopo
[Descrivi cosa fa questo agente in un paragrafo specifico.
Non cosa fa Claude in generale. Cosa fa questo agente specifico
è configurato per fare per questa operazione specifica.]
Contesto Operativo
[Descrivi il contesto lavorativo o personale in cui
opera questo agente. Cosa fa la persona che ha configurato
questo agente? Quali sono i suoi standard e priorità?]
Compiti Attivi Correnti
[Elenca i compiti ricorrenti specifici che questo agente esegue.
Per ognuno: cosa fa, quando viene eseguito, come si presenta un buon output.]
Permessi degli Strumenti
Hai il permesso di utilizzare questi strumenti in modo autonomo:
- Filesystem: leggere e scrivere su [PERCORSI SPECIFICI]
- Ricerca web: per ricerche su [ARGOMENTI SPECIFICI]
- [Altri strumenti con ambito specifico]
Non devi:
- Scrivere in nessun percorso al di fuori della directory di output configurata
- Effettuare chiamate API esterne non elencate sopra
- Intraprendere alcuna azione che influisca su sistemi esterni senza approvazione esplicita
Standard di Qualità
[Descrivi come si presenta un buon output per ogni tipo di compito.
Includi esempi dove possibile.
Sii abbastanza specifico affinché l'agente possa autovalutarsi.]
Istruzioni di Memoria
Memorizza:
- Ogni output significativo con data e valutazione della qualità
- Ogni caso limite incontrato e come è stato gestito
- Ogni fallimento di qualità e cosa lo ha causato
- Ogni modello identificato tra gli output
Gestione degli Errori
In caso di fallimento dello strumento: riprova una volta, registra il fallimento, continua
con gli strumenti disponibili.
In caso di fallimento di qualità: riprova con correzioni specifiche,
non una riscrittura completa. Massimo tre tentativi.
In caso di fallimento irreversibile: salva il lavoro parziale,
registra il fallimento specifico, invia una notifica,
fermati con eleganza.
Costruire il Livello di Definizione del Compito
Il livello di definizione del compito è dove la maggior parte degli agenti del mondo reale fallisce.
Le persone scrivono un prompt che descrive il percorso felice e si fermano. L'agente gestisce bene il percorso felice e si rompe su tutto il resto.
Una definizione di compito robusta copre l'intera realtà operativa del compito. Ecco il template:
[NOME COMPITO]
Scopo
[Una frase: cosa realizza questa skill?]
Attivazione
[Condizioni esatte che causano l'esecuzione:
ora programmata, comparsa di un file, comando manuale, ecc.]
Controlli Pre-Esecuzione
Prima di iniziare, verifica:
- [L'input richiesto esiste ed è accessibile]
- [Gli strumenti richiesti sono connessi e rispondono]
- [Il percorso di output è scrivibile]
- [La memoria è accessibile e aggiornata]
Se un qualsiasi controllo fallisce: registra il fallimento e fermati.
Non procedere con prerequisiti mancanti.
Processo Principale
Passo 1: Caricamento del Contesto
Leggi CLAUDE.md per il contesto operativo completo.
Leggi la memoria per la cronologia pertinente taggata: [TAG-COMPITO]
Nota eventuali schemi dalle esecuzioni precedenti
che dovrebbero informare questa.
Passo 2: Elaborazione dell'Input
[Descrivi esattamente cosa fare con l'input.
Copri il formato primario E i formati alternativi
che si presentano nella pratica.]
Per il formato di input standard:
[Passaggi di elaborazione esatti]
Per il formato di input alternativo A:
[Come gestirlo]
Per il formato di input alternativo B:
[Come gestirlo]
Per input malformato o mancante:
[Come gestirlo — mai fallire in silenzio]
Passo 3: Esecuzione Principale
[Il lavoro effettivo della skill.
Dividi in sottopassaggi. Ogni sottopassaggio dovrebbe essere
abbastanza specifico che una nuova istanza di Claude
potrebbe eseguirlo senza contesto aggiuntivo.]
Passo 4: Verifica della Qualità
Prima di salvare l'output, verifica rispetto a questi standard:
RICHIESTO: [Proprietà dell'output non negoziabili]
PREFERITO: [Proprietà di qualità che migliorano l'output]
VIETATO: [Cose che non dovrebbero mai apparire nell'output]
Se l'output fallisce i controlli richiesti:
- Identifica specificamente cosa è fallito
- Riprova con una correzione mirata
- Massimo tre tentativi
- Se ancora fallisce dopo tre: salva con flag di fallimento
Passo 5: Output e Archiviazione
Salva l'output in: [PERCORSO SPECIFICO E FORMATO NOME FILE]
Memorizza nella memoria taggata: [TAG-COMPITO, DATA]
Aggiorna CLAUDE.md se qualche informazione corrente è cambiata.
Invia notifica: [COSA INCLUDERE NELLA NOTIFICA]
Casi Limite
[Nome Caso Limite 1]
Condizione: [Quando si verifica]
Rilevamento: [Come riconoscerlo]
Risposta: [Cosa fare]
[Nome Caso Limite 2]
Condizione: [Quando si verifica]
Rilevamento: [Come riconoscerlo]
Risposta: [Cosa fare]
[Nome Caso Limite 3]
Condizione: [Quando si verifica]
Rilevamento: [Come riconoscerlo]
Risposta: [Cosa fare]
Standard di Qualità
Un ottimo output: [Descrizione specifica]
Un output accettabile: [Soglia minima]
Un output inaccettabile: [Cosa dovrebbe attivare un nuovo tentativo]
Istruzioni di Memoria
Dopo ogni esecuzione, memorizza:
- Data e durata dell'esecuzione
- Valutazione della qualità dell'output (ottimo/accettabile/fallito)
- Eventuali casi limite incontrati e come sono stati gestiti
- Qualsiasi schema degno di nota per esecuzioni future
Il Tuo Primo Agente Reale: L'Agente di Ricerca e Briefing
Ecco un agente del mondo reale completo costruito usando questa architettura. Questo agente monitora quotidianamente un insieme di fonti, ricerca argomenti rilevanti per il tuo lavoro e fornisce un briefing strutturato ogni mattina.
Questo non è un compito giocattolo. È un flusso di lavoro reale che sostituisce quarantacinque minuti di compilazione manuale di ricerche ogni giorno.
Crea skills/research-brief.md:
research-brief
Scopo
Monitorare le fonti configurate e produrre un briefing
di intelligence strutturato che copra gli sviluppi rilevanti
per i progetti e le priorità correnti.
Attivazione
Programmato giornalmente alle 6:00.
Manuale: "Briefing di ricerca" o "Briefing mattutino"
Controlli Pre-Esecuzione
Prima di iniziare, verifica:
- CLAUDE.md è leggibile in 07-SYSTEM/CLAUDE.md
- Brave Search MCP sta rispondendo
- Il percorso di output è scrivibile in outputs/briefings/
- Il database di memoria è accessibile
Processo Principale
Passo 1: Caricamento del Contesto
Leggi completamente CLAUDE.md. Nota:
- Progetti attivi correnti e il loro stato
- Argomenti segnalati per il monitoraggio
- Eventuali decisioni in sospeso che necessitano di intelligence
- Standard di qualità per questo briefing
Leggi la memoria taggata: research-brief
Nota: cosa è stato coperto nei briefing recenti
per evitare ripetizioni.
Passo 2: Ricerca delle Fonti
Per ogni argomento nell'elenco di monitoraggio di CLAUDE.md:
Query di ricerca: "[ARGOMENTO] notizie ultime 24 ore"
Raccogli: titolo, fonte, data, affermazione chiave
Applica il filtro del segnale:
INCLUDI: Nuovo sviluppo, dato, lancio prodotto,
dichiarazione significativa, risultato di ricerca
ESCLUDI: Ripetizione di copertura esistente,
opinione senza nuove informazioni,
qualsiasi cosa coperta negli ultimi 3 briefing
Per ogni risultato che supera il filtro del segnale:
Ricerca più approfondita con una query di follow-up se
il risultato iniziale suggerisce uno sviluppo significativo.
Passo 3: Sintesi
Raggruppa i risultati per argomento.
Per ogni gruppo di argomenti identifica:
- Il singolo sviluppo più significativo
- Perché è importante per i progetti correnti
- Quale azione, se del caso, implica
Sintesi tra argomenti:
- Ci sono due o più risultati che si collegano per suggerire uno schema più ampio?
- Qualche risultato ha un impatto diretto su un progetto attivo o una decisione in sospeso?
Passo 4: Verifica della Qualità
Prima di finalizzare, verifica:
RICHIESTO:
- Minimo 3 elementi di segnale (non rumore)
- Ogni elemento basato su una fonte specifica
- Ogni elemento spiega la rilevanza per il lavoro corrente
- Nessun elemento ripetuto dagli ultimi 5 briefing
PREFERITO:
- Almeno una connessione tra argomenti
- Almeno un elemento che implica un'azione specifica
- Riconoscimento onesto se è stata una giornata senza notizie
VIETATO:
- Analisi generica senza prove specifiche
- Elementi interessanti ma non pertinenti
- Riempitivo per far sembrare il briefing più completo
Se il briefing fallisce i controlli richiesti: identifica specificamente
cosa manca e cerca fonti aggiuntive
prima di riprovare. Non riempire con segnali deboli.
Passo 5: Generazione dell'Output
Genera il briefing in questo formato esatto:
Briefing di Intelligence Mattutino — [DATA]
PIÙ IMPORTANTE OGGI
[Singolo sviluppo più significativo e perché è
importante per il lavoro corrente. Specifico. Fondato.]
ELEMENTI DI SEGNALE
[Argomento 1]
\\Sviluppo:\\ [Cosa è successo]
\\Fonte:\\ [Pubblicazione, data]
\\Rilevanza:\\ [Perché questo è importante per i progetti correnti]
\\Implicazione:\\ [Qualsiasi azione che questo suggerisce]
[Argomento 2]
[Stesso formato]
[Continua per ogni elemento di segnale]
CONNESSIONE
[Se due o più elementi si collegano per suggerire uno
schema più ampio, descrivilo qui. Salta se non c'è una connessione genuina.]
RILEVANZA PER LE DECISIONI
[Se un qualsiasi elemento è direttamente rilevante per una
decisione in sospeso in CLAUDE.md, segnalalo qui con dettagli specifici.]
NOTA DI COPERTURA
[Valutazione onesta: giornata completa / giornata senza notizie.
Numero di fonti cercate.]
Passo 6: Archiviazione e Notifica
Salva in: outputs/briefings/[DATA]-morning-brief.md
Memorizza nella memoria:
- Data: [OGGI]
- Elementi coperti: [ELENCO ARGOMENTI]
- Qualità: [ottimo/accettabile/fallito]
- Degno di nota: [Eventuali casi limite o schemi] Tag: research-brief
Invia notifica Telegram:
"Briefing mattutino pronto: [N] elementi di segnale.
[PIÙ IMPORTANTE OGGI in una riga]"
Casi Limite
Nessun Segnale Trovato per un Argomento
Condizione: Le ricerche non restituiscono nuovi sviluppi
Rilevamento: Tutti i risultati hanno più di 48 ore
Risposta: Nota "Nessun nuovo sviluppo" per quell'argomento.
Non inventare o riempire. Passa all'argomento successivo.
La Fonte Restituisce Informazioni Contrastanti
Condizione: Due fonti riportano fatti contraddittori
Rilevamento: Contraddizione diretta su un'affermazione specifica
Risposta: Riporta entrambe le versioni, cita entrambe le fonti,
segnala come contrastante. Non scegliere l'una sull'altra.
Strumento di Ricerca Non Disponibile
Condizione: Brave Search MCP non risponde
Rilevamento: La chiamata allo strumento restituisce un errore
Risposta: Registra il fallimento. Notifica tramite Telegram.
Salva il briefing parziale con nota: "Ricerca non disponibile —
briefing basato solo sul contesto della memoria."
Non fallire in silenzio.
Il Briefing Ripeterebbe l'Elemento Principale di Ieri
Condizione: Lo sviluppo più significativo è lo stesso di ieri
Rilevamento: Confronto incrociato con il briefing di ieri nella memoria
Risposta: Nota "Sviluppo in corso dal [DATA]"
e concentrati su ciò che è specificamente nuovo oggi.
Standard di Qualità
Briefing ottimo: 4-6 elementi di segnale. Ogni elemento pertinente.
Almeno un'idea trasversale. Si legge in meno di 5 minuti.
Briefing accettabile: 3 elementi di segnale. Tutti pertinenti.
Nessuna idea trasversale. Si legge in meno di 5 minuti.
Briefing inaccettabile: Meno di 3 elementi di segnale.
Qualsiasi elemento generico o non pertinente al lavoro corrente.
Qualsiasi elemento ripetuto dagli ultimi 3 briefing.
Costruire il Livello di Verifica della Qualità
Il livello di verifica della qualità è ciò che separa gli agenti che producono risultati consistenti dagli agenti che producono risultati variabili.
La maggior parte degli agenti salta completamente questo livello. Generano un output e lo restituiscono. La qualità dipende interamente da quanto è buona la generazione. Alcune sessioni sono eccellenti. Alcune sono mediocri. Non sai mai cosa otterrai.
Un livello di verifica della qualità rende la qualità dell'output consistente controllando ogni output rispetto a standard definiti e riprovando con correzioni specifiche quando gli standard non vengono soddisfatti.
Ecco il modello di chiamata API Claude che implementa la verifica della qualità:
async function executeWithQualityVerification(prompt, qualityStandard, maxRetries = 3) {
let attempt = 0;
let lastOutput = null;
let lastFailure = null;
while (attempt < maxRetries) {
// Genera l'output
const response = await fetch('https://api.anthropic.com/v1/messages', {
method: 'POST',
headers: {
'Content-Type': 'application/json',
'x-api-key': process.env.ANTHROPIC_API_KEY,
'anthropic-version': '2023-06-01'
},
body: JSON.stringify({
model: 'claude-opus-4-8',
max_tokens: 4096,
messages: [
{
role: 'user',
content: attempt === 0
? prompt
: \${prompt}
Il tentativo precedente ha fallito il controllo qualità: ${lastFailure}
Correggi specificamente per questo fallimento. Non riscrivere tutto.\
}
]
})
});
const data = await response.json();
lastOutput = data.content[0].text;
// Verifica la qualità
const verificationResponse = await fetch('https://api.anthropic.com/v1/messages', {
method: 'POST',
headers: {
'Content-Type': 'application/json',
'x-api-key': process.env.ANTHROPIC_API_KEY,
'anthropic-version': '2023-06-01'
},
body: JSON.stringify({
model: 'claude-opus-4-8',
max_tokens: 1000,
messages: [
{
role: 'user',
content: `Sei un controllore di qualità. Valuta questo output rispetto a questi standard:
${qualityStandard}
Output da valutare:
${lastOutput}
Rispondi SOLO con:
PASS se l'output soddisfa tutti gli standard richiesti
FAIL: [descrizione specifica di cosa è fallito] se non soddisfa gli standard richiesti
Non spiegare. Non suggerire miglioramenti. Solo PASS o FAIL con descrizione specifica del fallimento.`
}
]
})
});
const verificationData = await verificationResponse.json();
const verificationResult = verificationData.content[0].text.trim();
if (verificationResult.startsWith('PASS')) {
return { output: lastOutput, attempts: attempt + 1, passed: true };
}
lastFailure = verificationResult.replace('FAIL:', '').trim();
attempt++;
}
// Tutti i tentativi esauriti
return {
output: lastOutput,
attempts: maxRetries,
passed: false,
failure: lastFailure
};
}
Questo modello genera un output, lo controlla rispetto a standard definiti e riprova con correzioni specifiche quando fallisce. Se tutti i tentativi falliscono, restituisce l'output migliore con un flag di fallimento invece di crashare.
Il Modello di Integrazione della Memoria
La memoria è ciò che trasforma un agente capace in un agente che apprende.
Senza memoria, ogni sessione ricomincia da zero. L'agente non sa cosa ha fatto prima. Non può applicare gli apprendimenti dalle esecuzioni passate. Non può evitare errori che ha già commesso.
Con la memoria, ogni sessione si basa sulla precedente. L'agente sa cosa ha funzionato e cosa no. Applica il contesto accumulato per migliorare gli output correnti. Migliora nel compito specifico nel tempo.
Ecco il modello di integrazione della memoria per qualsiasi agente Claude:
All'inizio di ogni esecuzione:
Leggi le voci di memoria taggate: [TAG-COMPITO]
Limite: 20 voci più pertinenti
Strategia: pertinenza (non solo recenza)
Applica questo contesto:
- Nota schemi dalle esecuzioni precedenti
- Nota casi limite precedentemente incontrati
- Nota problemi di qualità precedentemente identificati
- Applica gli apprendimenti all'esecuzione corrente
Alla fine di ogni esecuzione:
Memorizza:
data: [OGGI]
compito: [NOME COMPITO]
qualità: [ottimo/accettabile/fallito]
degno di nota: [qualsiasi cosa valga la pena ricordare]
caso_limite: [eventuali casi limite incontrati]
schema: [qualsiasi schema osservato]
Tag: [TAG-COMPITO], [DATA]
Consolidamento mensile:
Leggi tutte le voci di memoria taggate: [TAG-COMPITO]
Identifica:
- Schemi che appaiono in più voci
- Casi limite che si ripresentano
- Problemi di qualità che si ripresentano
- Cosa è correlato a output ottimi vs accettabili
Consolida in una singola voce di contesto aggiornata
Archivia le voci individuali più vecchie di 90 giorni
Il Sistema di Recupero dagli Errori
Gli agenti del mondo reale incontrano errori. Le fonti vanno offline. Le API limitano la frequenza. I file non sono dove ci si aspetta. Gli output falliscono i controlli di qualità dopo il massimo dei tentativi.
Il sistema di recupero dagli errori determina se questi errori sono intoppi invisibili o arresti catastrofici.
Tre livelli di gestione degli errori:
Livello 1: Recupero Automatico
Errori transitori che si risolvono con un nuovo tentativo. Strumento non disponibile. Timeout di rete. Limite di frequenza raggiunto.
Protocollo di Recupero Livello 1
In caso di fallimento di qualsiasi chiamata a uno strumento:
- Attendere 60 secondi
- Riprovare la stessa identica chiamata
- Se il tentativo riesce: continua normalmente, registra l'intoppo
- Se il tentativo fallisce: passa al Livello 2
Livello 2: Degrado Graduale
Errori che non possono essere risolti ma consentono il completamento parziale. Una fonte non disponibile. Uno strumento che non risponde. Una sezione dell'output che fallisce i controlli di qualità.
Protocollo di Recupero Livello 2
In caso di errore parziale non risolvibile:
- Completa ciò che può essere completato
- Nota specificamente cosa è stato saltato e perché
- Segnala l'output come parziale nel nome del file
- Includi una nota esplicita nell'output stesso
- Invia notifica: "Output parziale — [motivo specifico]"
- NON far fallire l'intero compito perché un componente è fallito
Livello 3: Arresto Graduale
Errori che rendono l'intero compito impossibile. CLAUDE.md non trovato. Percorso di output non scrivibile. Database di memoria inaccessibile.
Protocollo di Recupero Livello 3
In caso di fallimento completo:
- Identifica il punto di fallimento specifico
- Salva qualsiasi lavoro completato in una posizione temporanea
- Registra il contesto completo del fallimento
- Invia notifica: "Compito fallito — [motivo specifico]"
- Fermati in modo pulito senza corrompere output esistenti
- NON riprovare automaticamente — attendi l'intervento umano
Testare il Tuo Agente Prima del Deploy
L'errore più comune nel deploy di un agente del mondo reale è saltare i test strutturati.
Tre fasi di test prima che un agente entri in funzione:
Fase 1: Test dei Componenti
Testa ogni componente isolatamente prima di testare l'intero flusso di lavoro.
Testa la persistenza della memoria
hermes chat
Qual è la voce di memoria più vecchia che hai memorizzato?
Previsto: Dovrebbe riportare una voce o segnalare database vuoto
Se restituisce errore: la configurazione della memoria è sbagliata
Testa l'accesso agli strumenti
Elenca i file in [PERCORSO OUTPUT]
Previsto: Dovrebbe elencare i file effettivi
Se restituisce errore: il filesystem MCP non è configurato correttamente
Testa la ricerca
Cerca "notizie AI oggi" e dimmi il primo risultato
Previsto: Dovrebbe restituire risultati di ricerca effettivi
Se restituisce errore: Brave Search MCP non è configurato correttamente
Fase 2: Test del Percorso Felice
Esegui la skill manualmente su un input standard pulito e verifica che l'output soddisfi lo standard di qualità.
Esegui la skill manualmente
hermes run research-brief
Controlla l'output
cat outputs/briefings/[OGGI]-morning-brief.md
Verifica rispetto allo standard di qualità:
- Minimo 3 elementi di segnale?
- Ogni elemento pertinente al lavoro corrente?
- Nessuna analisi generica?
- Si legge in meno di 5 minuti?
Fase 3: Test dei Casi Limite
Innesca deliberatamente ogni caso limite documentato e verifica il comportamento di recupero.
Test: nessun accesso a internet
Disabilita Brave Search in .env
Esegui la skill
Previsto: Fallimento Livello 3, arresto pulito, notifica inviata
Test: percorso di output non scrivibile
Cambia OUTPUT_PATH in una directory inesistente
Esegui la skill
Previsto: Fallimento Livello 3, arresto pulito, notifica inviata
Test: giornata senza notizie
Esegui durante un weekend o un giorno festivo
Previsto: Output Livello 2 con NOTA DI COPERTURA che indica giorno lento
Eseguire il Tuo Agente in Produzione
Una volta che tutte e tre le fasi di test sono superate, configura lo scheduler e passa alla produzione.
{
"schedules": [
{
"skill": "research-brief",
"cron": "0 6 \ \ *",
"description": "Ogni giorno alle 6:00",
"timeout_minutes": 15,
"on_failure": "notify_and_stop"
}
]
}
Avvia Hermes in modalità background:
npm run start -- --daemon
Verifica la prima esecuzione programmata:
Controlla i log dopo le 6:00
cat logs/hermes-[DATA].log
Controlla che l'output sia stato prodotto
ls outputs/briefings/
Controlla che la memoria sia stata aggiornata
hermes chat
Quante voci di memoria research-brief hai?
Se la prima esecuzione automatizzata produce un buon output, l'agente è in produzione.
Cosa Cambia al Terzo Mese
Mese uno: L'agente funziona in modo affidabile. Gli output sono consistenti. Gli errori sono gestiti con eleganza. Risparmi quarantacinque minuti ogni mattina.
Mese due: lo strato di memoria inizia a mostrare miglioramenti visibili. L'agente ha elaborato sessanta giorni di fonti e accumulato contesto su quali fonti producono contenuti ad alto segnale rispetto al rumore. La qualità del filtraggio del segnale migliora perché l'agente ha imparato quali fonti valeva la pena seguire.
Mese tre: il consolidamento della memoria è stato eseguito due volte. L'agente ha identificato schemi su novanta giorni di ricerca. I rapporti fanno riferimento a un contesto accumulato che li rende più fondati e più specifici di quanto qualsiasi ricerca in una singola sessione potrebbe produrre.
L'agente al terzo mese non sta eseguendo lo stesso flusso di lavoro del primo mese.
Sta eseguendo una versione migliorata di quel flusso di lavoro, basata su novanta giorni di intelligenza operativa accumulata.
Questa è la differenza tra un agente da tutorial e un agente del mondo reale.
L'agente da tutorial esegue il compito.
L'agente del mondo reale impara a eseguire il compito meglio.
Costruisci le fondamenta questo fine settimana.
Eseguilo per una settimana. Ripara ciò che si rompe.
Eseguilo per un mese. Osservalo migliorare.
Eseguilo per tre mesi. Nota ciò che sa e che non avresti potuto dirgli il primo giorno.
Ecco come si presenta la creazione di un agente Claude che funziona davvero nel mondo reale.
Segui @cyrilXBT per ogni architettura di agente, modello di competenza e schema di distribuzione in produzione che fa sì che i tuoi agenti Claude sopravvivano al contatto con il mondo reale.
