Quando a equipe de engenharia da Cursor fez um enxame de agentes de IA escrever um motor de banco de dados funcional em Rust usando apenas o manual de 835 páginas do SQLite, eles descobriram um fato contraintuitivo, validado não por especulação, mas por gastos reais: como você orquestra os agentes importa mais do qual modelo você escolhe.
Um Experimento, Quatro Configurações, uma Dispersão de Custo de 8×
As regras eram austeras: o enxame podia ler o manual do SQLite e nada mais — sem código-fonte, sem execuções de teste, sem internet. Implementação em Rust do zero; a corretude avaliada pela suíte oficial de testes sqllogictest do SQLite (milhões de consultas), que foi mantida em segredo — os agentes nunca souberam no que seriam testados. Quatro configurações rodaram:
-
Todos premium: GPT-5.5 como planejador e executor → $10.565.
-
Todos econômicos: Grok 4.5 nos dois papéis → a linha de base.
-
Híbrido A: Opus 4.8 planeja, Composer 2.5 executa → $1.339.
-
Híbrido B: Fable 5 planeja, Composer 2.5 executa → um pouco mais caro.
A descoberta-chave: toda configuração que passou produziu qualidade aproximadamente equivalente — com uma dispersão de custo de quase 8×. Os workers queimaram de 69% a mais de 90% de todos os tokens, mas a preços unitários muito menores: na mistura Opus com Composer, o Opus gerou uma pequena fração dos tokens, porém cerca de dois terços do custo, enquanto o Composer carregou o volume de tokens por um terço do preço. A percepção por trás disso é simples: tarefas grandes contêm apenas alguns estágios que realmente precisam de inteligência de fronteira — decomposição, decisões de design, certos trade-offs. Uma vez que o planejador comprime a incerteza em instruções detalhadas, os modelos baratos apenas seguem.
De “Um Modelo Inteligente Escreve Tudo” a um Sistema de Controle
A rodada do SQLite é a final de uma série, e a evolução fica evidente em retrospecto:
Geração um: auto-coordenação plana (falhou)
Todos os agentes iguais, reivindicando tarefas por meio de arquivos de coordenação compartilhados. Resultado: forte contenção de locks, e agentes evitavam tarefas difíceis em favor de tarefas repetitivas e fáceis — uma equipe sem gerente de projeto, todo mundo ocupado, ninguém comendo o pão duro.
Geração dois: separação entre planejamento e execução (funcionável)
Agentes planejadores exploravam o codebase e criavam tarefas recursivamente; workers focavam na execução; árbitros julgavam se era preciso iterar. Mas os executores de longa duração ficaram sobrecarregados — planejando, pesquisando, codando, fazendo merge, revisando e julgando conclusão tudo ao mesmo tempo.
Geração três: arquitetura de planejador raiz (estável e eficiente)
Um planejador raiz detém o objetivo completo, delega unidades de trabalho de escopo estreito recursivamente e nunca implementa nada. Os workers reportam ao seu pai exatamente uma vez por tarefa. O isolamento de contexto é o núcleo: os planejadores não são sobrecarregados com detalhes, os workers não são distraídos pelo objetivo global.
Geração quatro: o enxame do SQLite (uma linha de produção de alto rendimento)
Sobre o planejador raiz, um conjunto completo de mecanismos industriais:
-
Um VCS customizado: dos 1.000 commits por hora do Git para 1.000 por segundo.
-
Resolução neutra de conflitos: agentes dedicados de terceiros para merges — 70.000 conflitos no enxame antigo reduzidos para menos de 1.000.
-
Documentos de design com referências verificadas em compilação: decisões escritas em documentos compartilhados, código dependente carregando referências rastreáveis.
-
Revisão multiperspectiva: camadas de ângulos de revisão de baixa correlação, confiáveis como a redundância de direção autônoma.
-
Field Guide: uma base de conhecimento compartilhada mantida pelos próprios agentes, herdada pelos sucessores.
-
Divisão de arquivos inflados: workers sinalizam arquivos gigantes; agentes externos os fatiam.
-
Breaking changes deliberadas: permitidas, com o compilador propagando o impacto por todo o sistema.
Os resultados foram marcantes: o enxame antigo (mistura Fable 5) precisou de 64.305 linhas de código do motor para passar; o novo enxame passou com 9.908. A mistura Opus 4.8 foi ainda mais marcante — 19.013 linhas com 97% no framework antigo versus 4.645 linhas com 100% no novo.
Por que Enxames Funcionam: Eficiência de Contexto Supera Paralelismo
Esta é a percepção da própria Cursor, e a mais valiosa aqui. Um agente solitário percorrendo a árvore completa da tarefa precisa manter em contexto, simultaneamente, os nós ancestrais, sua posição atual e o objetivo macro. Com o tempo, a aglomeração de contexto e o desequilíbrio de atenção se tornam inevitáveis — hiperfoco no presente em detrimento do todo, ou uma visão global com execução local fraca. Os enxames resolvem isso por meio da decomposição de papéis: os planejadores nunca implementam, então seu contexto permanece conceitual; os workers nunca planejam, então seu contexto se concentra inteiramente em uma peça concreta. A conjectura da Cursor: a escalabilidade do enxame decorre principalmente dessa eficiência de contexto, não do paralelismo — por isso mesmo tarefas de médio porte melhoram quando divididas com sensatez.
Engenharia de Software Está se Tornando o Estudo de Como Declarar Objetivos
O experimento expõe uma mudança de paradigma mais profunda. O autocomplete funcionava linha por linha; os primeiros modelos elevaram a unidade para blocos de código; os agentes elevaram para arquivos e funcionalidades. Os enxames fazem da especificação a unidade básica de trabalho. O julgamento da Cursor: o que se torna escasso é a capacidade de descrever a intenção com precisão. Quando o trabalho do desenvolvedor é definir o objetivo, anexar a especificação e definir o avaliador — e a orquestração cuida da decomposição e da execução — a engenharia se volta de “como eu implemento isso” para “como declaro o objetivo, as restrições e os critérios de aceitação com precisão.”
A analogia mais aguda: os sistemas de orquestração estão começando a se assemelhar a compiladores. Um compilador traduz código-fonte em código de máquina, preservando a semântica a cada passo; um enxame faz o mesmo com a intenção — o planejador analisa o objetivo em uma árvore de tarefas e então o refina em trabalho executável. A diferença é que um compilador é determinístico a cada passo e um enxame é probabilístico a cada passo. Reduzir essa lacuna entre intenção e execução tem sido o problema central da Cursor no último ano.
Cinco Lições para Desenvolvedores e Equipes
-
Pare de venerar o modelo mais forte. Sob orquestração sensata, uma mistura híbrida igualou a qualidade com um desconto de 8×. A alavancagem está em desenhar a fronteira entre planejamento e execução.
-
Isolamento de contexto é a chave para a escala dos agentes. Divida papéis → isole contextos → foque localmente. Funciona para equipes humanas; funciona para enxames.
-
Revisão é mais barata que trabalho. Revisão empilhada em múltiplas perspectivas se paga sozinha; pequenos erros são capturados antes de se acumularem.
-
A qualidade da especificação define o teto. Um manual de 835 páginas, bem estruturado, é a entrada ideal. Codebases reais estão cheios de ambiguidade, comportamentos não documentados e conhecimento tribal — converter requisitos vagos em especificações precisas está se tornando a competência central do engenheiro.
-
A era de “um único agente escreve tudo” acabou. A nova UI de agentes da Cursor já roda múltiplos agentes em paralelo em uma única visão — o experimento do SQLite é o alicerce de pesquisa por trás dessa direção de produto.
Referências: Cursor: Agent Swarm Model Economics · Cursor: Towards Self-driving Codebases · Cursor: Scaling Long-running Autonomous Coding · Cobertura do InfoQ
