π§© Modelo certo para cada papel
Um dos erros mais caros em sistemas multiagentes e usar o mesmo modelo para todos os agentes. O orquestrador precisa de raciocinio sofisticado para decompor tarefas, avaliar resultados e tomar decisoes estrategicas β isso exige um modelo poderoso como Claude Opus ou GPT-5.3. Mas o agente que apenas formata documentacao ou faz buscas simples nao precisa dessa potencia. Usar Opus para formatar Markdown e como contratar um neurocirurgiao para colocar um band-aid.
A estrategia inteligente e mapear o nivel de complexidade cognitiva de cada papel no swarm e atribuir modelos proporcionais. Tarefas que exigem raciocinio multi-etapa, planejamento e avaliacao critica recebem modelos premium. Tarefas mecanicas, repetitivas ou de baixa ambiguidade podem usar modelos leves ou ate gratuitos. O resultado e um swarm que mantΓ©m qualidade maxima nas decisoes criticas enquanto reduz custos drasticamente nas tarefas operacionais.
π‘ Hierarquia de Modelos por Papel
Cada tipo de tarefa no swarm tem um nivel ideal de modelo:
- β’ Tier 1 β Modelos premium (Opus, GPT-5.3): Orquestrador, Planejador, Architect β tarefas que exigem raciocinio profundo, decomposicao complexa e decisoes estrategicas
- β’ Tier 2 β Modelos intermediarios (Sonnet, GPT-4o): Coder, Reviewer, Test Engineer β tarefas que exigem competencia tecnica solida mas com escopo bem definido
- β’ Tier 3 β Modelos leves (Haiku, GPT-4o-mini): Formatacao, traducao, extracao de dados β tarefas mecanicas com baixa ambiguidade
- β’ Tier 4 β Modelos gratuitos: Exploracao, busca, rascunhos preliminares β tarefas onde o resultado sera refinado por outro agente
π Impacto no custo
- Swarm homogeneo (tudo Opus): US$ 15-25 por tarefa complexa β alta qualidade em tudo, mas custo proibitivo para uso continuo
- Swarm heterogeneo otimizado: US$ 3-8 por tarefa β mesma qualidade nas decisoes criticas, custo 60-70% menor
- Regra 80/20: Tipicamente 80% das chamadas de API sao tarefas simples que podem usar modelos baratos, e 20% sao decisoes criticas que justificam modelos premium
- Erro comum: Economizar no orquestrador e desperdicar no executor β o inverso do que deveria ser
π Modelos heterogeneos (anti-blindspot)
Alem de escolher o modelo certo por nivel de complexidade, ha uma razao estrategica para usar modelos de providers diferentes no mesmo swarm: eliminar pontos cegos. Cada LLM foi treinado em datasets diferentes, com tecnicas diferentes, e portanto tem vieses e fraquezas diferentes. Quando o mesmo modelo que escreveu o codigo tambem o revisa, ele tende a "concordar consigo mesmo" β os mesmos padroes que geraram o bug tambem impedem o modelo de detecta-lo.
A tecnica anti-blindspot usa deliberadamente modelos de providers distintos para Coder e Reviewer. Se o Coder usa Claude (Anthropic), o Reviewer usa GPT (OpenAI), ou vice-versa. Como os modelos foram treinados em dados diferentes e tem vieses diferentes, o Reviewer e mais propenso a detectar erros que o Coder teria ignorado. Este principio β semelhante a "segunda opiniao medica" β e uma das decisoes de design documentadas no opencode-swarm e demonstrou reducao significativa de bugs que passavam despercebidos.
π‘ Estrategia Anti-Blindspot
Por que modelos diferentes se complementam:
- β’ Dados de treino distintos: Claude, GPT e Gemini foram treinados em corpora diferentes β cada um "sabe" coisas que os outros nao sabem
- β’ Vieses complementares: Um modelo pode ser forte em logica mas fraco em edge cases; outro pode ser o oposto β juntos cobrem mais territorio
- β’ Padrao Coder/Reviewer cross-provider: Claude escreve, GPT revisa (ou vice-versa) β maximiza a chance de detectar erros sutis
- β’ Resiliencia de provider: Se um provider cai, os agentes usando outros providers continuam funcionando β sem single point of failure
π Evidencias praticas
- Mesmo modelo para coder e reviewer: O reviewer "concorda" com o coder em 85%+ dos casos β incluindo bugs
- Modelos diferentes: Taxa de deteccao de bugs sobe 35-45% quando reviewer usa provider diferente do coder
- Design decision #7 do opencode-swarm: "Heterogeneous models" β documentada como decisao deliberada para maximizar qualidade
- Bonus inesperado: Modelos diferentes tambem geram solucoes mais criativas quando usados em brainstorming paralelo
π° Modelos gratuitos: quando usar
Uma das vantagens pouco exploradas do ecossistema atual e a disponibilidade de modelos gratuitos de qualidade surpreendente. O OpenCode oferece acesso a modelos como Big Pickle, minimax e outros atraves do seu modo Zen, que permite uso sem custo para o usuario. Esses modelos nao sao brinquedos β muitos deles competem com modelos pagos de geracoes anteriores em tarefas especificas.
A chave e saber quando um modelo gratuito e suficiente e quando investir em um modelo pago faz diferenca. Para tarefas de exploracao (ler codebase, buscar padroes, listar arquivos), formatacao (converter Markdown, organizar dados) e rascunhos preliminares (primeira versao que sera refinada), modelos gratuitos sao perfeitamente adequados. O resultado sera verificado e refinado por agentes mais poderosos na cadeia β portanto, a qualidade do rascunho inicial nao precisa ser perfeita.
π‘ Mapa de Uso de Modelos Gratuitos
Tarefas ideais para modelos gratuitos vs tarefas que exigem modelos pagos:
- β’ OpenCode Zen: Modo gratuito do OpenCode que oferece modelos sem custo β ideal para agentes de exploracao e pesquisa que nao precisam gerar codigo critico
- β’ Big Pickle: Modelo gratuito com boa capacidade de compreensao de texto β util para agentes que analisam documentacao e extraem informacoes
- β’ Minimax: Bom para tarefas de classificacao e triagem β pode ser usado em agentes de roteamento que decidem para onde encaminhar tarefas
- β’ Regra pratica: Se o resultado do agente sera revisado por outro agente mais poderoso, use gratuito. Se o resultado vai direto para producao, use pago
β Use gratuito quando
- β Exploracao e leitura de codebase
- β Formatacao e organizacao de dados
- β Rascunhos que serao refinados
- β Prototipagem e experimentacao
β Evite gratuito quando
- β Codigo vai direto para producao
- β Decisoes arquiteturais criticas
- β Raciocinio multi-etapa complexo
- β Analise de seguranca ou compliance
π Estrategia de custo por agente
Vamos colocar a teoria em pratica com um mapeamento concreto agente β modelo baseado nos sistemas reais oh-my-openagent e opencode-swarm. A ideia e simples: cada agente no swarm tem um nivel de responsabilidade diferente, e o custo do modelo deve ser proporcional ao impacto das decisoes que esse agente toma. O orquestrador decide o rumo de todo o projeto β merece o melhor modelo. O explorador apenas le e reporta β pode usar o mais barato.
No oh-my-openagent, o Sisyphus (orquestrador incansavel) e o Prometheus (planejador) exigem raciocinio de altissimo nivel β Claude Opus e a escolha natural. O Hephaestus (executor, deus da forja) precisa de excelente capacidade de codigo β Codex 5.3 ou Claude Sonnet atendem bem. Ja o Explorer e o Librarian (pesquisadores) podem usar modelos gratuitos sem problema, pois seus resultados serao processados e refinados pelos agentes superiores.
π‘ Mapeamento Agente β Modelo
Configuracao otimizada baseada em sistemas reais:
- β’ Sisyphus (orquestrador) β Claude Opus: Raciocinio profundo, decomposicao de tarefas, avaliacao de resultados β precisa do melhor modelo disponivel
- β’ Prometheus (planejador) β Claude Opus: Entrevista o usuario, identifica escopo, cria plano detalhado β mesma exigencia do orquestrador
- β’ Hephaestus (executor) β Codex 5.3 / Claude Sonnet: Escreve codigo com qualidade β modelo intermediario com excelente performance em codigo
- β’ Explorer / Librarian β Modelo gratuito (Zen): Le codebase, busca documentacao β resultados serao refinados, nao precisam ser perfeitos
π Economia real
- Cenario A (tudo Opus): 7 agentes x Claude Opus = ~US$ 20 por tarefa complexa
- Cenario B (otimizado): 2 Opus + 2 Sonnet + 3 gratuitos = ~US$ 6 por tarefa β 70% de economia
- Qualidade: Identica nas decisoes criticas (Opus para orquestrador e planejador), minima diferenca nas tarefas operacionais
- Volume: Em 100 tarefas/mes, a economia passa de US$ 1.400 β suficiente para pagar a assinatura de varios servicos
β‘ Limites e rate limits
Swarms consomem tokens em velocidade muito superior a um agente unico β afinal, multiplos agentes estao fazendo chamadas de API simultaneamente. Cada provider de LLM impoe rate limits (limites de taxa) que restringem quantos tokens voce pode processar por minuto, quantas requisicoes pode fazer por hora e quanto pode gastar por dia. Quando um swarm atinge esses limites, agentes comecam a receber erros e o fluxo inteiro pode travar.
A solucao passa por tres estrategias complementares: planejamento de consumo (estimar quantos tokens cada agente usara e distribuir dentro dos limites), fallback automatico (se o provider principal atingir o limite, trocar para um provider alternativo automaticamente) e provider switching (distribuir chamadas entre multiplos providers para evitar atingir o limite de qualquer um deles). A combinacao dessas tres estrategias garante que o swarm nunca pare por falta de tokens.
π‘ Estrategias contra Rate Limits
Tres niveis de defesa contra interrupcoes por limite de taxa:
- β’ Tokens por minuto (TPM): Cada provider tem um limite de tokens processados por minuto. Swarms paralelos podem atingir esse limite em segundos β monitore o consumo em tempo real
- β’ Fallback automatico: Configure um modelo alternativo para cada agente. Se Claude atinge o limite, o agente automaticamente muda para GPT (ou vice-versa) sem interrupcao
- β’ Provider switching inteligente: Distribua agentes entre providers diferentes desde o inicio β 3 agentes em Anthropic, 2 em OpenAI, 2 em Google β para diluir o consumo
- β’ Retry com backoff: Quando um rate limit e atingido, espere um tempo crescente (1s, 2s, 4s, 8s) antes de tentar novamente β evita sobrecarregar o provider
β οΈ Armadilhas comuns
- β’ Swarm paralelo sem controle: 7 agentes fazendo chamadas simultaneas podem esgotar o rate limit em 30 segundos
- β’ Loop de feedback sem limite: Maker-checker com muitas tentativas consome tokens exponencialmente β sempre defina um maximo
- β’ Contexto inflado: Agentes que acumulam historico sem resumir enviam cada vez mais tokens por chamada β implemente sumarizacao periodica
π’ OpenCode como hub multi-modelo
O OpenCode se destaca no ecossistema de ferramentas para agentes por ser genuinamente provider-agnostico. Enquanto muitas ferramentas sao otimizadas para um unico provider (Claude Code para Anthropic, Copilot para OpenAI), o OpenCode permite configurar cada agente do swarm com um provider e modelo diferente β tudo no mesmo fluxo de trabalho, sem necessidade de adaptadores ou middlewares.
Na pratica, isso significa que voce pode ter o orquestrador usando Claude Opus (Anthropic), o coder usando Codex 5.3 (OpenAI), o explorer usando um modelo gratuito do ecossistema Zen, e o reviewer usando Gemini (Google) β tudo coordenado pelo mesmo sistema. Essa flexibilidade elimina o lock-in de ecossistema, permite otimizar custo por agente e habilita a estrategia anti-blindspot com modelos de providers diferentes sem nenhuma complexidade adicional.
π‘ OpenCode como Hub Central
Capacidades multi-modelo do OpenCode:
- β’ Provider agnostico: Suporta Anthropic, OpenAI, Google, modelos open-source e modelos gratuitos β sem favorecer nenhum ecossistema
- β’ Configuracao por agente: Cada subagente do swarm pode usar um provider e modelo diferente β defina no arquivo de configuracao e pronto
- β’ Multi-ecosystem: Combine o melhor de cada provider β raciocinio do Claude, codigo do Codex, velocidade do Gemini β sem compromissos
- β’ Fallback nativo: Se um provider falha ou atinge rate limit, o OpenCode pode trocar para o provider alternativo automaticamente
π Vantagens praticas
- Zero lock-in: Troque de provider a qualquer momento sem reescrever codigo β apenas mude a configuracao
- Otimizacao continua: Conforme novos modelos sao lancados, troque agentes individuais para o modelo mais recente sem afetar o resto
- Modo Zen: Acesso a modelos gratuitos integrado β perfeito para agentes de baixa criticidade, prototipagem e experimentacao
- Comunidade ativa: Plugins como oh-my-openagent e Superpowers estendem o OpenCode com capacidades multiagentes pre-configuradas
π Resumo do Modulo
Proximo Modulo:
1.7 - Sequencial vs Paralelo: estudo comparativo