Ciclo de desenvolvimento orientado por IA com Amazon Bedrock AgentCore

O problema que o AgentCore resolve na prática

Equipes de engenharia que tentam adotar o Ciclo de Desenvolvimento Orientado por Inteligência Artificial (AI-DLC) frequentemente esbarram num obstáculo concreto: a distância entre a teoria e o código que realmente funciona. O Amazon Bedrock AgentCore é o serviço da AWS voltado para construir, conectar e otimizar agentes em escala, com suporte a qualquer framework ou modelo. O AI-DLC posiciona a IA como colaboradora central ao longo do ciclo de vida do desenvolvimento de software, assumindo a execução de tarefas rotineiras enquanto humanos mantêm o controle das decisões críticas.

Para fechar essa lacuna entre conceito e implementação, a AWS publicou duas implementações de referência que demonstram padrões concretos da fase de construção do AI-DLC usando o Amazon Bedrock AgentCore, o Kiro e ferramentas de codificação agêntica local. Este artigo percorre a arquitetura, as decisões de design e os padrões de código por trás dessas duas soluções.

Padrões de construção AI-DLC na prática

Na fase de construção do AI-DLC, a IA propõe arquiteturas, gera planos de implementação, produz código e cria artefatos de implantação, enquanto os membros da equipe fornecem orientação em tempo real sobre decisões técnicas. As duas implementações mapeiam diretamente esse padrão:

• Geração automatizada de artefatos: um agente recebe entrada estruturada (arquivos de esquema SQL), cria um plano detalhado, gera a saída (diagramas ER em Mermaid) e armazena os resultados para revisão humana.
• Verificação contínua de qualidade de código: um sistema multi-agente analisa código enviado por pipelines de Integração Contínua e Entrega Contínua (CI/CD), produzindo avaliações de segurança, verificações de Vulnerabilidades e Exposições Comuns (CVE) e relatórios de conformidade de políticas.

Ambos os sistemas compartilham uma base arquitetural comum construída sobre o AgentCore, demonstrando como equipes podem compor fluxos orientados por IA a partir de componentes modulares e gerenciáveis.

Solução 1: geração de diagrama ER a partir de esquema SQL

O primeiro projeto auto-gera diagramas ER em Mermaid a partir de arquivos de esquema SQL usando um fluxo de trabalho agêntico no Amazon Bedrock AgentCore. Após o desenvolvedor fazer o commit do código SQL, um gatilho no Amazon Simple Storage Service (Amazon S3) aciona uma função AWS Lambda que invoca o runtime do AgentCore. O agente analisa as instruções de Linguagem de Definição de Dados (DDL) e produz um arquivo .mmd salvo de volta no Amazon S3. O sistema lê apenas metadados do esquema — tabelas, restrições e chaves estrangeiras — nunca dados de linha.

Desafio de negócio

Times de banco de dados que gerenciam esquemas SQL em evolução precisam de documentação de relacionamento entre entidades sempre atualizada. A criação manual de diagramas ER é demorada e a documentação frequentemente fica defasada em relação ao esquema real. Quando mudanças chegam via pull requests, as equipes precisam de diagramas atualizados sem adicionar etapas manuais ao fluxo de desenvolvimento.

Arquitetura da Solução 1

O sistema usa uma arquitetura serverless orientada a eventos com os seguintes componentes:

• Gatilho S3: arquivos SQL enviados a um bucket Amazon S3 acionam uma função AWS Lambda que inicia o fluxo de análise.
• Autenticação: o Amazon Cognito fornece autenticação máquina a máquina (M2M) via OAuth2. As credenciais do cliente ficam armazenadas no AWS Systems Manager Parameter Store.
• Runtime do AgentCore: um agente em container construído com o framework Strands roda no runtime do AgentCore. O agente usa o Claude Sonnet 4 via Amazon Bedrock para analisar instruções DDL e gerar a sintaxe do diagrama ER em Mermaid. (Para disponibilidade do modelo por região AWS, consulte a disponibilidade regional por modelos.)
• Memória do AgentCore: fornece contexto de sessão persistente com validade de 90 dias, além de suporte a busca semântica em análises anteriores e compreensão incremental do esquema.
• Armazenamento de saída: os arquivos .mmd gerados são salvos no Amazon S3 com metadados rastreando o arquivo de origem e o timestamp de geração.

