Cursor Composer 2.5: O Que É, Como Usar e Como Acessar

A Cursor lançou o Composer 2.5 em 18 de maio de 2026 com uma proposta direta para desenvolvedores: um modelo de codificação agentivo que se aproxima do Opus 4.7 e do GPT-5.5 em benchmarks reais de software, mas com custo inferior a US$ 1 por tarefa.

Experimente o Apidog hoje

Neste guia, você verá como usar o Composer 2.5 na prática: o que ele é, como ativá-lo no Cursor, quando escolher cada variante, como interpretar os benchmarks e como combinar o modelo com o Apidog para gerar, testar e validar código de API com menos retrabalho.

O que é o Cursor Composer 2.5?

O Composer 2.5 é o modelo de codificação agentivo da Cursor. Ele foi criado para trabalhar dentro do editor Cursor planejando tarefas, editando arquivos, executando comandos de terminal e verificando o próprio resultado.

Ele é o sucessor do Composer 2. A principal mudança é sair do papel de “autocomplete avançado” e atuar como um agente capaz de concluir tarefas longas sem perder o contexto.

Na prática, ele se destaca por três pontos:

• É construído sobre o checkpoint open source Moonshot Kimi K2.5, uma base de aproximadamente 1 trilhão de parâmetros.
• A Cursor dedicou cerca de 85% do orçamento computacional de treinamento ao pós-treinamento e ao aprendizado por reforço.
• Foi treinado com 25 vezes mais tarefas sintéticas do que o Composer 2, incluindo cenários em que um recurso é removido e o modelo precisa reconstruí-lo até os testes passarem.

O resultado é um modelo mais estável para tarefas multi-etapas: refatorações, criação de endpoints, atualização de testes, correção de bugs e mudanças que exigem leitura de vários arquivos.

Se quiser entender a base dessa família de modelos, veja também o guia do Composer 2.

O que mudou no treinamento?

Você não precisa conhecer a infraestrutura interna para usar o modelo, mas essas mudanças explicam por que ele se comporta melhor em tarefas longas.

1. RL direcionado com feedback textual
   
   Em vez de receber apenas uma recompensa no fim da tarefa, o modelo recebe uma dica textual curta sobre a correção esperada. Essa dica entra no contexto local e o comportamento é destilado de volta para o modelo.

2. Mais dados sintéticos validados por testes
   
   O aumento de 25x em tarefas sintéticas dá ao modelo mais prática em cenários parecidos com repositórios reais, com validação por testes em vez de avaliação subjetiva.

3. Treinamento em larga escala com Muon fragmentado e HSDP de malha dupla
   
   Essa é uma otimização de infraestrutura. Ela permitiu treinar um modelo de 1 trilhão de parâmetros com etapa de otimizador de 0,2 segundos, acelerando ciclos de melhoria.

Para o uso diário, isso significa: o Composer 2.5 tende a manter melhor o objetivo da tarefa, usar ferramentas com mais consistência e continuar trabalhando até chegar a um estado verificável.

Benchmarks do Composer 2.5

A Cursor compara o Composer 2.5 com Opus 4.7 e GPT-5.5 em três suítes principais:

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

Como interpretar:

• No SWE-bench Multilingual, o Composer 2.5 chega a 79,8%, próximo do Opus 4.7 e acima do GPT-5.5.
• No CursorBench v3.1, ele supera a configuração padrão do Opus 4.7.
• No Terminal-Bench 2.0, o GPT-5.5 lidera com margem clara.

Se seu fluxo envolve muitas sequências longas de terminal, o GPT-5.5 ainda pode ser melhor nesse tipo específico de tarefa. Para tarefas de editor, múltiplos arquivos e correções guiadas por testes, o Composer 2.5 entrega uma relação custo-benefício forte.

O ponto mais importante é o custo por tarefa. Segundo a Cursor, o Composer 2.5 atinge cerca de 63% no CursorBench com custo médio inferior a US$ 1 por tarefa. Opus 4.7 e GPT-5.5 podem custar vários dólares por tarefa em resultados semelhantes ou inferiores. A análise do The Decoder chegou à mesma conclusão: qualidade próxima do topo por uma fração do preço.

Quanto custa o Composer 2.5?

A Cursor oferece duas variantes:

Variante	Entrada	Saída	Quando usar
Padrão	US$ 0,50 / M tokens	US$ 2,50 / M tokens	Tarefas de agente com foco em custo
Rápido	US$ 3,00 / M tokens	US$ 15,00 / M tokens	Iteração ao vivo com menor latência

A variante rápida tem a mesma inteligência do modelo padrão, mas responde com menor latência. Ela costuma ser a opção padrão no produto.

