Pular para o conteúdo
fernando.moretes.com
BlogEstudosCursosE-booksOpen SourcePodcasts
Loading…
Fernando Azevedo

Arquiteto de TI Especialista

Arquitetura, AWS, IA em produção, sistemas financeiros e FinOps, escritos a partir do que foi operado, com os números.

  • LinkedIn
  • GitHub
  • E-mail

Conteúdo

  • Blog
  • Estudos de arquitetura
  • Cursos
  • E-books
  • Open Source
  • Podcasts
  • Assuntos
  • Trilhas

Ferramentas

  • Well-Architected self-check
  • Arquitetura deste site
  • Números públicos
  • Histórico de estudo

Sobre

  • Comunidade
  • IA Builder
  • Perfil
  • Currículo (CV)
  • Trabalhe comigo
  • Media kit
  • RSS do blog
  • RSS dos estudos
  • Artigos narrados (podcast)
  • llms.txt
  • Termos, privacidade e uso de IA

(c) 2026 Fernando Francisco Azevedo

Trilha Arquiteto de IA/Bedrock AgentCore: agentes em produção na AWS
Módulo 4 · Arquitetura na AWS· Aula 17/22

Bedrock AgentCore: agentes em produção na AWS

Os blocos gerenciados para rodar agentes de verdade: runtime, ferramentas, memória, identidade e observabilidade.

6 min de leitura

Escolha como aprender

combine como quiser

Dica: o vídeo é um resumo visual rápido; o áudio e o texto trazem a aula completa. Terminar o áudio ou o vídeo, ou passar no quiz, já conta a aula como concluída.

Assista a esta aula
Narrado por Fernando AzevedoMP4PDF
Ouça esta aula
0:0011:38
Velocidade
Baixar

Construir um agente que funciona no notebook é fácil. Colocar esse agente em produção, com isolamento de sessão, credenciais seguras, memória persistente e rastreabilidade, é onde a maioria dos projetos trava. O Amazon Bedrock AgentCore é a resposta da AWS para esse problema: um conjunto de blocos gerenciados que cobre exatamente o que o Módulo 3 ensinou, só que sem você operar a infraestrutura.

Arquitetura de referência: Amazon Bedrock AgentCore

Fluxo de uma requisição de agente do cliente até a resposta, passando por todos os blocos do AgentCore.

🟧 AWS: Bedrock AgentCore
  • Runtime · Execução serverless · isolada por sessão
  • Gateway · Expõe tools via MCP
  • Memory · Curto e longo prazo
  • Identity · Credenciais e authz · das ferramentas
  • Observability · Traços, logs e evals
🤖 AWS: Bedrock Models
  • Modelo Foundation · Claude / Titan / etc.
🛠️ AWS: Ferramentas Gerenciadas
  • Browser Tool · Navegação web gerenciada
  • Code Interpreter · Execução de código isolada
🔌 Externo: Ferramentas e Dados
  • APIs / Serviços · externas
  • Knowledge Base · RAG gerenciado

Runtime e Gateway: onde o loop do agente realmente roda

O AgentCore Runtime é o ambiente de execução do agente, serverless, isolado por sessão. Cada sessão ganha seu próprio sandbox: sem estado compartilhado entre usuários, sem você gerenciar containers ou escalar manualmente. Você traz seu código de agente (qualquer framework: LangGraph, Strands Agents, código puro) e o Runtime cuida do ciclo de vida.

O AgentCore Gateway é o que conecta o modelo ao mundo externo usando o protocolo MCP que vimos na aula 14. Em vez de você implementar um servidor MCP do zero, o Gateway expõe suas ferramentas como endpoints MCP gerenciados. O modelo chama uma tool, o Gateway roteia para a implementação correta, devolve o resultado, e o loop ReAct da aula 11 continua.

A separação entre Runtime e Gateway é intencional: o Runtime pensa, o Gateway age. Isso significa que você pode trocar o framework do agente sem mexer nas ferramentas, e pode adicionar ferramentas sem redeployar o agente. É o mesmo princípio de desacoplamento que aplicamos em event-driven architecture, só que aplicado ao loop cognitivo do agente.