Detalhes de implementação

A implementação do agente usa o wrapper de runtime BedrockAgentCoreApp com o decorador @app.entrypoint para registrar o handler:

from bedrock_agentcore.runtime import BedrockAgentCoreApp
from bedrock_agentcore.memory import MemoryClient
from strands import Agent
from strands.models import BedrockModel

app = BedrockAgentCoreApp()
model = BedrockModel(model_id="us.anthropic.claude-sonnet-4-5-20250929-v1:0", region_name="us-west-2")
erdiagram_agent = Agent(model=model)
memory_client = MemoryClient(region_name="us-west-2")

@app.entrypoint
async def generate_er_diagram(payload: Dict[str, Any]) -> Dict[str, Any]:
    sql_content = payload.get("sql_content", "")
    file_name = payload.get("file_name", "unknown_file.sql")
    # Generate diagram, store in memory, save to S3
    ...

As principais decisões de design incluem:

• Processamento em chunks: arquivos SQL grandes são divididos em segmentos gerenciáveis, analisados independentemente e depois consolidados em um diagrama unificado. Isso permite lidar com esquemas de centenas de tabelas sem ultrapassar os limites de contexto.
• Prompting estruturado: o agente usa um prompt de análise sistemático que extrai tabelas, colunas, tipos de dados, chaves primárias e relacionamentos de chave estrangeira antes de gerar a sintaxe do diagrama.
• Rastreamento com OpenTelemetry: cada etapa é instrumentada com spans e atributos, oferecendo observabilidade sobre duração do processamento, contagem de chunks e atribuição de erros.

A implementação completa, incluindo skills do OpenAI Codex e integração com servidor MCP (Protocolo de Contexto de Modelo), está disponível no repositório no GitHub.

Solução 2: handoffs seguros de software

A segunda solução é um sistema serverless de análise de segurança de código que usa o Amazon Bedrock AgentCore para escanear automaticamente código Python ou Java em busca de vulnerabilidades de segurança, riscos de CVE em dependências e violações de políticas. A análise é acionada quando código é enviado de um pipeline GitLab para o Amazon S3. Um agente baseado no framework Strands então avalia o código usando modelos Anthropic Claude Sonnet no Amazon Bedrock, chamando ferramentas MCP que rodam no AWS Lambda para verificações de CVE e políticas. (Para disponibilidade por região, consulte a disponibilidade regional por modelos.)

Os resultados — incluindo pontuações de qualidade de 1 a 10 e recomendações — são armazenados na memória do AgentCore com busca semântica e exibidos em um dashboard web em tempo real baseado em sessão. O Amazon Cognito cuida da autenticação, enquanto o AgentCore Observability e o Amazon CloudWatch fornecem monitoramento.

Desafio de negócio

Revisões de código para conformidade de segurança exigem conhecimento especializado em bases de dados CVE, políticas de codificação organizacionais e padrões de segurança específicos de cada linguagem. Revisões manuais criam gargalos nos pipelines de entrega, e a aplicação inconsistente de padrões entre equipes leva a variações na qualidade do código.

Arquitetura da Solução 2

Esta solução oferece análise automatizada de segurança de código por meio de uma arquitetura multi-agente para handoffs seguros de software entre estágios de desenvolvimento:

