AWS HubAWS HubSão Paulo operando · 2 eventos no mundo

AgentesComunidade

Nível de dificuldade: Básico (2 de 5)

Misturar Graph, Swarm e Workflow no Strands Agents custa caro e quebra auditoria de falha

Por AWS Hub10 min de leitura

Em números

  • 74,5% e 192,8% a mais de tokens de modelo gastos pelas duas execuções mistas, comparadas com a baseline pura de Graph (E1)
  • 3,02x o tempo de parede (wall clock) da execução mista mais lenta frente à mesma baseline
  • 3.640 tokens e $0,002912 é o valor fixo de fixture que aparece em todas as cinco execuções lineares (E1 a E5), sem relação com o uso real de modelo
  • 100,0% de sucesso reportado pelo Workflow tool mesmo com uma das tarefas registrando erro em disco

Esses números vêm de um artigo técnico publicado na DEV Community por um AWS Community Builder, que rodou nove experimentos (E1 a E9) com o Strands Agents SDK (versão 1.63.0), o pacote strands-agents-tools (0.8.11), Python 3.11 e o Amazon Bedrock na região us-east-1, usando o modelo amazon.nova-pro-v1:0. O autor documenta no próprio texto que E9 só agrega as evidências das outras oito execuções e não faz chamada a modelo. Os scripts e a saída bruta estão publicados no GitHub do autor, pinxiong, no repositório strands-in-action.

O problema

Quem desenha um sistema multiagente no Bedrock com Strands Agents tem hoje três formas nativas de orquestrar: um Graph (grafo com ordem fixa de execução), um Swarm (handoff autônomo entre agentes) e o Workflow tool do pacote strands-agents-tools (um sub-processo determinístico orientado a tarefas). Arquiteturas reais raramente usam só um padrão: um pipeline pode precisar de uma etapa determinística, uma etapa de pesquisa autônoma e uma etapa condicional no mesmo fluxo. A pergunta que o artigo testa é direta: o que acontece quando você aninha os três no mesmo processo, sem rede e sem segundo processo envolvido?

A resposta documentada é que a composição funciona no nível da API (um Graph pode agendar um Swarm como nó, porque ambos herdam de MultiAgentBase), mas não funciona no nível dos dados. Cada orquestrador mantém sua própria estrutura de estado interna, e nenhuma delas é compartilhada com as outras. Para o arquiteto que vai colocar isso em produção, essa distinção determina se um branch condicional, uma auditoria de falha ou uma métrica de custo vão funcionar como esperado.

A arquitetura

O desenho testado no artigo combina os três orquestradores em um único processo, sem socket, sem segundo processo e sem comunicação via A2A (o protocolo de agente-para-agente usado em posts anteriores da mesma série). O fluxo, do ponto de entrada ao dado final, segue estes passos:

  1. O processo recebe a tarefa: somar três contagens de token por nó (de um fixture local, data/brief-input.json) usando uma tool sum_tokens, e depois salvar um resumo curto com uma tool save_draft.
  2. Um nó Graph dispara a execução e fixa a ordem das etapas seguintes, mantendo cada resultado de nó como um NodeResult dentro de state.results.
  3. Um dos nós do Graph é, na verdade, um Swarm inteiro: o Graph trata esse Swarm como seu executor porque Swarm herda de MultiAgentBase, a mesma classe-base que o próprio Graph usa para nós aninhados.
  4. Dentro do Swarm, os agentes membros trocam contexto por handoff, gravando pares chave-valor num SharedContext interno, pensado como uma camada de pesquisa colaborativa.
  5. Em paralelo na composição (mas não em paralelo na execução, como o autor descobre), o Workflow tool roda um sub-processo determinístico à parte, persistindo cada tarefa em task_results, um dicionário em disco com status, resultado e métricas por tarefa.
  6. Quando o Graph precisa repassar o resultado de um nó (seja ele um Swarm aninhado ou uma tarefa do Workflow tool) para o próximo nó, ele não repassa a estrutura original: ele chama str() sobre o NodeResult e insere o texto resultante no prompt do próximo nó.
  7. O resultado final chega ao chamador como um GraphResult, com o dicionário state.results completo, mas qualquer dado que não tenha sobrevivido à renderização em string já se perdeu antes de chegar ali.