Como a cobrança funciona:

• Planos individuais, como Pro, incluem um pool de uso do Composer.
• Planos Team e Enterprise 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.

Para entender melhor a cobrança, veja o guia de preços do Cursor Composer. Se você quer testar sem gastar, o guia sobre Composer gratuito explica o uso incluído.

Como acessar o Cursor Composer 2.5

Siga este fluxo dentro do Cursor:

1. Atualize o Cursor Abra o Cursor e verifique atualizações:
   • macOS: menu Cursor
   • Windows/Linux: menu Help ou equivalente

Reinicie o editor se uma atualização for instalada.

1. Entre com uma conta compatível
   
   Planos Pro e Business incluem uso do Composer. Contas gratuitas podem ter permissões incluídas, mas uso frequente exige plano pago.

2. Abra o seletor de modelo
   
   Inicie uma sessão de chat ou agente e abra o menu de modelos.

3. Selecione composer-2.5
   
   Normalmente, a variante rápida aparece selecionada por padrão.

4. Use o modo Agent
   
   O Composer 2.5 foi feito para tarefas agentivas. Use o modo Agent para permitir:

   • leitura de arquivos;
   • edição de arquivos;
   • execução de comandos;
   • uso de ferramentas;
   • integração com MCP.

A documentação oficial do Composer 2.5 lista o comportamento atual do modelo. Se você conhece o Cursor, mas ainda não usa o agente, a visão geral do Cursor 2.0 ajuda a entender a interface.

Como usar o Composer 2.5 de forma eficaz

O Composer 2.5 funciona melhor quando você passa tarefas com objetivo claro e critérios de validação.

1. Dê uma tarefa completa, não uma instrução pequena

Evite prompts como:

Crie paginação.

Prefira:

Adicione paginação ao endpoint de pedidos.

Requisitos:
- aceitar page e pageSize via query string;
- manter compatibilidade com chamadas sem paginação;
- retornar total, page, pageSize e items;
- atualizar os testes existentes;
- adicionar testes para page inválida e pageSize acima do limite;
- executar a suíte de testes relacionada e corrigir falhas.

Esse tipo de instrução permite que o agente planeje, edite vários arquivos e valide o resultado.

2. Escreva a condição de sucesso

Inclua no prompt como você vai considerar a tarefa concluída:

A tarefa está concluída quando:
- todos os testes existentes continuarem passando;
- os novos testes cobrirem entrada válida e inválida;
- o endpoint retornar 422 para parâmetros inválidos;
- nenhuma alteração quebrar a compatibilidade da resposta atual.

Como o modelo foi treinado com verificação por testes, isso ajuda a direcionar o comportamento.

3. Escolha a variante conforme o tipo de trabalho

Use a variante padrão quando:

• a tarefa pode rodar em segundo plano;
• você quer reduzir custo;
• está processando várias mudanças parecidas;
• a latência não é crítica.

Use a variante rápida quando:

• você está pareando com o agente em tempo real;
• precisa revisar cada etapa rapidamente;
• está depurando algo interativamente;
• o custo extra compensa a espera menor.

4. Não deixe o modelo adivinhar APIs

Modelos agentivos podem gerar código convincente, mas errado, quando não conhecem a API real.

Exemplo de prompt frágil:

Escreva um cliente TypeScript para nosso serviço de pagamentos.

Melhor:

Use a especificação OpenAPI do serviço de pagamentos.
Gere um cliente TypeScript para os endpoints de criação, consulta e cancelamento de pagamento.
Garanta que os tipos correspondam ao schema real.
Inclua testes para respostas 200, 400 e 401.

Para isso funcionar bem, conecte a especificação real ao fluxo do Cursor.

Composer 2.5 no fluxo de API com Apidog

Muitas tarefas geradas por agente envolvem APIs: clientes HTTP, controladores, SDKs, testes de contrato, mocks e documentação.

O risco é o modelo gerar código com base em suposições incorretas sobre:

• path do endpoint;
• nomes de campos;
• payload obrigatório;
• autenticação;
• códigos de status;
• formato da resposta;
• regras de erro.

Use este fluxo para reduzir esse risco.

Passo 1: conecte a especificação real via MCP

O servidor Apidog MCP conecta a especificação da sua API no Apidog diretamente ao Cursor.

Com isso, o Composer 2.5 pode gerar:

• chamadas HTTP;
• tipos;
• validações;
• testes;
• mocks;
• documentação auxiliar;

com base no esquema real, não em inferência.

Se você usa outros agentes, o guia com os melhores servidores MCP para Cursor lista opções complementares.

Passo 2: peça código com base na especificação