• Arquivos de código são enviados a um bucket Amazon S3 (manualmente ou via pipeline CI/CD).
• Um gatilho AWS Lambda detecta novos uploads e inicia o fluxo de análise do AgentCore com autenticação OAuth2.
• AgentCore Gateway com ferramentas MCP: o gateway orquestra chamadas a integrações externas — uma Lambda de verificação de políticas e uma Lambda de verificação de banco de dados CVE.
• Runtime do AgentCore (framework Strands): o agente central realiza revisão profunda de código, incluindo avaliação de estrutura, qualidade lógica, análise de memória e desempenho, detecção de problemas de segurança e conformidade com boas práticas.
• Memória do AgentCore: armazena resultados de análise com capacidades de busca semântica, suportando comparação histórica e análise de tendências.
• Lambda de Dashboard: serve uma interface web que exibe resultados baseados em sessão com navegação em múltiplas abas por arquivos, violações e métricas de qualidade.

Capacidades principais

O sistema avalia código em múltiplas dimensões: qualidade estrutural, eficiência algorítmica, postura de segurança e conformidade com padrões. Três estratégias de memória distintas atendem a necessidades diferentes:

• Estratégia semântica: armazena descobertas detalhadas de análise de código, resultados de CVE e violações de políticas para recuperação por contexto.
• Estratégia de resumo: mantém métricas agregadas e tendências para visualização no dashboard.
• Estratégia de preferências do usuário: rastreia layout do dashboard e preferências de filtro entre sessões.

Para saber mais, consulte a documentação sobre estratégias de memória do AgentCore.

Detalhes de implementação

O agente de análise segue o mesmo padrão de runtime do AgentCore da Solução 1, com o acréscimo de chamadas a ferramentas MCP roteadas pelo AgentCore Gateway:

from bedrock_agentcore.runtime import BedrockAgentCoreApp
from bedrock_agentcore.memory import AgentCoreMemory
from strands import Agent
from strands.models import BedrockModel

app = BedrockAgentCoreApp()
model = BedrockModel(model_id="us.anthropic.claude-sonnet-4-5-20250929-v1:0", region_name="us-west-2")
analysis_agent = Agent(model=model, tools=[analyze_code, check_quality])
memory = AgentCoreMemory(namespace="code-analysis")

@app.entrypoint
async def analyze_uploaded_code(payload: Dict[str, Any]) -> Dict[str, Any]:
    file_content = payload.get("file_content", "")
    file_name = payload.get("file_name", "unknown.py")
    session_id = payload.get("session_id", "")
    # Analyze code, store results in memory, return quality score
    ...

As principais decisões de design incluem separação de responsabilidades entre agentes (o agente de análise foca apenas em qualidade; verificação de políticas e CVE são delegadas a funções Lambda dedicadas), persistência de resultados por sessão e invocação de ferramentas externas mediada pelo Gateway usando MCP — o que desacopla o agente dos detalhes de implementação das ferramentas e permite adicionar novas ferramentas sem modificar o código do agente.

A implementação completa está disponível no repositório no GitHub.

Ferramentas agênticas locais: Kiro, OpenAI Codex e Claude Code

Enquanto o AgentCore fornece o runtime em nuvem para cargas de trabalho agênticas implantadas e orientadas a eventos, o fluxo de desenvolvimento em si se beneficia de ferramentas agênticas locais que implementam padrões AI-DLC na estação de trabalho do desenvolvedor.

Kiro

O Kiro suporta as fases de concepção e construção do AI-DLC por meio de especificações estruturadas e skills de agente customizadas. Ele transforma requisitos em linguagem natural em especificações estruturadas com critérios de aceitação, e depois gera planos de implementação a partir dessas especificações — mapeando diretamente o padrão AI-DLC de a IA criar planos e buscar validação humana antes da execução. Equipes também podem definir skills de agente reutilizáveis que codificam padrões organizacionais para que o código gerado por IA atenda consistentemente aos requisitos de qualidade corporativos.

OpenAI ChatGPT Codex

O repositório inclui uma integração com o OpenAI Codex que demonstra como o mesmo fluxo de geração de diagramas ER se estende a outros agentes de codificação via MCP e skills customizadas. Um servidor MCP local baseado em stdio conecta o Codex a bancos de dados MySQL ou Amazon Aurora MySQL por meio do INFORMATION_SCHEMA, expondo três ferramentas (schema_summary, generate_er_markdown e generate_mermaid) sem acessar dados de linha. As credenciais de banco de dados são recuperadas do AWS Secrets Manager com verificação TLS.

