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.
PerfectScale™ for Kubernetes
Ready to optimize?
Get your free Kubernetes savings analysis
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.
Your cloud bill shouldn't be a mystery
Optimization, automation, expertise. In one platform.
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 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 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!