O autor resume o achado central: a fronteira entre os três orquestradores não é uma rede, é uma etapa de renderização. Dentro do mesmo processo dá para inspecionar cada objeto em memória, mas o que efetivamente atravessa de um orquestrador para o outro é só o texto que o adaptador escrito à mão decide expor.

Os serviços envolvidos

A pilha testada depende de poucos componentes, mas a interação entre eles é o ponto central do artigo:

ComponentePapelEstrutura de estado própria
Graph (Strands Agents SDK)Fixa a ordem de execução entre nósGraphState.results, um NodeResult por nó concluído
Swarm (Strands Agents SDK)Coordena handoff autônomo entre agentes membrosSharedContext, dicionário aninhado por chave e por nó
Workflow tool (strands-agents-tools)Executa um sub-processo determinístico orientado a tarefastask_results, registro persistido em disco por tarefa
Amazon Bedrock (us-east-1)Serve o modelo de linguagem que cada agente chamaNão participa da composição entre orquestradores

O modelo usado em todas as chamadas foi amazon.nova-pro-v1:0. O Bedrock entra só como provedor de inferência: ele não enxerga, e não precisa enxergar, a diferença entre um Graph, um Swarm ou uma tarefa de Workflow tool. Toda a complexidade de composição é responsabilidade do código Python que o desenvolvedor escreve em cima do SDK, não do serviço gerenciado.

Vale notar o que falta nessa lista: não há um message broker, uma fila ou qualquer serviço de rede da AWS envolvido no teste. É tudo em processo único, o que torna o resultado ainda mais relevante para quem pensava que colocar tudo no mesmo processo eliminaria os problemas de borda que apareceriam numa arquitetura distribuída via rede.

Trade-offs

O artigo documenta três problemas que atingem diretamente o pilar de excelência operacional do Well-Architected Framework, porque tratam da capacidade de monitorar, depurar e confiar no comportamento do sistema em produção.

O primeiro problema é perda de dados estruturados na travessia. O autor mostra, com trecho de código do arquivo graph.py (linhas 1284-1325 da versão 1.63.0), que _build_node_input sempre serializa o resultado de um nó anterior com str() antes de montar o prompt do próximo nó.

Mesmo que uma condition predicate (a função que decide se uma aresta do grafo deve disparar) consiga ler campos estruturados do NodeResult, o nó seguinte na cadeia só recebe a versão em texto. Um branch que precise checar um status, uma contagem de tokens ou uma flag de sucesso por tarefa tem que ler isso de uma estrutura que ele mesmo controla; uma execução mista não entrega essa estrutura.

O segundo problema é mais sério: uma falha interna pode ser relatada como sucesso no nível externo. O experimento E7 mostra uma tool que levanta exceção dentro de um Swarm aninhado, e mesmo assim o Graph externo termina com status completed. O experimento E8 mostra o Workflow tool reportando 100,0% de sucesso (no texto que ele devolve ao chamador) enquanto uma das tarefas registrou um erro em disco.

Só uma exceção que escapa até o nível do agente (o que o autor chama de "agent-level", em oposição a uma falha "swallowed", engolida pelo loop do agente) faz o Graph externo falhar de verdade. Isso significa que um gate de compliance não pode se apoiar numa string de texto que diz "sucesso".

O terceiro problema é custo. As duas execuções mistas (que combinam os três orquestradores) consumiram 74,5% e 192,8% a mais de tokens de modelo do que a baseline pura de Graph isolado (E1), com tempo de parede até 3,02 vezes maior. O autor relata que havia planejado uma camada de pesquisa paralela dentro do Swarm, mas a execução produziu um handoff serial, não trabalho paralelo, o primeiro sinal de que a composição era decorativa e não trazia ganho real de desempenho.

Dentro de um processo você ainda consegue inspecionar cada objeto em memória, então a fronteira não é uma rede. É uma etapa de renderização.

Inside one process you can still inspect each object in memory, so the boundary is not a network. It is a rendering step.Autor do artigo, AWS Community Builder

Custo estimado

O artigo não estima custo de infraestrutura da AWS em dólares por hora nem compara preços de instância ou de serviço gerenciado: o recorte do teste é o custo em tokens de modelo, medido pelo campo accumulated_usage.totalTokens que o runtime do Strands Agents já expõe. A baseline E1 (Graph puro) gastou 4.829 tokens nessa métrica, segundo o próprio artigo.

