Phase 16 - Lesson 10

Group Chat e Seleção de Oradores

O GroupChat do AutoGen e o GroupChat do AG2 compartilham uma única conversa entre N agentes; uma função seletora (LLM, round-robin ou personalizada) escolhe quem fala a seguir. Este é o arquétipo da conversa multiagente emergente — os agentes não conhecem seu papel em um grafo estático, eles apenas reagem ao pool compartilhado. A semântica do GroupChat do AutoGen v0.2 foi preservada no fork do AG2; o AutoGen v0.4 a reescreveu como um modelo de ator orientado a eventos. A Microsoft colocou o AutoGen em modo de manutenção em fevereiro de 2026 e o fundiu com o Semantic Kernel no Microsoft Agent Framework (RC em fevereiro de 2026). A primitiva GroupChat sobrevive em ambas as vertentes, AG2 e Microsoft Agent Framework — aprenda uma vez, use em qualquer lugar.

Tipo: Aprenda + Construa Linguagens: Python (stdlib) Pré-requisitos: Phase 16 · 04 (Primitive Model) Tempo: ~60 minutos

Problema

Grafos estáticos (LangGraph) são ótimos quando o fluxo de trabalho é conhecido. Conversas reais não são estáticas: às vezes o programador pergunta ao revisor, às vezes ao pesquisador, às vezes ao redator. Codificar rigidamente cada transição possível produz uma explosão de arestas. Você quer agentes reagindo a um pool compartilhado, com alguma função decidindo quem fala a seguir.

É exatamente isso que o GroupChat do AutoGen faz.

Conceito

O formato

              ┌─── shared pool ────┐
              │   m1  m2  m3  ...  │
              └─────────┬──────────┘
                        │ (everyone reads all)
      ┌───────┬─────────┼─────────┬───────┐
      ▼       ▼         ▼         ▼       ▼
    Agent A  Agent B  Agent C  Agent D  Selector
                                           │
                                           ▼
                                  "next speaker = C"

Cada agente vê cada mensagem. Uma função seletora é invocada a cada turno para escolher quem fala a seguir.

Os três tipos de seletores

Round-robin. Ciclo fixo. Determinístico. Escalona linearmente em N, mas ignora o contexto — um programador recebe a vez mesmo quando o tópico é revisão jurídica.

LLM-selected. Uma chamada para um LLM que lê o pool recente e retorna o melhor próximo orador. Ciente do contexto, mas lento: cada turno adiciona uma chamada de LLM. O padrão do AutoGen.

Custom. Uma função Python com qualquer lógica que você desejar. Comum: LLM-selected com regras de fallback (por exemplo, "sempre dar a vez ao verificador após o programador").

A API ConversableAgent

agent = ConversableAgent(
    name="coder",
    system_message="You write Python.",
    llm_config={...},
)
chat = GroupChat(agents=[coder, reviewer, tester], messages=[])
manager = GroupChatManager(groupchat=chat, llm_config={...})

O GroupChatManager contém o seletor. Quando um agente conclui um turno, o gerenciador chama o seletor, que retorna o próximo agente. O loop continua até que ocorra uma condição de terminação.

Terminação

Três padrões comuns:

• Limite de rodadas (Max rounds). Limite máximo rígido no total de turnos.
• Token "TERMINATE". Os agentes podem emitir uma mensagem sentinela; o gerenciador para quando uma delas aparece.
• Verificação de objetivo alcançado. Um verificador leve é executado a cada turno e encerra o chat quando o objetivo for concluído.

A divisão AutoGen → AG2 e a fusão com o Microsoft Agent Framework

No início de 2025, a Microsoft iniciou uma grande reescrita do AutoGen (v0.4) em torno de um modelo de ator orientado a eventos. A comunidade fez um fork das semânticas de GroupChat do AutoGen v0.2 como AG2, preservando a API que os primeiros adotantes haviam integrado.

Em fevereiro de 2026, a Microsoft anunciou que o AutoGen entraria em modo de manutenção, com o modelo de ator orientado a eventos sendo fundido ao Microsoft Agent Framework (RC em fevereiro de 2026, agora fundido com o Semantic Kernel). O conceito de GroupChat sobrevive em ambas as vertentes; os detalhes de implementação diferem. O AG2 é o upstream preferencial para código compatível com a v0.2.