Memory e Identity: o que mantém o agente coerente e seguro

Na aula 12 vimos que agentes precisam de dois tipos de memória: curto prazo (o que aconteceu nesta conversa) e longo prazo (o que o agente deve lembrar entre sessões). O AgentCore Memory implementa exatamente isso. A memória de curto prazo é o histórico de mensagens da sessão atual, gerenciada automaticamente. A de longo prazo é um armazenamento persistente que o agente pode consultar e atualizar, útil para preferências do usuário, decisões anteriores ou contexto de projetos em andamento.

O AgentCore Identity resolve um problema que todo arquiteto enfrenta: como o agente autentica nas ferramentas que chama? Sem um bloco dedicado, você acaba com credenciais hardcoded, IAM roles excessivamente permissivas ou um sistema caseiro de gestão de segredos. O Identity centraliza isso: cada tool call passa por uma camada de autorização que valida se aquele agente, naquela sessão, tem permissão para chamar aquele recurso. É o princípio de menor privilégio da aula 10 aplicado em runtime.

A combinação Memory + Identity é o que diferencia um agente de produção de um protótipo. Um protótipo esquece tudo e tem acesso irrestrito. Um agente de produção lembra o que importa e só acessa o que precisa.

Observability, Browser e Code Interpreter: completando o quadro

AgentCore Observability entrega o que a aula 9 pediu: visibilidade sobre o que o agente está fazendo. Cada passo do loop ReAct, qual tool foi chamada, qual foi a resposta, quanto tempo levou, qual foi o raciocínio do modelo, vira um traço estruturado. Você consegue responder perguntas como: por que o agente tomou essa decisão? Em qual passo ele alucionou? Qual tool está sendo o gargalo de latência? Sem isso, depurar um agente em produção é trabalhar no escuro.

As ferramentas gerenciadas fecham o ciclo. O Browser Tool dá ao agente a capacidade de navegar na web de forma isolada e auditável, sem você provisionar instâncias de browser, lidar com Playwright em produção ou expor sua rede. O Code Interpreter faz o mesmo para execução de código: o modelo gera Python, o Code Interpreter executa em sandbox, devolve o resultado. Ambos chegam via Gateway como qualquer outra tool MCP.

O ponto arquitetural aqui é consistência: todas as capacidades, ferramentas externas, browser, código, RAG, chegam ao modelo pelo mesmo protocolo. O agente não sabe se está chamando uma Lambda sua ou o Browser Tool gerenciado. Isso simplifica o design e facilita substituir implementações sem reescrever o agente.

FA
Na prática: o que o AgentCore realmente resolve
Arquiteto de TI Especialista

Na prática, o AgentCore não é sobre usar um serviço novo, é sobre não ter que construir seis serviços diferentes. Toda equipe que coloca agentes em produção acaba reinventando: isolamento de sessão, gestão de credenciais de tools, armazenamento de memória, servidor MCP, coleta de traços, sandbox de execução de código. O AgentCore entrega esses blocos prontos e integrados. Minha recomendação: comece pelo Runtime + Observability. Sem visibilidade, você vai gastar mais tempo depurando do que construindo. Adicione Memory e Identity quando o agente precisar de persistência e chamar recursos com controle de acesso. Gateway e as ferramentas gerenciadas entram quando as tools ficam complexas o suficiente para justificar o protocolo.

Os seis blocos e o que cada um resolve

Runtime: executa o agente serverless, isolado por sessão, sem você gerenciar infraestrutura de compute.
Gateway: expõe ferramentas via MCP, desacoplando o agente das implementações concretas das tools.
Memory: gerencia histórico de sessão (curto prazo) e contexto persistente entre sessões (longo prazo).
Identity: centraliza autenticação e autorização das tool calls, aplicando menor privilégio em runtime.
Observability: entrega traços estruturados de cada passo do loop, habilitando debug e avaliação.
Browser Tool e Code Interpreter: capacidades gerenciadas que chegam ao agente como qualquer outra tool MCP.
Ligar

AgentCore, cada bloco e seu papel

Toque num conceito e depois na definição.

