Cosa rende agentico un sistema
Autonomia, utilizzo degli strumenti e processo decisionale iterativo.
Cosa rende agentico un sistema è una lezione Claude Architect gratuita su CoddyKit. Questa è la lezione 1 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Claude Architect, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Claude Architect include 4 lezioni in totale.
Che cos'è un sistema agentico?
Un programma normale segue uno script fisso. Un sistema agentico è diverso: gli date un obiettivo e il modello decide i passaggi necessari per raggiungerlo.
Tre proprietà rendono agentico un sistema:
- Autonomia — il modello sceglie cosa fare dopo, non il vostro codice.
- Uso dei tool — può agire sul mondo esterno (cercare, leggere file, chiamare API).
- Iterazione — ripete il ciclo: agisce, osserva il risultato e decide di nuovo.
Nel percorso Claude Certified Architect, queste tre idee sono al centro di Agent Architecture & Orchestration, il dominio d'esame più ampio (27%).
Il modello non mantiene alcuno stato
Ogni chiamata alla Claude API è stateless. Il modello non ricorda nulla tra un turno e l'altro. Dovete inviare la cronologia completa dei messaggi a ogni turno.
Una richiesta contiene questi campi:
model— quale modello Claude utilizzare.max_tokens— il limite dell'output.system— istruzioni e ruolo.messages— l'intera conversazione fino a quel momento.tools— ciò che il modello può chiamare.
Poiché non esiste memoria nascosta, siete voi a gestire il ciclo che nel tempo fa crescere messages. È questo ciclo a trasformare una singola risposta in un comportamento agentico.
import anthropic
client = anthropic.Anthropic()
messages = [{"role": "user", "content": "Check today's open orders."}]
response = client.messages.create(
model="claude-opus-4-8",
max_tokens=1024,
system="You are an operations assistant.",
messages=messages, # the FULL history, every single turn
tools=TOOLS,
)Autonomia: decisioni guidate dal modello
Il cuore dell'autonomia è semplice: il modello decide, il vostro codice esegue.
Non codificate in modo rigido "prima cerca, poi riassumi, infine rispondi". Descrivete l'obiettivo e i tool disponibili, e Claude determina il percorso, compreso il momento in cui ha raccolto informazioni sufficienti per rispondere.
Riservate la logica codificata in modo rigido a ciò che dovete garantire (un limite per i rimborsi, una verifica dell'identità). Tutto il resto è una decisione del modello. Definire in anticipo ogni passaggio vanifica lo scopo stesso di creare un agent.
Uso dei tool: agire sul mondo
L'autonomia è inutile se il modello può solo parlare. I tool permettono a Claude di compiere azioni reali: cercare un cliente, leggere un file, eseguire una query.
Dichiarate ogni tool con un name, una description e un input_schema. La descrizione è il principale meccanismo di selezione: Claude la legge per decidere quando il tool è applicabile. I nomi contano molto meno.
Una buona descrizione indica lo scopo, i valori restituiti, i formati di input e i casi limite. Mantenete ogni agent focalizzato: 4-5 tool per agent è il numero ottimale; oltre circa 18 tool, l'affidabilità della selezione diminuisce.
TOOLS = [{
"name": "lookup_order",
"description": (
"Fetch an order by its ID. Use when the user references a "
"specific order. Returns status, items, and total. "
"order_id format: 'ORD-' followed by 6 digits, e.g. ORD-001234. "
"Returns an empty result if the order does not exist."
),
"input_schema": {
"type": "object",
"properties": {"order_id": {"type": "string"}},
"required": ["order_id"],
},
}]Il segnale stop_reason
Dopo ogni richiesta, Claude restituisce un stop_reason. È così che il modello vi comunica cosa vuole che accada dopo:
end_turn— Claude ha terminato. L'attività è completata.tool_use— Claude vuole eseguire uno o più tool e poi continuare.max_tokens— l'output è stato troncato dal limite impostato.stop_sequence— è stata raggiunta una stringa di arresto personalizzata.
Il ciclo agentico si basa interamente sull'ispezione di questo campo. Non dovete mai indovinare cosa intendesse il modello: ve lo comunica direttamente.
Il ciclo agentico
Unite i vari elementi e ottenete il ciclo agentico:
- Inviate la richiesta.
- Ispezionate
stop_reason. - Se è
tool_use: eseguite i tool, aggiungete i risultati amessagese ripetete il ciclo. - Se è
end_turn: fermatevi: l'attività è terminata.
Questa è la presa di decisioni iterativa in azione. A ogni passaggio, il modello vede i nuovi risultati dei tool e sceglie la mossa successiva. La cronologia della conversazione cresce finché Claude decide di aver terminato.
while True:
response = client.messages.create(
model="claude-opus-4-8",
max_tokens=1024,
messages=messages,
tools=TOOLS,
)
messages.append({"role": "assistant", "content": response.content})
if response.stop_reason == "end_turn":
break # the model says it is done
if response.stop_reason == "tool_use":
results = run_requested_tools(response.content)
messages.append({"role": "user", "content": results})Terminare su stop_reason, non sul testo
Questa è una delle decisioni più verificate nell'esame. Dovete terminare il ciclo su stop_reason, mai cercando nel testo del modello parole come "done", "complete" o "finished".
Perché? L'analisi del testo è fragile: il modello potrebbe dire "non ho ancora finito" o "ho quasi finito" e una semplice ricerca di parole chiave interromperebbe il ciclo troppo presto o lo farebbe continuare per sempre. Il campo stop_reason è il segnale esplicito e strutturato del modello: non lascia spazio ad ambiguità.
Analizzare il testo alla ricerca di segnali di completamento è un classico anti-pattern. Se compare in una risposta tra le opzioni, è quasi sempre errato.
I limiti di iterazione sono una rete di sicurezza
È saggio limitare il numero di iterazioni del ciclo, ma è importante comprenderne il ruolo. Un limite di iterazione è una rete di sicurezza che intercetta i cicli fuori controllo. Non è il modo principale in cui termina il ciclo.
Il meccanismo principale di arresto è sempre stop_reason == "end_turn". Il limite entra in gioco solo se qualcosa va storto e il modello non converge mai.
Trattare un limite arbitrario (ad esempio "fermarsi sempre dopo 3 turni") come flusso di controllo principale è un anti-pattern. Lasciate che sia il modello a guidare il ciclo e mantenete il limite come protezione.
MAX_TURNS = 10 # safety net, not the primary exit
for turn in range(MAX_TURNS):
response = client.messages.create(
model="claude-opus-4-8", max_tokens=1024,
messages=messages, tools=TOOLS,
)
messages.append({"role": "assistant", "content": response.content})
if response.stop_reason == "end_turn":
break # PRIMARY exit — the model decided
handle_tool_use(response)
else:
escalate("Loop hit the safety cap without converging.")Le garanzie spettano al codice
Le decisioni del modello sono potenti ma probabilistiche: hanno un'affidabilità di circa il 90% quando sono guidate da un prompt. Per tutto ciò che ha conseguenze finanziarie, legali o di sicurezza, non è sufficiente.
Quando vi serve una garanzia del 100%, utilizzate codice deterministico, non istruzioni nel prompt:
- Un hook può bloccare un'azione che viola una policy prima che venga eseguita (ad esempio un rimborso superiore a $500).
- Una precondizione programmatica può richiedere che l'identità del cliente sia verificata prima dell'esecuzione di qualsiasi tool per i rimborsi.
I prompt guidano; il codice garantisce. Sapere a quale ricorrere è una competenza fondamentale per un architetto.
def process_refund(order_id, amount, verified_customer_id):
# Deterministic precondition — a prompt cannot guarantee this
if verified_customer_id is None:
raise PermissionError("Identity must be verified before refunds.")
if amount > 500:
return escalate_to_human(order_id, amount) # hook-style hard rule
return issue_refund(order_id, amount)La scelta dei tool definisce l'autonomia
Potete regolare il grado di libertà del modello per ogni richiesta con tool_choice:
"auto"— Claude decide se rispondere con testo o chiamare un tool. È l'impostazione predefinita e quella più agentica."any"— Claude deve chiamare un tool. È utile quando desiderate un output strutturato garantito.{"type": "tool", "name": "X"}— forza l'uso di uno specifico tool.
Normalmente un sistema agentico funziona con "auto": il modello ha bisogno della libertà di decidere quando agire e quando ha terminato. Forzare i tool a ogni turno interromperebbe il naturale segnale end_turn.
response = client.messages.create(
model="claude-opus-4-8",
max_tokens=1024,
messages=messages,
tools=TOOLS,
tool_choice={"type": "auto"}, # let the model choose to act or finish
)Da un agent a molti
Una volta che un singolo ciclo agentico funziona, gli stessi concetti possono essere estesi. Un sistema multi-agent utilizza una struttura hub-and-spoke: un coordinatore scompone l'attività, la assegna ai subagent e aggrega i risultati.
Una regola è fondamentale per l'esame: i subagent non ereditano la cronologia della conversazione del coordinatore. Il contesto di ciascun subagent deve essere passato esplicitamente nel prompt. Non esiste memoria condivisa tra loro.
Ogni subagent esegue comunque un proprio ciclo autonomo, iterativo e basato sull'uso dei tool: il componente fondamentale che avete appena imparato, composto su una scala più ampia.
Controllo rapido: terminare il ciclo
Un architetto sta creando un agent Claude che chiama tool per risolvere i ticket di supporto. Come dovrebbe decidere il ciclo quando l'agent ha terminato una richiesta?
Riepilogo: i componenti fondamentali degli agent
Ora disponete delle basi di ogni agent Claude:
- Autonomia — il modello decide il percorso; il vostro codice esegue. Riservate il codice rigido alle garanzie.
- Uso dei tool — le descrizioni guidano la selezione; mantenete 4-5 tool focalizzati per agent.
- Iterazione — il ciclo esegue richiesta → ispezione di
stop_reason→ esecuzione dei tool → ripetizione. - Terminate su
stop_reason(end_turn), mai analizzando il testo. I limiti di iterazione sono soltanto una rete di sicurezza. - Lo stato è vostro — il modello non ne conserva alcuno; inviate la cronologia completa a ogni turno.
Se padroneggiate questi concetti, potete ragionare su qualsiasi agent d'esame, singolo o multi-agent hub-and-spoke.
Impara Python con un tutor IA — gratis
Scrivi ed esegui vero codice nel tuo browser, ricevi aiuto istantaneo da un tutor IA disponibile 24/7, e riprendi da dove hai lasciato sul web o nell'app.
- Corsi
- 26
- Lezioni
- 104
Domande Frequenti
La lezione «Cosa rende agentico un sistema» è gratuita?
Sì — il testo completo di «Cosa rende agentico un sistema» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Claude Architect, passa a CoddyKit PRO. Il corso Claude Architect include 4 lezioni in totale.
Cosa imparerò in «Cosa rende agentico un sistema»?
Autonomia, utilizzo degli strumenti e processo decisionale iterativo. Eserciti Claude Architect con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.
Ho bisogno di esperienza per iniziare Claude Architect?
Non è richiesta alcuna esperienza precedente. Claude Architect su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 1 di 4.
Quanto tempo richiede la lezione «Cosa rende agentico un sistema»?
La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.
Posso scrivere ed eseguire codice in questa lezione Claude Architect?
Sì. Ogni lezione Claude Architect include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.
Tutte le lezioni di questo corso
- Cosa rende agentico un sistema
- Decisioni guidate dal modello vs hard-coded
- Quando usare un agente
- Panoramica del ciclo agentico