Quando o GroupChat se aplica

• Conversas emergentes. Você não quer mapear previamente cada possível próximo orador.
• Tarefas com mistura de papéis. O programador pergunta ao pesquisador, o pesquisador pergunta ao arquivista, o arquivista pergunta de volta ao programador. O fluxo não é um DAG (Grafo Acíclico Dirigido).
• Resolução exploratória de problemas. Pense em uma "reunião de brainstorm", não em uma "linha de montagem".

Quando ele falha

• Determinismo estrito. O seletor de LLM pode ser inconsistente. Mesmo prompt, execuções diferentes, próximos oradores diferentes.
• Cascatas de adulação (Sycophancy cascades). Os agentes concordam com quem falou com mais confiança. Use contra-prompts explicitamente.
• Inchaço de contexto (Context bloat). Cada agente lê todas as mensagens anteriores; o contexto cresce com os turnos. Use projeções (Lição 15) para restringir as visualizações.
• Oradores dominantes (Hot speakers). Um agente domina a conversa porque o seletor favorece suas especialidades. Introduza o equilíbrio de oradores como um recurso do seletor.

Group chat vs supervisor

Mesmas primitivas, padrões diferentes:

• Supervisor: um agente planeja e os outros executam. O seletor é "pergunte ao planejador o que fazer".
• Group chat (Chat em grupo): todos os agentes são pares; o seletor é uma função sobre o pool compartilhado.

Ambos usam as quatro primitivas da Lição 04. O Group chat assume como padrão a orquestração selecionada por LLM (LLM-selected) e o estado compartilhado de pool completo.

Construa

O code/main.py implementa um GroupChat do zero na stdlib. Três agentes (programador, revisor, gerente), variantes round-robin e selecionadas por LLM (LLM-selected), e uma terminação com um token TERMINATE.

A demonstração exibe a transcrição da conversa mais o rastreamento de decisão do seletor para ambas as variantes.

Execute:

python3 code/main.py

Use

O outputs/skill-groupchat-selector.md configura um seletor de GroupChat para uma determinada tarefa — round-robin vs selecionado por LLM vs personalizado, e quais entradas do seletor (mensagens recentes, especialidades dos agentes, contagem de turnos) usar.

Coloque em Produção

Lista de verificação:

• Limite de rodadas (Max rounds). Sempre. 10-20 para tarefas típicas.
• Métrica de equilíbrio de oradores. Rastreie os turnos por agente; alerte quando o desequilíbrio exceder um limite.
• Token de terminação. TERMINATE ou um agente verificador dedicado.
• Projeção ou memória restrita. Após cerca de 10 mensagens, considere dar a cada agente apenas uma visão restrita (scoped view) para evitar o inchaço de contexto.
• Registro do seletor (Selector logging). Para variantes selecionadas por LLM, registre tanto a entrada do seletor quanto sua escolha. Caso contrário, a depuração será impossível.

Exercícios

1. Execute code/main.py. Compare a conversa sob round-robin vs selecionada por LLM (LLM-selected). Qual agente domina em cada caso?
2. Adicione uma regra de "máximo de falas por agente" (max-speaks-per-agent) no seletor. Como isso afeta a transcrição?
3. Implemente uma terminação de objetivo alcançado: pare quando o revisor retornar "aprovado" ("approved"). Com que frequência ela é acionada antes do limite de rodadas?
4. Leia a documentação estável do AutoGen sobre GroupChat (https://microsoft.github.io/autogen/stable/user-guide/core-user-guide/design-patterns/group-chat.html). Identifique o seletor padrão usado pelo GroupChatManager.
5. Leia o repositório do AG2 (https://github.com/ag2ai/ag2) e compare seu GroupChat v0.2 com a versão v0.4 orientada a eventos. Qual propriedade concreta (taxa de transferência, tolerância a falhas, composibilidade) a v0.4 adiciona?

Termos-Chave

Leituras Adicionais

• AutoGen group chat docs — a implementação de referência
• AG2 repo — continuação do AutoGen v0.2 pela comunidade
• Microsoft Agent Framework docs — o sucessor fundido, RC de fevereiro de 2026
• AutoGen v0.4 release notes — detalhes da reescrita do modelo de ator orientado a eventos