Importa diferenciar dois números que carregam a palavra "tokens" no texto, porque confundi-los leva a ler o benchmark errado:

  • accumulated_usage.totalTokens é o que o runtime do SDK reporta como gasto real de uma execução contra o modelo (4.829 na E1).
  • O valor "3.640 tokens" que aparece dentro de cada brief gerado é um número de fixture: a tool sum_tokens apenas soma três contagens por nó inventadas, lidas do arquivo data/brief-input.json. Esse número pertence à tarefa de teste, não é uma medição de uso de modelo.

As cinco execuções lineares (E1 a E5) registram sempre os mesmos dois números de fixture, 3.640 tokens e $0,002912, porque o fixture não muda; o que varia entre elas é só o texto do brief gerado. Já as execuções mistas (que combinam os três orquestradores) são as que disparam o aumento real de 74,5% e 192,8% em totalTokens, porque cada etapa extra de renderização e cada rodada adicional de chamada ao modelo dentro do Swarm aninhado soma ao total.

Como adaptar

Para quem desenha arquiteturas multiagente com Strands Agents sobre o Bedrock, o artigo sugere um critério objetivo de decisão, não uma recomendação genérica contra misturar orquestradores.

Quando não misturar:

  • Quando uma etapa seguinte precisa fazer um branch condicional baseado em um campo estruturado (status, contagem, flag) de um resultado anterior que veio de um orquestrador aninhado: o texto renderizado por str() não carrega esse campo.
  • Quando a falha de uma etapa interna precisa ser auditável por um gate de compliance ou um pipeline de aprovação: uma exceção engolida (swallowed) dentro de um Swarm ou de uma tarefa do Workflow tool pode não escalar até o Graph externo.
  • Quando a cadeia é puramente linear: as cinco execuções lineares do artigo (E1 a E5) não ganham nenhum fato novo ao misturar orquestradores, só trocam a redação do texto final.

Quando misturar pode valer a pena: o artigo identifica um ganho real e específico: um Graph pode agendar um Swarm inteiro como um de seus nós, porque ambos herdam de MultiAgentBase. Isso permite que uma máquina de estados determinística contenha uma camada de handoff autônomo entre agentes em um ponto específico do fluxo. Nenhuma das três baselines puras testadas nos posts anteriores da série oferecia essa forma: um Swarm recusou hospedar um nó de Graph, e o Workflow tool não é um nó de Graph de forma alguma.

Se o arquiteto decidir seguir esse caminho, o artigo recomenda tratar a fronteira entre orquestradores como uma interface explícita de texto, e não como uma passagem de dados estruturados: quem escreve o adaptador precisa decidir, campo por campo, o que atravessa e o que se perde. Quem precisa de uma informação estruturada do outro lado da fronteira (um código de erro, uma métrica, um status binário) deve extraí-la antes da renderização em string e repassá-la por um canal próprio, criado manualmente, em vez de confiar que ela sobrevive no texto.

O autor fecha com uma ressalva importante sobre o escopo do teste: é um benchmark para inspecionar uma fronteira entre orquestradores, não uma amostra de tráfego de produção. Os números descrevem o que o runtime reporta sobre custo e status; eles não dizem nada sobre a qualidade das respostas geradas pelo modelo em cada etapa.

Fonte: DEV Community — AWS Community Builders

Serviços neste textoAgentes

Leve para a sua IA

Decida com o seu assistente, com o contexto deste texto já montado.

1. O que você quer saber

Ver o prompt
Li no AWS Hub: "Misturar Graph, Swarm e Workflow no Strands Agents custa caro e quebra auditoria de falha" (https://awshub.com.br/comunidade/misturar-graph-swarm-e-workflow-no-strands-agents-custa-caro-e-quebra-auditoria).
Resumo: Um teste publicado por um AWS Community Builder cruzou Graph, Swarm e o Workflow tool do Strands Agents no mesmo processo e mostrou que a composição funciona na API, mas não compartilha dados: cada orquestrador passa texto renderizado adiante, e uma falha interna pode virar sucesso no resultado final.
Serviços: Agentes

Minha stack: [descreva em uma linha: serviços, linguagem, volume, região]

Isso muda alguma coisa na minha arquitetura? O que eu faria diferente a partir de amanhã?

Newsletter semanal

A semana da AWS, em português

Os lançamentos que importam, o que chegou à região São Paulo e o melhor tutorial da semana. Toda sexta, gratuita.