Um prompt mais seguro:

Use a especificação da API disponível via Apidog MCP.

Implemente um cliente TypeScript para o endpoint POST /payments.

Requisitos:
- usar os tipos do schema real;
- validar campos obrigatórios antes da chamada;
- tratar respostas 200, 400, 401 e 500;
- adicionar testes unitários para payload válido e inválido;
- não inventar campos fora da especificação.

Passo 3: valide as chamadas no Apidog

Depois que o Composer gerar o código:

1. Copie ou importe os endpoints gerados no Apidog.
2. Envie requisições reais.
3. Verifique status codes.
4. Compare o corpo da resposta com o schema.
5. Transforme chamadas válidas em testes automatizados.
6. Crie mocks para cenários que ainda não existem no backend.

Esse ciclo é simples:

especificação real -> geração com Composer 2.5 -> validação no Apidog -> testes/mocks

O modelo acelera o primeiro rascunho. O Apidog confirma o comportamento.

Composer 2.5 vs. concorrentes

Use este resumo para escolher o driver diário:

• vs. Opus 4.7
  
  O Composer 2.5 fica muito próximo no SWE-bench Multilingual e no CursorBench, com custo menor por tarefa. O Opus ainda lidera na configuração máxima do CursorBench.

• vs. GPT-5.5
  
  O Composer 2.5 vence no SWE-bench Multilingual e no CursorBench. O GPT-5.5 lidera no Terminal-Bench 2.0.

• vs. Claude Code
  
  São fluxos diferentes. O Composer 2.5 roda dentro do editor Cursor. O Claude Code é um agente de terminal. A comparação entre Claude Code e Cursor explica onde cada um se encaixa.

• vs. GitHub Copilot
  
  O Copilot é mais forte como autocomplete inline. O Composer 2.5 foi desenhado para tarefas agentivas multi-arquivo. Veja o guia Cursor vs. GitHub Copilot para uma comparação mais detalhada.

A Cursor também afirmou que está treinando um modelo maior com a xAI usando cerca de dez vezes mais poder computacional. Portanto, o Composer 2.5 parece mais um marco intermediário do que o limite da linha.

Checklist prático para usar em produção

Antes de aceitar um PR gerado com Composer 2.5, valide:

• [ ] O prompt tinha escopo e condição de sucesso claros.
• [ ] O agente executou ou atualizou testes.
• [ ] As alterações multi-arquivo fazem sentido juntas.
• [ ] O código não inventou endpoints, campos ou schemas.
• [ ] Chamadas de API foram verificadas contra a especificação real.
• [ ] Requisições críticas foram testadas no Apidog.
• [ ] Casos de erro foram cobertos.
• [ ] O diff foi revisado por uma pessoa.

Perguntas frequentes

O Composer 2.5 é gratuito?

Não há uma camada totalmente gratuita. Planos individuais incluem um pool de uso do Composer que cobre uso diário normal, e a Cursor dobrou o uso na semana de lançamento. O guia sobre Composer gratuito explica o limite do uso incluído.

O Composer 2.5 é melhor que o Composer 2?

Sim. O SWE-bench Multilingual subiu de 73,7% para 79,8%, e o modelo mantém contexto melhor em tarefas longas. O guia do Composer 2 serve como linha de base para entender a evolução.

Em que modelo o Composer 2.5 é baseado?

Ele é construído sobre o checkpoint open source 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?

A inteligência é a mesma. A diferença está em latência e preço. Use a variante padrão para reduzir custo em tarefas menos interativas. Use a rápida quando estiver iterando em tempo real.

O Composer 2.5 funciona com especificações de API e MCP?

Sim. Ele suporta o conjunto de ferramentas agentivas do Cursor, incluindo MCP. Você pode conectar sua especificação por meio do servidor Apidog MCP para gerar código alinhado ao schema real.

Conclusão

O Composer 2.5 mostra que modelos de codificação agentiva estão ficando mais baratos sem perder muita qualidade. Ele entrega resultados próximos ao Opus 4.7 em tarefas reais de software, com custo médio inferior a US$ 1 por tarefa segundo a Cursor.

Para começar:

1. Atualize o Cursor.
2. Selecione composer-2.5.
3. Use o modo Agent.
4. Escreva prompts com objetivo, restrições e critérios de sucesso.
5. Execute testes.
6. Valide chamadas de API contra a especificação real.

Para fluxos com API, combine o Composer 2.5 com o Apidog: gere código com base na especificação real, baixe o Apidog, envie requisições, confirme respostas e transforme os casos válidos em testes e mocks. Código rápido é útil; código rápido e verificado é o que chega com segurança à produção.