AutoGen local: o que funciona e o que casse

#O modelo de conversa

Enquanto um framework de cadeias exige definir etapas, o AutoGen exige definir participantes. Um agente assistente propõe; um agente que atua em seu nome representa você, pode executar código e retorna o resultado; uma discussão em grupo envolve vários especialistas sob a coordenação de um gerenciador que decide quem fala. O comportamento emerge dessas trocas.

Isso é realmente poderoso para tarefas abertas — depurar, refinar uma análise em várias iterações — e é exatamente isso que torna o custo imprevisível. Uma cadeia fixa faz N chamadas ao modelo. Uma conversa faz tantas chamadas quantas forem necessárias, e essa quantidade é decidida justamente pelo modelo do qual você desconfia.

Esse design tem uma consequência direta sobre a escolha dos papéis: quanto mais agentes distintos houver na conversa, mais turnos serão possíveis antes que uma resposta final surja e maior será o risco de desvio. Dois agentes que se respondem em loop sem nunca chegar a uma conclusão são o sintoma mais comum na execução local, exatamente porque nenhum limite foi definido antes do primeiro teste. O número de agentes, portanto, não é apenas uma escolha de arquitetura: é um multiplicador direto do tempo de cálculo consumido na sua própria placa gráfica.

#AutoGen em modo manutenção: o que mudou

Esse é o ponto que a maioria dos tutoriais ainda disponíveis online omite. O próprio repositório oficial microsoft/autogen declara isso explicitamente desde 2 de outubro de 2025: o projeto está em modo de manutenção, não receberá novas funcionalidades e será gerido pela comunidade. A Microsoft recomenda que novos projetos comecem diretamente com o Microsoft Agent Framework (MAF), o sucessor que reúne os componentes do AutoGen e do Semantic Kernel em um único kit de desenvolvimento, disponibilizado para uso geral no início de abril de 2026.

Os criadores originais do AutoGen, Chi Wang e Qingyun Wu, saíram da Microsoft no final de 2024 e continuaram o desenvolvimento sob o nome AG2, um fork sob licença Apache 2.0, hospedado pela organização ag2ai. O AG2 se apresenta como a continuação ativa do projeto, e não como uma ruptura: a base histórica continua acessível sob o nome AG2 Classic para quem não quer mudar nada no código, enquanto o AG2 1.0 evolui a arquitetura para um protocolo mais explícito entre agentes. Para um projeto que começa hoje, o AG2 é a escolha mais coerente se você quer manter-se próximo da API original do AutoGen; o Microsoft Agent Framework é a opção a considerar se você já está no ecossistema da Microsoft e a fusão com as ferramentas do Semantic Kernel diz respeito diretamente a você.

#Conectá-lo a um modelo local

1. 01
   Servir o modelo

   Em um endpoint compatível com a API da OpenAI. Para vários agentes conversando ao mesmo tempo, um servidor projetado para lidar com solicitações simultâneas funciona muito melhor do que um servidor pensado para uma única estação de trabalho.
2. 02
   Configurar o cliente

   URL base (por exemplo http://localhost:11434/v1 para Ollama), nome do modelo exatamente como foi baixado localmente, chave fictícia. Servidores locais ignoram a chave; a biblioteca do cliente exige frequentemente que ela exista.
3. 03
   Declarar honestamente as capacidades

   Os frameworks perguntam se o modelo suporta chamadas de função ou o modo JSON. Afirmar uma capacidade inexistente gera erros incompreensíveis mais adiante, em vez de uma falha clara.
4. 04
   Aumentar a janela de contexto

   O histórico cresce a cada rodada. Um contexto padrão trunca silenciosamente o início, e os agentes então repetem um trabalho já feito.

#Execução de código: deve ser isolada

O fluxo que torna o AutoGen atraente — um agente escreve código, um agente intermediário o executa, o erro retorna, o agente corrige — é também o que executa código escrito por um modelo na sua máquina. Esse código deve ser executado em um contêiner, sem credenciais, sem acesso à rede se a tarefa não o exigir e nunca tendo sua pasta pessoal como alvo. E todo conteúdo obtido de fontes externas — um ticket, uma página web, um arquivo de documentação — deve ser considerado potencialmente hostil.

A observabilidade conta tanto quanto o isolamento. Em uma conversa com três ou quatro agentes, um incidente é diagnosticado relendo o prompt exato recebido por cada agente em cada turno, e não um resumo feito depois. Sem um registro completo, nunca se sabe se um agente interpretou mal uma instrução ou simplesmente recebeu um contexto truncado por falta de memória. Registrar cada troca, incluindo as chamadas de ferramentas e seus argumentos exatos, custa pouco e evita ter que adivinhar o que aconteceu depois que a placa gráfica volta a ficar silenciosa.

#O tamanho do modelo, de novo

Prefira modelos treinados para chamadas de ferramentas e saídas estruturadas. É o mesmo limite que todos os frameworks de agentes locais enfrentam: produzir texto é fácil, mas seguir formatos rígidos não é. O papel de gerenciador, em uma discussão em grupo, geralmente merece o modelo mais capaz de que você dispõe: é ele quem decide quem fala a seguir, e cada decisão errada de roteamento custa um turno inteiro, um custo que se repete enquanto a conversa continua sem convergir.

• CrewAI: papéis e entregas organizadas
• Arquitetura de um agente local
• Crie um agente local em Python com LangChain
• O kit QuelLLM para montar agentes locais
• Repositório oficial: anúncio do modo de manutenção
• AG2: o fork ativamente desenvolvido
• A API oficial do Ollama compatível com OpenAI

#AutoGen, AG2 ou CrewAI

No código já escrito com a API histórica do AutoGen, a migração para o AG2 geralmente exige poucas alterações: o namespace autogen.* original continua disponível em uma branch dedicada (AG2 Classic), dando tempo para você fazer a transição no seu ritmo. Começar do zero hoje é outra decisão: vale mais a pena escolher diretamente o AG2 ou avaliar o Microsoft Agent Framework do que aprender uma base de código que seu próprio fornecedor descreve como mantida pela comunidade.

#Quanto realmente custa uma conversa

Em uma API paga, uma conversa com três agentes que se estende por vinte rodadas aparece na fatura. Localmente, ela aparece no ventilador do gabinete e no relógio de parede. Cada rodada é uma geração completa: se uma rodada dura em média cinco segundos na sua placa, vinte rodadas sem condição de parada representam pelo menos um minuto e quarenta segundos de processamento contínuo, muitas vezes bem mais quando o contexto aumenta e cada geração relê um histórico mais longo do que o da geração anterior. Nada alerta você enquanto isso acontece — nenhum contador, nenhum limite, apenas uma GPU que continua quente.

É por isso que o limite de rodadas não é um detalhe de configuração entre outros: é o único mecanismo que transforma um custo potencialmente ilimitado em um custo limitado e previsível, exatamente como faria um orçamento de tokens em uma API comercial. Definir esse limite antes do primeiro teste, em vez de descobri-lo depois, é a diferença entre um teste de cinco minutos e uma placa de vídeo monopolizada durante uma noite inteira por uma conversa que não levava a nada desde a décima mensagem. Em uma máquina compartilhada com outros usos — uma estação de trabalho, não um servidor dedicado —, essa monopolização também tem um custo de oportunidade concreto: é impossível executar qualquer outra tarefa que exija muitos recursos da GPU enquanto uma conversa entre múltiplos agentes roda sem limite em segundo plano.

#FAQ