A internet é vasta e não para de crescer. Em meados de 2025, ela já abriga mais de 1,25 bilhão de sites e gera cerca de 149 zettabytes de dados por ano. Mais da metade de todo o tráfego hoje vem de bots — boa parte deles maliciosos. Nesse cenário, ajudar as empresas a proteger sua presença digital nunca foi tão essencial.
Na DoiT, trabalhamos com um cliente especializado em Attack Surface Management (ASM) para explorar como a IA moderna poderia automatizar e escalar parte desse processo. O objetivo: um agente capaz de navegar pela web, analisar os ativos expostos de um cliente e identificar potenciais vulnerabilidades — tudo rodando na AWS.
Desenhando a solução
Arquitetamos um sistema em cima do Amazon Bedrock e do Strands Agents, combinando modelos de raciocínio, automação de navegador, retrieval-augmented generation e observabilidade completa em produção.
Os principais componentes da AWS foram:
| Componente | Serviço | Função |
| -------------------------- | ------------------------------------ | ---------------------------------------------------------- |
| **Foundation Model** | Amazon Bedrock executando Claude | Acesso serverless a LLMs de ponta via API unificada |
| **Agent Framework** | Strands Agents | SDK para criar e orquestrar agentes |
| **Tooling Layer** | Model Context Protocol (MCP) | Interface entre o agente e ferramentas externas |
| **Retrieval** | Bedrock Knowledge Bases + OpenSearch | Vector store para grounding e RAG |
| **Runtime** | AWS Fargate & Bedrock AgentCore | Ambientes de execução totalmente gerenciados |
| **Observabilidade** | CloudWatch & LangFuse | Tracing, logging e métricas. |
| **Infrastructure as Code** | AWS CDK | Automação de deploy |
E como tudo se encaixa:
Vamos nos aprofundar em cada um deles nas próximas seções!
Modelos de raciocínio e Agent Framework
Vamos começar pela base: como o agente "pensa". O AWS Bedrock dá acesso fácil a modelos de raciocínio avançados, como a família Nova da Amazon, os modelos Claude da Anthropic e vários modelos open source, como Mistral, DeepSeek e Llama. Esses modelos já suportam raciocínio no estilo chain-of-thought, o que permite ao agente produzir etapas intermediárias de "pensamento" antes de chegar a conclusões e agir. Essa capacidade de raciocínio é essencial, porque cada ação de navegação e cada observação se apoiam nas anteriores.
Para a orquestração, o Strands Agents oferece uma abstração elegante sobre o loop do agente: na essência, um ciclo de raciocínio, uso de ferramentas e geração de respostas. Ele se integra perfeitamente aos modelos do Bedrock e traz primitivas prontas para produção para estado de sessão, coordenação multi-agente e gerenciamento de contexto.
Um pequeno trecho de código do agente, só para você ter uma ideia de como o Strands simplifica o desenvolvimento:
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,
)
Esse loop permite que o agente navegue de forma autônoma, raciocine sobre o que encontra e mantenha o estado entre as etapas.
Agindo por meio de ferramentas e MCP
Mas só raciocinar não basta — o agente precisa interagir com o mundo.
O ferramental foi viabilizado pelo Model Context Protocol (MCP), um padrão aberto que conecta LLMs a sistemas externos. Cada servidor MCP expõe um catálogo de "ferramentas" com definições e schemas claros, que o agente pode chamar dinamicamente em runtime.
No nosso caso, combinamos três fontes de ferramentas:
retrieve: para consultas semânticas no banco de vulnerabilidades.- Playwright MCP: para navegação web e interações com sites.
- Filesystem MCP: para armazenamento persistente simples e logging.
Enquanto desenvolvíamos isso, em agosto de 2025, a AWS lançou o AgentCore, que já vem com sua própria Browser Tool, eliminando a necessidade de manter nossa própria infraestrutura Playwright. Ela oferece um ambiente de navegador totalmente gerenciado e isolado, com integração ao IAM e observabilidade via CloudTrail — e se encaixou direitinho no código existente:
from strands_tools.browser.agent_core_browser import AgentCoreBrowser
all_tools = [retrieve, AgentCoreBrowser().browser]
A modularidade do Strands tornou trivial trocar o ferramental de navegador self-hosted por um serviço gerenciado mais seguro e escalável.
Grounding com Bedrock Knowledge Bases
Para que o agente raciocinasse com dados do mundo real, fizemos o grounding com o banco de dados do CVE™ Program, um repositório de vulnerabilidades conhecidas.
Com o Amazon Bedrock Knowledge Bases, subimos o dataset de CVEs, que a AWS automaticamente fragmentou, fez o embedding e indexou no OpenSearch Serverless, pronto para ser consultado.
A ferramenta retrieve permitiu então que o agente consultasse esse vector store em runtime, dando a ele conhecimento atualizado sobre vulnerabilidades relevantes para cada ativo de cliente que aparecia. O pipeline gerenciado de ingestão e retrieval do Bedrock Knowledge Bases poupou um esforço significativo de engenharia, na comparação com criar um fluxo de RAG do zero.
Implantando o agente na AWS
Depois de validar o protótipo localmente, levamos a solução para produção usando dois runtimes gerenciados:
1. AWS Fargate
Um deploy containerizado empacotado via Docker e orquestrado com o AWS CDK. Essa configuração trouxe controle total sobre escalonamento e rede, sendo ideal para quem quer mais controle ou tem dependências especializadas (como os servidores MCP).
2. Amazon Bedrock AgentCore
O AgentCore oferece uma abstração de nível ainda mais alto: você define o agente e a configuração dele, e a AWS executa para você.
Com alguns ajustes de código — basicamente trocando o armazenamento em filesystem pelo sistema de estado do Strands — o mesmo agente passou a rodar totalmente gerenciado, sem precisar de configuração de CDK ou VPC, apenas com agentcore configure e agentcore launch do starter kit do AgentCore. Para iteração rápida e overhead operacional mínimo, essa abordagem foi imbatível.
Observabilidade e avaliação
Monitorar o comportamento do agente é tão crítico quanto projetá-lo.
Para times que preferem analytics externos, o LangFuse se conectou sem esforço via OpenTelemetry, oferecendo uma timeline detalhada de loops, chamadas de modelo e invocações de ferramentas. Isso te dá uma visão passo a passo excelente do que o agente está "pensando" e de quais ferramentas ele decide usar — algo fundamental para debugar e evoluir o sistema continuamente.
Após o lançamento do AgentCore, a AgentCore Observability também ficou disponível, integrando-se perfeitamente ao CloudWatch, que agora tem um dashboard de GenAI Observability, capturando traces, métricas e logs em cada invocação. Os desenvolvedores conseguem visualizar uso de tokens, taxas de erro e inspecionar sessões, transformando a caixa-preta do raciocínio do LLM em dados mensuráveis.
Acompanhe os gastos do seu agente com a DoiT Cloud Intelligence
Bem próximo da observabilidade, entender o impacto nos custos antes de ir para produção também precisa estar no topo da lista.
Na DoiT, lançamos o GenAI Lens, parte da plataforma DoiT Cloud Intelligence™, para te ajudar a analisar os padrões de gasto de workloads de IA generativa.
Ele se integra diretamente ao Amazon Bedrock, além da Anthropic e da OpenAI, dando visibilidade sobre quais modelos e workloads estão puxando seus custos.
Para uma análise mais profunda, o DataHub permite incorporar a ingestão de dados diretamente na sua aplicação. Com labeling e dashboards customizados, dá para acompanhar custos por domínio ou cliente — e até calcular um custo por vulnerabilidade encontrada, transformando insights de segurança em ROI mensurável.
O que vem por aí
Da ingestão de dados ao raciocínio e à observabilidade, o ecossistema da AWS forneceu todos os blocos para dar vida a esse agente autônomo de ASM — de forma segura, escalável e com gerenciamento mínimo de infraestrutura, principalmente agora que o AgentCore está em GA.
Rodamos testes no testphp.vulnweb.com e o sistema mostrou ser capaz de detectar cenários de SQL Injection, Reflected e Stored XSS, Authentication Bypass e até comprometimento ativo de site. Esses resultados confirmaram que o agente consegue percorrer fluxos web de forma autônoma, inserir payloads, interpretar evidências de execução e correlacionar os resultados com a base de CVEs — tudo com supervisão humana mínima. Além da precisão técnica, ficou claro o valor de combinar raciocínio autônomo com retrieval em tempo real e observabilidade, transformando varreduras brutas de vulnerabilidades em inteligência estruturada e explicável.
Ainda há muito o que explorar: refinar a geração de relatórios, avaliar o desempenho em benchmarks conhecidos e integrar outras bases de vulnerabilidades. Mas, mesmo na forma atual, este projeto mostra como a combinação AWS Bedrock + Strands Agents consegue traduzir a promessa da IA generativa em valor operacional na cibersegurança.
Todo o código-fonte e os detalhes de implementação estão no GitHub, e há uma versão estendida aqui.
—
Vem com a gente facilitar sua jornada de FinOps: fale com a gente em doit.com/services!