Claude Code

O Claude Code opera como agente local de linha de comando que complementa implantações no AgentCore: antes de implantar no runtime do AgentCore, desenvolvedores usam o Claude Code para iterar sobre lógica de agentes, testar prompts e validar padrões de integração de ferramentas localmente. Ele também gera scripts de implantação, Dockerfiles, políticas do AWS Identity and Access Management (IAM) e templates do AWS CloudFormation, além de realizar revisões de primeira passagem antes que o código entre no pipeline CI/CD.

O fluxo combinado

Um ciclo típico de trabalho AI-DLC usando essas ferramentas segue este padrão:

• Concepção (Kiro): transformar requisitos de negócio em especificações com critérios de aceitação, validadas pela equipe.
• Construção (Claude Code e Kiro): gerar código de implementação, scripts de implantação e suítes de teste.
• Validação (AgentCore): código enviado via CI/CD aciona análise automatizada de segurança, com avaliação de qualidade antes do merge.
• Operações (AgentCore): agentes em produção rodam continuamente no runtime do AgentCore, acionados por eventos, processando cargas de trabalho em escala com observabilidade completa.

Boas práticas

Com base nas implementações descritas, a AWS recomenda as seguintes práticas:

• Separe as responsabilidades dos agentes: projete cada agente com uma única responsabilidade bem definida. A composabilidade vem da orquestração, não de sobrecarregar agentes individuais.
• Use a memória do AgentCore para continuidade de contexto: memória persistente permite que agentes aprendam com interações anteriores e mantenham estado entre sessões sem reprocessar tudo.
• Instrumente com OpenTelemetry desde o início: rastreamento fornece visibilidade sobre o comportamento do agente, duração do processamento e modos de falha.
• Armazene configuração no Parameter Store: desacople configuração do código. Credenciais do Cognito, IDs de memória, seleções de modelo e nomes de buckets devem ser recuperáveis em tempo de execução.
• Implemente processamento em chunks para entradas grandes: projete agentes para lidar com entradas que excedam janelas de contexto do modelo dividindo, analisando independentemente e consolidando resultados.
• Proteja com autenticação M2M do Cognito: use o fluxo de credenciais de cliente OAuth2 para comunicação serviço a serviço. Evite credenciais hardcoded ou tokens de longa duração.
• Integre via CI/CD, não por upload manual: em produção, conecte agentes a eventos de repositório em vez de exigir uploads manuais de arquivos.
• Aplique Amazon Bedrock Guardrails para saídas de agentes em produção: configure políticas de filtragem de conteúdo, detecção de tópicos negados e validação de fundamentação para garantir que respostas geradas por agentes atendam aos padrões de IA responsável.

Conclusão

A metodologia AI-DLC se torna prática quando respaldada por padrões concretos de implementação. O Amazon Bedrock AgentCore fornece a infraestrutura de runtime — agentes em container, memória persistente, gateways seguros e integração com ferramentas externas — enquanto ferramentas locais como Kiro e Claude Code aceleram o próprio fluxo de desenvolvimento.

Para começar, a AWS sugere partir pelo exemplo SQL-to-ER-Diagram para implantar o primeiro agente AgentCore, depois estender o padrão com coordenação multi-agente, integrações MCP e gatilhos orientados a CI/CD usando o exemplo de Handoffs Seguros de Software. Para aprofundar, a AWS publicou um guia complementar sobre como levar agentes de IA do proof of concept à produção com o Amazon Bedrock AgentCore. Para detalhes completos do serviço, referências de API e orientações de configuração, consulte a documentação do Amazon Bedrock AgentCore.

Fonte

AI-driven development lifecycle using Amazon Bedrock AgentCore (https://aws.amazon.com/blogs/machine-learning/ai-driven-development-lifecycle-using-amazon-bedrock-agentcore/)