Como adotar o AgentCore progressivamente

  1. 1

    1. Comece com Runtime + modelo existente

    Empacote seu agente atual (LangGraph, Strands ou código próprio) no Runtime. Valide isolamento de sessão e latência antes de adicionar outros blocos.

  2. 2

    2. Ative Observability imediatamente

    Ligue os traços antes de qualquer teste de carga. Você vai precisar deles para entender o comportamento do agente desde o primeiro dia em produção.

  3. 3

    3. Migre tools para o Gateway

    Registre suas ferramentas existentes como endpoints MCP no Gateway. Teste que o modelo continua chamando corretamente, a interface muda, o comportamento não deve mudar.

  4. 4

    4. Adicione Identity para cada tool com acesso a recursos

    Para cada tool que acessa banco de dados, API externa ou serviço AWS, configure a política de autorização no Identity. Revise as permissões com o princípio de menor privilégio.

  5. 5

    5. Ative Memory quando o agente precisar de persistência

    Não ative memória de longo prazo por padrão, ela tem custo e complexidade. Ative quando o caso de uso exigir continuidade entre sessões (assistentes pessoais, agentes de projeto).

AgentCore vs. construir os blocos você mesmo

BlocoConstruir próprioAgentCore
Isolamento de sessãoContainer por sessão, orquestração manualGerenciado, serverless, automático
Servidor MCPImplementar, hospedar, versionar você mesmoGateway gerenciado, registro de tools via API
Credenciais de toolsSecrets Manager + IAM customizado por toolIdentity centralizado com políticas por sessão
Traços do loopInstrumentação manual com X-Ray ou OTELTraços estruturados automáticos por passo
Browser / Code sandboxPlaywright em EC2 ou Fargate, sandbox customizadoFerramentas gerenciadas via Gateway MCP

Perguntas frequentes

Preciso usar o AgentCore com o Amazon Bedrock Agents (o serviço de agentes anterior)?

Não. O AgentCore é um conjunto de blocos de infraestrutura que você usa com qualquer framework de agente: LangGraph, Strands Agents, código próprio. Ele não substitui o Bedrock Agents; os dois podem coexistir, mas são produtos diferentes com filosofias diferentes.

O Gateway só funciona com MCP ou posso expor tools via OpenAPI também?

O Gateway usa MCP como protocolo principal, que é o padrão que vimos na aula 14. Para tools baseadas em APIs REST existentes, você pode criar um wrapper MCP que chama sua API, o Gateway não exige que você reescreva as implementações.

A memória de longo prazo do AgentCore Memory é um banco vetorial?

O AgentCore Memory abstrai o armazenamento, você não precisa escolher e operar um banco vetorial diretamente para memória de agente. Para RAG sobre documentos, a aula 18 cobre o Knowledge Bases, que é o serviço dedicado para isso.

O Code Interpreter executa código em qual linguagem?

Python é o suporte principal, que cobre a grande maioria dos casos de uso de análise de dados, cálculos e automação que os modelos geram. O ambiente é isolado por execução, sem estado persistente entre chamadas.

Minha leitura do AgentCore

Recomendado para produção / Recommended

O AgentCore é a resposta certa para a pergunta certa: como não reinventar a infraestrutura de agentes toda vez que você começa um projeto. Os blocos são bem delimitados, o protocolo MCP como espinha dorsal é uma escolha sólida, e a integração com o ecossistema Bedrock (modelos, Knowledge Bases, guardrails) é natural. O risco é o de qualquer serviço gerenciado: você troca controle por conveniência. Para a maioria dos projetos corporativos, esse é o trade-off certo. Para quem precisa de customização profunda em cada camada, construir sobre primitivas AWS ainda é uma opção válida, mas o custo de manutenção é real e cresce com o tempo.

Referências

Amazon Bedrock AgentCore: Developer GuideIntroducing Amazon Bedrock AgentCore (AWS Blog)AgentCore Runtime: Isolating agent sessionsAgentCore Gateway: MCP tool exposureAgentCore Memory: Short and long-term memoryAgentCore Identity: Tool authorizationStrands Agents SDK: Open source agent framework for AgentCore
Concluir e ir para a próxima Aula anterior