A Cursor lançou o Composer 2.5 em 18 de maio de 2026, e a manchete é difícil de ignorar: um modelo de codificação que se iguala ao Opus 4.7 e ao GPT-5.5 em benchmarks de software reais, custando menos de um dólar por tarefa. Se você escreve código para viver, essa relação preço-qualidade muda a forma como você planeja seu dia.
Este guia aborda três coisas que os desenvolvedores continuam procurando: o que o Composer 2.5 realmente é, como acessá-lo dentro do Cursor e como usá-lo bem em trabalhos de produção. Você terá os números de benchmark, a matemática de preços e um fluxo de trabalho prático que combina o modelo com o Apidog para que o código de API que ele escreve esteja correto na primeira execução.
O que é o Cursor Composer 2.5?
O Composer 2.5 é o modelo de codificação agentivo da própria Cursor, construído para planejar, editar arquivos, executar comandos de terminal e verificar seu próprio trabalho dentro do editor Cursor. É o sucessor do Composer 2, e ele transforma o modelo de "parceiro de preenchimento automático rápido" para "agente que conclui tarefas longas sem perder o fio da meada".
Alguns fatos o definem:
- É construído sobre o checkpoint de código aberto Moonshot Kimi K2.5, uma base de aproximadamente um trilhão de parâmetros.
- A Cursor dedicou cerca de 85% do orçamento computacional de treinamento ao pós-treinamento e aprendizado por reforço, e não apenas ao modelo base.
- Foi treinado com 25 vezes mais tarefas sintéticas do que o Composer 2, incluindo exercícios onde o Cursor exclui um recurso e o modelo precisa reconstruí-lo até que os testes passem.
O resultado prático é um modelo que mantém o contexto em sessões longas. O Composer 2 era rápido, mas às vezes se perdia em trabalhos com várias etapas. O Composer 2.5 sustenta o esforço em uma tarefa longa, segue instruções complexas de forma mais confiável e calibra a quantidade de trabalho que uma solicitação realmente precisa, em vez de fazer demais ou de menos.
Se você quiser um conhecimento mais aprofundado sobre a família de modelos, o guia do Composer 2 explica a arquitetura sobre a qual o 2.5 se baseia.
O que mudou nos bastidores
Três ideias de treinamento impulsionam o salto:
- RL direcionado com feedback textual. Em vez de uma recompensa no final de uma tarefa, o Cursor escreve uma breve dica descrevendo a correção desejada, insere essa dica no contexto local e destila o comportamento de volta ao modelo. Foi assim que ele aprendeu a parar de chamar ferramentas que não estão disponíveis.
- Dados sintéticos em escala. O aumento de 25x nas tarefas sintéticas dá ao modelo muito mais prática em trabalhos realistas de repositório, verificados por testes em vez de "sensações".
- Um otimizador Muon fragmentado com HSDP de malha dupla. Esta é uma infraestrutura de treinamento, não um recurso que você manipula, mas é por isso que o Cursor conseguiu treinar um modelo de 1 trilhão de parâmetros com uma etapa de otimizador de 0,2 segundos. Loops de treinamento mais rápidos significam mais iterações na qualidade.
Você não precisa memorizar nada disso para usar o modelo. Isso importa porque explica por que o Composer 2.5 parece mais estável nos tipos de tarefas longas e complexas que quebravam agentes anteriores.
Benchmarks do Composer 2.5: quão bom ele realmente é?
A Cursor relata pontuações em três suítes e as compara com o Opus 4.7 e o GPT-5.5. Aqui está a imagem:
| Benchmark | Composer 2.5 | Opus 4.7 | GPT-5.5 |
|---|---|---|---|
| SWE-bench Multilingual | 79.8% | 80.5% | 77.8% |
| Terminal-Bench 2.0 | 69.3% | 69.4% | 82.7% |
| CursorBench v3.1 | 63.2% | 64.8% (máx.) / 61.6% (padrão) | 59.2% (padrão) |
Lendo com atenção, a história é consistente. No SWE-bench Multilingual, um teste padrão de correção de problemas reais do GitHub em vários idiomas, o Composer 2.5 atinge 79,8%, um ponto de distância do Opus 4.7 e à frente do GPT-5.5. Isso é um grande salto em relação aos 73,7% do Composer 2. No CursorBench, a própria suíte de tarefas da Cursor, ele supera a configuração padrão do Opus 4.7.
O único lugar onde ele fica atrás é no Terminal-Bench 2.0, onde o GPT-5.5 lidera com 82,7%. Se o seu trabalho envolve muitas sequências de terminal longas, tenha isso em mente.
O número que reformula tudo é o custo por tarefa. O Cursor relata aproximadamente 63% no CursorBench a um custo médio inferior a US$ 1 por tarefa, enquanto o Opus 4.7 e o GPT-5.5 custam vários dólares por tarefa para resultados semelhantes ou piores; algumas comparações colocam os custos dos concorrentes em até onze dólares. A cobertura independente do The Decoder chegou à mesma conclusão: qualidade quase de ponta a uma fração do preço.
Então, o Composer 2.5 não é o melhor modelo em todos os gráficos. É o modelo que oferece 95% da qualidade de ponta por aproximadamente um décimo do custo, que é a troca que a maioria das equipes deseja.
Quanto custa o Composer 2.5?
A Cursor oferece duas variantes em dois pontos de preço:
| Variante | Entrada | Saída | Quando usar |
|---|---|---|---|
| Padrão | US$ 0,50 / M tokens | US$ 2,50 / M tokens | Padrão para a maioria dos trabalhos de agente; melhor eficiência de custo |
| Rápido | US$ 3,00 / M tokens | US$ 15,00 / M tokens | Trabalho sensível à latência; mesma inteligência, menor espera |
A variante rápida oferece a mesma qualidade de modelo com menor latência e é o padrão no produto. Ainda tem um preço abaixo das camadas rápidas de outros modelos de ponta.
Como você é cobrado depende do seu plano:
- Planos individuais (Pro e similares) incluem um pool de uso do Composer autônomo com uso generoso incluído, de modo que a maioria dos desenvolvedores solo não tocará na taxa por token no dia a dia.
- Planos de equipe e empresariais são cobrados diretamente pela taxa de API.
- Promoção de lançamento: A Cursor dobrou o uso do Composer 2.5 na primeira semana após o lançamento, então os primeiros usuários obtêm uma vantagem extra para testá-lo.
Para uma análise mais completa de como o Cursor mede os modelos, consulte o guia de preços do Cursor Composer. Se você está tentando executá-lo sem gastar, o guia Composer gratuito aborda o caminho de uso incluído.
Como acessar o Cursor Composer 2.5
Acessar o modelo leva cerca de um minuto.
- Atualize o Cursor. O Composer 2.5 precisa de uma compilação recente. Abra o Cursor, verifique as atualizações (menu Cursor no macOS, menu Ajuda em outros lugares) e reinicie se uma atualização for instalada.
- Faça login em um plano que o inclua. Os planos Pro e Business incluem o uso do Composer. Uma conta gratuita ainda pode experimentá-lo através das permissões incluídas, mas o uso intenso requer um plano pago.
- Abra o seletor de modelo. Inicie um bate-papo ou sessão de agente e, em seguida, abra o menu suspenso de modelo. Escolha
composer-2.5. Você geralmente verá a variante rápida selecionada por padrão. - Confirme o modo agente. O Composer é construído para trabalho de agente, então use o modo Agente em vez de um bate-papo simples para obter edições de arquivo, acesso ao terminal e uso de ferramentas.
Essa é toda a configuração. O modelo tem acesso a todas as ferramentas de agente que o Cursor expõe: leitura e edição de arquivos, execução de comandos de terminal e chamada de ferramentas. A documentação oficial do modelo Composer 2.5 lista os padrões atuais caso o Cursor os altere.
Se você já usou o Cursor antes, mas não seu agente, a visão geral do Cursor 2.0 é um bom guia sobre como a interface do agente funciona.
Como usar o Composer 2.5 de forma eficaz
O acesso é fácil. Obter uma saída robusta requer um pouco de técnica.
Deixe-o executar tarefas longas. A principal melhoria do Composer 2.5 é o desempenho sustentado. Dê a ele uma tarefa real com um estado final claro ("adicione paginação ao endpoint de pedidos e atualize os testes") em vez de microgerenciar linha por linha. Ele é treinado para continuar até que os testes passem.
Escreva a condição de sucesso no prompt. O modelo foi treinado para verificação de testes. Se você disser a ele como julgará a conclusão ("todos os testes existentes permanecem verdes e o novo endpoint retorna 422 em entrada inválida"), ele se autocorrige em direção a esse objetivo.
Escolha a variante certa. Use a variante padrão para trabalho em lote sensível ao custo e a variante rápida quando você estiver iterando ao vivo e esperando por cada resposta. A qualidade é a mesma; você está apenas trocando latência por custo.
Mantenha seu contexto honesto. Modelos agentivos são fortes, mas ainda chutam quando não conhecem a forma real de uma API. Esse é o modo de falha que vale a pena contornar, e é onde suas ferramentas de API importam.
Composer 2.5 mais seu fluxo de trabalho de API
A maioria das tarefas de codificação reais toca em uma API. Peça ao Composer 2.5 para "escrever um cliente para nosso serviço de pagamentos" e ele produzirá um código de aparência limpa; o risco é que os endpoints, campos e autenticação correspondam ao que o modelo assume, em vez do que seu serviço realmente expõe. Código errado, mas confiante, é mais lento do que nenhum código.
Duas práticas corrigem isso:
Primeiro, alimente o modelo com a especificação real da sua API em vez de deixá-lo adivinhar. O servidor Apidog MCP conecta a especificação da sua API Apidog diretamente ao Cursor, para que o Composer 2.5 gere código de solicitação, tipos e testes contra seu esquema real. Se você também executa outros agentes, o resumo dos melhores servidores MCP para Cursor cobre opções complementares.
Segundo, verifique as chamadas geradas antes que cheguem ao branch de um colega de equipe. Insira os endpoints que o Composer 2.5 escreveu no Apidog, envie solicitações reais, verifique os códigos de status e as formas de resposta, e transforme as chamadas que funcionam em testes automatizados e servidores mock. O modelo escreve o primeiro rascunho; o Apidog confirma seu comportamento. Esse ciclo, gerar com base em uma especificação real e depois testar em um servidor real, é o que impede que a velocidade do agente se transforme em dívida de depuração.
Composer 2.5 vs. a concorrência
Orientação rápida se você estiver escolhendo um driver diário:
- vs Opus 4.7: Quase idêntico no SWE-bench Multilingual e CursorBench, muito mais barato por tarefa. O Opus ainda lidera no topo absoluto da configuração máxima do CursorBench.
- vs GPT-5.5: O Composer 2.5 vence no SWE-bench Multilingual e CursorBench; o GPT-5.5 lidera claramente no Terminal-Bench 2.0.
- vs Claude Code: Formato de ferramenta diferente. O Composer 2.5 vive no editor Cursor; o Claude Code é um agente de terminal. A comparação entre Claude Code e Cursor detalha qual se encaixa em cada fluxo de trabalho.
- vs GitHub Copilot: O Copilot é mais forte como preenchimento inline; o Composer 2.5 é construído para tarefas de agente multi-arquivo. O guia Cursor vs GitHub Copilot aprofunda-se.
A Cursor também disse que está treinando um modelo muito maior com xAI usando cerca de dez vezes mais poder de computação, então o 2.5 é um marco em uma curva mais acentuada, não o teto.
Perguntas Frequentes
O Composer 2.5 é gratuito? Não há uma camada totalmente gratuita, mas os planos individuais incluem um pool de uso do Composer que cobre o trabalho diário normal, e o Cursor dobrou o uso na semana de lançamento. O guia Composer gratuito explica até onde vai a permissão incluída.
O Composer 2.5 é melhor que o Composer 2? Sim, comprovadamente. O SWE-bench Multilingual subiu de 73,7% para 79,8%, e o modelo mantém o contexto muito melhor em tarefas longas. O guia do Composer 2 é a linha de base que ele aprimorou.
Em que modelo o Composer 2.5 é baseado? Ele é construído no checkpoint de código aberto Kimi K2.5 da Moonshot, e depois fortemente pós-treinado pela Cursor com aprendizado por reforço e tarefas sintéticas.
Qual variante devo escolher, padrão ou rápida? Mesma inteligência, latência e preço diferentes. Use o padrão para trabalho em lote com foco em custo, o rápido quando estiver iterando ao vivo.
O Composer 2.5 funciona com especificações de API e MCP? Sim. Ele suporta todo o conjunto de ferramentas de agente do Cursor, incluindo o MCP. Conecte sua especificação de API através do servidor Apidog MCP para que ele codifique de acordo com seu esquema real.
Conclusão
O Composer 2.5 é o sinal mais claro de que "codificação de qualidade de ponta" e "cara" estão se desassociando. Você obtém resultados aproximadamente no nível do Opus 4.7 em tarefas de software reais por bem menos de um dólar por tarefa, dentro de um editor construído para trabalho de agente. Atualize o Cursor, escolha composer-2.5 no menu suspenso de modelos e dê a ele tarefas reais de várias etapas em vez de frases únicas.
Combine-o com um ciclo de verificação rigoroso e a velocidade realmente se multiplica. Gere código de API contra sua especificação real, então baixe o Apidog para enviar solicitações ao vivo, confirmar as respostas e bloquear as chamadas que funcionam em testes automatizados e mocks. Código rápido que você verificou é melhor do que código rápido que você precisa depurar.