Internet è sterminato e cresce senza sosta. A metà 2025 ospita oltre 1,25 miliardi di siti web e produce circa 149 zettabyte di dati all'anno. Più della metà del traffico arriva ormai da bot, molti dei quali malevoli. In questo contesto, aiutare le aziende a proteggere la propria impronta digitale non è mai stato così importante.
In DoiT abbiamo collaborato con un cliente specializzato in Attack Surface Management (ASM) per capire come l'AI di ultima generazione possa automatizzare e portare in scala parte di questo processo. L'obiettivo: un agente capace di navigare il web, analizzare gli asset esposti di un cliente e individuare potenziali vulnerabilità, il tutto su AWS.
La progettazione della soluzione
Abbiamo costruito un sistema su Amazon Bedrock e Strands Agents, mettendo insieme modelli di reasoning, automazione del browser, retrieval-augmented generation e observability completa di livello produttivo.
Questi i principali componenti AWS:
| Componente | Servizio | Ruolo |
| -------------------------- | ------------------------------------ | ---------------------------------------------------------- |
| **Foundation Model** | Amazon Bedrock con Claude | Accesso serverless a LLM all'avanguardia tramite API unificata |
| **Agent Framework** | Strands Agents | SDK per costruire e orchestrare agenti |
| **Tooling Layer** | Model Context Protocol (MCP) | Interfaccia tra l'agente e gli strumenti esterni |
| **Retrieval** | Bedrock Knowledge Bases + OpenSearch | Vector store per grounding e RAG |
| **Runtime** | AWS Fargate & Bedrock AgentCore | Ambienti di esecuzione completamente gestiti |
| **Observability** | CloudWatch & LangFuse | Tracing, logging e metriche. |
| **Infrastructure as Code** | AWS CDK | Automazione del deployment |
Ed ecco come si incastrano tra loro:
Vediamoli più nel dettaglio nelle prossime sezioni!
Modelli di reasoning e Agent Framework
Partiamo dalle fondamenta: come l'agente "pensa". AWS Bedrock rende immediato l'accesso a modelli di reasoning avanzati come la famiglia Nova di Amazon, i modelli Claude di Anthropic e numerosi modelli open source come Mistral, DeepSeek o Llama. Si tratta di modelli che supportano già il reasoning di tipo chain-of-thought, permettendo all'agente di produrre passaggi intermedi di "ragionamento" prima di arrivare alle conclusioni e di passare all'azione. È una capacità essenziale, perché ogni azione di navigazione e ogni osservazione si fondano sulla precedente.
Per l'orchestrazione, Strands Agents offre un'astrazione elegante del ciclo dell'agente: nella sua essenza, un loop di reasoning, uso dei tool e generazione della risposta. Si integra in modo nativo con i modelli Bedrock e mette a disposizione primitive di livello produttivo per la gestione dello stato di sessione, il coordinamento multi-agente e la gestione del contesto.
Un piccolo estratto di codice per dare l'idea di quanto Strands semplifichi lo sviluppo di un agente:
all_tools = [retrieve]
with playwright_mcp_client, filesystem_mcp_client:
playwright_tools = playwright_mcp_client.list_tools_sync()
filesystem_tools = filesystem_mcp_client.list_tools_sync()
all_tools.extend(playwright_tools + filesystem_tools)
agent = Agent(
model=bedrock_model,
system_prompt=system_prompt,
tools=all_tools,
)
Questo loop consente all'agente di navigare in autonomia, ragionare sui risultati e mantenere lo stato tra un passaggio e l'altro.
Agire tramite tool e MCP
Il reasoning, da solo, non basta: l'agente deve interagire con il mondo esterno.
L'integrazione con i tool è stata abilitata tramite il Model Context Protocol (MCP), uno standard aperto che collega gli LLM a sistemi esterni. Ogni server MCP espone un catalogo di "tool" con definizioni e schemi chiari, che l'agente può richiamare dinamicamente a runtime.
Per il nostro caso d'uso abbiamo combinato tre fonti di tool:
retrieve: per l'interrogazione semantica del database delle vulnerabilità.- Playwright MCP: per la navigazione web e l'interazione con i siti.
- Filesystem MCP: per uno storage persistente di base e per il logging.
Mentre stavamo sviluppando la soluzione, ad agosto 2025 AWS ha presentato AgentCore, che include il proprio Browser Tool e ci ha sollevato dall'onere di gestire un'infrastruttura Playwright dedicata. Offre un ambiente browser completamente gestito e isolato con integrazione IAM e observability tramite CloudTrail, e si è inserito senza attriti nel codice esistente:
from strands_tools.browser.agent_core_browser import AgentCoreBrowser
all_tools = [retrieve, AgentCoreBrowser().browser]
La modularità di Strands ha reso quasi immediato il passaggio da un tooling browser self-hosted a un servizio gestito più sicuro e scalabile.
Grounding con Bedrock Knowledge Bases
Per consentire all'agente di ragionare su dati reali, lo abbiamo ancorato al database del CVE™ Program, un repository di vulnerabilità note.
Tramite Amazon Bedrock Knowledge Bases abbiamo caricato il dataset CVE, che AWS ha automaticamente suddiviso in chunk, vettorizzato e indicizzato in OpenSearch Serverless, pronto per essere interrogato.
Il tool retrieve ha quindi permesso all'agente di interrogare questo vector store a runtime, mettendogli a disposizione conoscenze aggiornate sulle vulnerabilità rilevanti per ciascun asset cliente analizzato. La pipeline gestita di ingestione e retrieval di Bedrock Knowledge Bases ci ha fatto risparmiare un notevole sforzo ingegneristico rispetto alla costruzione di un flusso RAG personalizzato da zero.
Il deploy dell'agente su AWS
Una volta validato il prototipo in locale, abbiamo portato la soluzione in produzione utilizzando due runtime gestiti:
1. AWS Fargate
Un deployment containerizzato impacchettato con Docker e orchestrato tramite AWS CDK. Questa configurazione offre il pieno controllo su scaling e networking, ed è la scelta ideale quando serve maggiore controllo o quando si hanno dipendenze specifiche (come i server MCP).
2. Amazon Bedrock AgentCore
AgentCore offre un'astrazione di livello ancora più alto: si definiscono l'agente e la sua configurazione, al resto pensa AWS.
Con qualche piccolo intervento sul codice — soprattutto il passaggio dallo storage su filesystem al sistema di stato di Strands — lo stesso agente è entrato in esecuzione in modalità completamente gestita, senza alcuna configurazione di CDK o VPC, semplicemente con agentcore configure e agentcore launch dello starter kit di AgentCore. Per chi punta a iterare rapidamente con un overhead operativo minimo, è un approccio imbattibile.
Observability e valutazione
Monitorare il comportamento dell'agente è importante quanto progettarlo.
Per i team che preferiscono analytics esterni, LangFuse si integra senza fatica tramite OpenTelemetry, restituendo una timeline granulare di loop, chiamate ai modelli e invocazioni dei tool. Si ottiene così una visibilità step-by-step su ciò che l'agente sta "pensando" e sui tool che decide di utilizzare: un aspetto cruciale per il debug e per il miglioramento continuo.
Dopo il lancio di AgentCore è arrivata anche AgentCore Observability, che si integra in modo nativo con CloudWatch, oggi dotato di una dashboard di GenAI Observability che cattura tracce, metriche e log per ogni invocazione. Gli sviluppatori possono visualizzare il consumo di token, i tassi di errore e ispezionare le sessioni, trasformando la black box del reasoning degli LLM in dati misurabili.
Tenere sotto controllo la spesa del proprio agente con DoiT Cloud Intelligence
Strettamente legato all'observability, anche capire l'impatto sui costi prima del deployment in produzione dovrebbe essere una priorità.
In DoiT abbiamo lanciato GenAI Lens, parte della nostra piattaforma DoiT Cloud Intelligence™, per aiutarvi ad analizzare i pattern di spesa dei workloads di AI generativa.
Si integra direttamente con Amazon Bedrock, oltre che con Anthropic e OpenAI, offrendo visibilità su quali modelli e workloads stanno trainando i costi.
Per analisi più approfondite, DataHub permette di integrare l'ingestione dei dati direttamente nell'applicazione. Con labeling e dashboard personalizzate è possibile tracciare i costi per dominio o per cliente, fino a calcolare un costo per vulnerabilità rilevata, trasformando gli insight di sicurezza in ROI misurabile.
Uno sguardo al futuro
Dall'ingestione dei dati al reasoning fino all'observability, l'ecosistema AWS ci ha messo a disposizione tutti i building block per dare vita a questo agente ASM autonomo, in modo sicuro, scalabile e con una gestione minima dell'infrastruttura, tanto più ora che AgentCore è in GA.
Abbiamo eseguito test su testphp.vulnweb.com e il sistema si è dimostrato in grado di rilevare scenari di SQL Injection, Reflected e Stored XSS, Authentication Bypass e perfino di compromissione attiva del sito. Questi risultati hanno confermato che l'agente è in grado di percorrere autonomamente i flussi web, inserire payload, interpretare le evidenze di esecuzione e correlare i risultati con il database CVE, il tutto con una supervisione umana minima. Oltre all'accuratezza tecnica, ne è emerso il valore di unire reasoning autonomo, retrieval in tempo reale e observability, trasformando scansioni di vulnerabilità grezze in intelligence strutturata e spiegabile.
Le strade da esplorare sono molte: affinare le capacità di reporting, valutare le performance su benchmark consolidati e integrare ulteriori database di vulnerabilità. Ma anche nella sua forma attuale, questo progetto dimostra come AWS Bedrock + Strands Agents possano tradurre la promessa dell'AI generativa in valore operativo concreto nella cybersecurity.
Tutto il codice sorgente e i dettagli implementativi sono disponibili su GitHub; una versione estesa è disponibile qui.
—
Rendi più semplice il tuo percorso FinOps insieme a noi: scrivici su doit.com/services!