Cursor 2.0 e Composer: como uma reformulação multiagente surpreendeu a programação de IA.

Cursor, o editor de código e plataforma de agentes com foco em IA, foi lançado. Cursor 2.0 Em 29 de outubro de 2025 — uma grande atualização que combina um modelo de codificação desenvolvido especificamente para esse fim (chamado ComporCom uma interface reimaginada e centrada no agente, além de um conjunto de atualizações de plataforma, a empresa apresenta uma solução que visa tornar a programação orientada a agentes mais rápida, segura e colaborativa. A empresa posiciona este lançamento como uma mudança estratégica, passando da integração de modelos de terceiros para o fornecimento de seu próprio modelo treinado e ferramentas otimizadas de ponta a ponta para o desenvolvimento de software "orientado a agentes".

Abaixo: uma análise detalhada do que o Cursor trouxe na versão 2.0, como o Composer foi construído, os itens concretos do changelog e — o mais importante — O que realmente surpreendeu o mundo da IA ​​para desenvolvedores? sobre este lançamento.

O que é um cursor (e por que os desenvolvedores devem prestar atenção a ele)?

Cursor é um editor e plataforma projetados desde o início para permitir que desenvolvedores usem IA. agentes como colaboradores de primeira classe dentro do fluxo de trabalho de codificação. Ele combina um editor local/remoto, orquestração de agentes, integrações de ferramentas (terminais, navegador, busca semântica) e um fluxo de trabalho centrado em modelos para que os agentes possam ler, planejar, editar, testar e iterar em bases de código reais. A empresa define o Cursor como "a melhor maneira de programar com IA", com foco em permitir que os agentes executem tarefas de engenharia úteis, em vez de apenas completar linhas automaticamente.

Por que o Cursor 2.0 é importante agora?

Os assistentes de IA para código evoluíram de simples conclusões para fluxos de trabalho mais longos e com várias etapas (planejar → editar → testar → iterar). Isso cria novos gargalos — latência, fidelidade de contexto em grandes repositórios, execução segura de comandos de shell/CI e o trabalho humano de revisar as alterações do agente. Cursor 2.0 visa diretamente esses gargalos, fornecendo um modelo otimizado para fluxos de trabalho com agentes. e Primitivas de interface do usuário/arquitetura para executar vários agentes simultaneamente e com segurança. Em resumo: Cursor busca ser a solução completa para engenharia de software centrada em agentes.

Recursos da atualização do Cursor 2.0:

• 4 vezes mais rápido — turno de diálogo concluído em média em menos de 30 segundos;
• Capacidades aprimoradas para tarefas em várias etapas — capaz de lidar de forma independente com cadeias de código complexas;
• Busca semântica aprimorada — capaz de compreender e encontrar relações em toda a base de código;
• Otimização de interação de baixa latência — adequada para desenvolvimento em tempo real e prototipagem rápida;
• Treinamento de aprendizado por reforço (RL) — otimizado para codificação baseada em agentes.

Qual é o conceito central por trás do Cursor 2.0?

Em sua essência, o Cursor 2.0 promove três ideias interligadas:

1. Design de editor com foco no agente

Em vez de adicionar agentes a um IDE tradicional, o Cursor 2.0 expõe os agentes como objetos no editor: visíveis em uma barra lateral, gerenciáveis ​​como processos e capazes de executar "planos" (estratégias de várias etapas) no repositório. Isso reformula as ações de IA como tarefas orquestráveis ​​— cada uma com entradas, registros e saídas que os engenheiros podem inspecionar.

2. Modelo de codificação rápido e específico (Composer)

O novo modelo da Cursor, o Composer, é um modelo de codificação de ponta treinado e otimizado especificamente para interações de agentes dentro do ambiente Cursor. Ele prioriza a taxa de transferência e a capacidade de resposta — propriedades essenciais para ciclos curtos e iterativos de codificação dentro de um editor — em detrimento de benchmarks brutos e dispendiosos de perplexidade de tokens. A empresa relata que o Composer atinge aproximadamente Velocidade de geração 4× Em comparação com modelos de capacidade semelhante, o sistema completa a maioria das interações em menos de 30 segundos em seus testes internos. Essa velocidade não é apenas uma questão de conveniência; ela transforma a experiência de fluxos de trabalho com agentes (de espera para iteração).

3. Execução paralela e isolada de agentes

O Cursor 2.0 permite que as equipes executem vários agentes em paralelo no mesmo projeto, evitando conflitos de arquivos ao isolar o espaço de trabalho de cada agente (por meio de técnicas como árvores de trabalho do Git ou ambientes de trabalho remotos). Isso possibilita a exploração de cenários hipotéticos em grande escala: executar diversas estratégias de reparo, variantes de refatoração ou pipelines de teste em paralelo e comparar os resultados sem interferir uns nos outros.

---

Lista de alterações do Cursor 2.0: o que exatamente há de novo?

A Cursor publicou um changelog detalhado juntamente com o anúncio da versão 2.0. Os destaques abaixo resumem as mudanças mais significativas no produto e na pesquisa.

Composer — o primeiro modelo de codificação agentiva do Cursor

• Modelo de fronteira desenvolvido especificamente para esse fim: O Composer é descrito como um modelo de "fronteira" otimizado para tarefas de engenharia de software e velocidade de execução. Ele foi treinado com acesso a ferramentas de código-fonte durante o treinamento, o que o ajuda a aprender padrões de busca, edição e resolução de problemas em várias etapas dentro de um repositório do mundo real.
• Vantagem de velocidade: O Cursor informa que o Composer está aproximadamente 4× mais rápido em termos de capacidade de processamento de geração, supera modelos de inteligência comparável em seus benchmarks, e a maioria das interações conversacionais termina em menos de 30 segundos na prática — uma melhoria fundamental para sessões interativas.
• Otimização agentiva: O Composer foi treinado em um ambiente agentivo (com acesso a ferramentas como busca semântica, edição e execução de testes) e otimizado com métodos de aprendizado por reforço para favorecer alterações de código rápidas e confiáveis. Algumas pesquisas independentes apontam para arquiteturas do tipo MoE (mistura de especialistas) e ajuste fino por aprendizado por reforço na estratégia de treinamento do modelo.

Impacto para o desenvolvedor: Menor latência e melhor reconhecimento de contexto para grandes repositórios tornam os fluxos de trabalho iterativos do agente mais ágeis e confiáveis ​​para edições em várias etapas.

Multiagentes: orquestração de agentes paralelos

Gestão da barra lateral e do plano: Uma nova interface de editor permite que os desenvolvedores criem, nomeiem e gerenciem vários agentes e "planos" (estratégias de agentes com várias etapas) com uma barra lateral persistente, facilitando a inspeção dos agentes e seus registros.

Execuções paralelas (até oito agentes): O Cursor 2.0 suporta a execução de até oito agentes em paralelo Em um único prompt, cada um operando em uma cópia isolada do código-fonte para evitar conflitos. Isso é possível graças a árvores de trabalho Git locais ou a processos remotos. O paralelismo transforma a experimentação orientada a agentes, de um processo linear e bloqueante, em um processo rápido e comparativo.

Navegador (GA): permitindo que agentes testem e inspecionem interfaces de usuário da web reais.

O navegador foi promovido para GA:* O navegador integrado do Cursor — originalmente em versão beta — agora está disponível para todos e melhor integrado ao editor. Os agentes podem interagir com páginas da web, extrair elementos DOM e encaminhar informações estruturadas de volta para o ambiente de execução do agente. Isso permite que os agentes pesquisem documentação, acessem APIs remotas e realizem depuração orientada pela web sem sair do editor.

Impacto para o desenvolvedor: Agora, os agentes podem validar alterações na interface do usuário, reproduzir bugs do cliente e iterar com evidências visuais/DOM concretas, em vez de descrições textuais vagas.

Revisão de código e comparações aprimoradas

Revisão simplificada de alterações de agentes em vários arquivos. O Cursor 2.0 simplifica a revisão das alterações feitas por um agente em um repositório, sem a necessidade de alternar entre arquivos; as diferenças são apresentadas de uma forma que reduz a sobrecarga cognitiva.

Impacto para o desenvolvedor: À medida que os agentes fazem edições maiores ou que abrangem vários arquivos, o tempo que os humanos gastam determinando a confiabilidade diminui — um passo essencial para a adoção.

Terminais em ambiente controlado (GA) e controles de segurança

Os terminais em sandbox são GA (macOS) e executam comandos do shell do agente em um ambiente seguro por padrão. As execuções do shell são realizadas em um ambiente isolado (sandbox) com acesso de leitura/gravação ao espaço de trabalho, sem rede por padrão e com listas de permissões para comandos sensíveis. Controles administrativos para empresas estão disponíveis.
Impacto para o desenvolvedor: A execução segura de agentes é crucial; o isolamento em sandbox reduz o risco quando um agente precisa executar testes, executar verificadores de código ou executar comandos efêmeros.

Modo de voz, modo de planejamento e agentes em segundo plano

• Controlo de voz para agentes (conversão de voz em texto + palavras-chave de envio personalizadas).
• Modo de planoCriar um plano com um modelo e executá-lo com outro; os planos podem ser executados em primeiro plano ou em segundo plano.
• Agentes de fundo e em nuvemInicialização mais rápida, 99.9% de confiabilidade para agentes na nuvem, melhor visibilidade do trabalho em segundo plano.

O que o Cursor 2.0 representa para o cenário mais amplo da programação de IA?

A ação do Cursor é notável por dois motivos:

1. Especialização em detrimento da generalidade. O Composer exemplifica uma tendência de construção de modelos personalizados para domínios e ambientes de execução específicos (neste caso: programação orientada a agentes dentro de uma IDE). Em vez de um único modelo generalista que atenda a todos os casos de uso, as equipes defendem modelos co-criados com a experiência do usuário e o conjunto de ferramentas que utilizam.
2. Orquestração de agentes como um elemento primitivo do produto. A interface do Cursor trata os agentes como recursos gerenciados que você pode orquestrar, auditar e versionar. Esse padrão de produto — agentes como processos gerenciados com árvores de trabalho isoladas e planos compartilhados — provavelmente aparecerá em outras ferramentas de desenvolvimento à medida que as equipes buscam escalar a assistência autônoma com segurança.

Essa combinação — modelos especializados e mais rápidos, além de uma experiência de usuário (UX) de orquestração deliberada — leva o setor de "modelos como preenchimento automático" para "modelos como colaboradores ativos", mas também levanta questões de governança que todas as equipes terão que responder.

Como faço para acessar o Cursor 2.0?

1. Baixe ou atualize o aplicativo Cursor no site oficial (o Cursor distribui as versões a partir do seu site). O Cursor 2.0 foi lançado como a linha de produtos v2 (Composer + interface de usuário multiagente), portanto, atualizar para a versão mais recente do Cursor é o primeiro passo.

2. Certifique-se de que o Cursor 2.0 / Composer esteja ativado.

• O modelo de preços da Cursor é baseado em planos de assinatura, cada um oferecendo diferentes níveis de acesso ao Composer e a outros modelos. A empresa oferece um plano Hobby gratuito, mas usuários profissionais geralmente optam por um plano pago para desbloquear todos os recursos.
• A versão 2.0 do Cursor (Composer, interface de usuário multiagente, navegador integrado, etc.) está destacada no changelog; se o aplicativo foi atualizado automaticamente, você já deve estar na versão 2.0. Caso contrário, atualize o aplicativo na página de download ou na caixa de diálogo de atualização do aplicativo.
• Os recursos de Composer ou de múltiplos arquivos/agentes podem estar ocultos por uma opção Beta nas Configurações (versões mais antigas). Se você não vir o Composer, verifique Configurações → Recursos/Beta e habilite-o; o Composer geralmente é aberto pelo atalho Composer/Agent (por exemplo, Ctrl/Cmd + I) ou pelo painel lateral. O Composer pode ser ativado/desativado e aparece na interface do Agente/Composer.

3. Configurar chaves/modelos de APIO Cursor usa chaves de API configuradas para chamar provedores de LLM (OpenAI, Anthropic, Google ou provedores personalizados, como...) CometAPIAbra o Cursor → Configurações → Modelos (ou Configurações → Chaves de API) para adicionar chaves de provedor e URLs base personalizadas. O Cursor permitirá que você selecione o modelo habilitado em Chat / Agente / Compositor.

Como usar a API Comet dentro do Cursor? (passo a passo)

Resumo: O CometAPI é um gateway de agregação de modelos (um único endpoint que pode servir de proxy para diversos fornecedores de modelos). Para usá-lo no Cursor, você se cadastra no CometAPI, obtém uma chave de API e um identificador de modelo, adiciona essa chave e o endpoint às configurações de Modelos do Cursor como um provedor personalizado (substituindo a URL base) e seleciona o modelo do CometAPI no modo Composer/Agent.

Etapa A — Obtenha suas credenciais da CometAPI

1. Cadastre-se no CometAPI e criar uma chave de API a partir do painel de controle deles. Mantenha a chave em segredo (trate-a como qualquer token de portador).
2. Crie/copie uma chave de API e anote o nome/ID do modelo que deseja usar (por exemplo, claude-sonnet-4.5 ou outro modelo de fornecedor disponível através da CometAPI). Documentação/guias da API do Comet Descreva o processo e liste os nomes dos modelos suportados.

Etapa B — Adicione a CometAPI como um modelo/provedor personalizado no Cursor

1. Abrir cursor → Configurações → Modelos (ou Configurações → Chaves de API).
2. Se o cursor mostrar um “Adicionar modelo personalizado” or “Substituir URL base do OpenAI” opção, use-a:

• URL base / EndpointCole aqui a URL base da CometAPI compatível com OpenAI (a CometAPI informará se expõe uma URL base compatível com OpenAI). openai/v1 endpoint de estilo ou endpoint específico do provedor). (Exemplo: https://api.cometapi.com/v1 — Use o URL real da documentação da CometAPI.)
• Chave APICole sua chave CometAPI no campo "Chave de API".
• Nome do modelo: adicione o identificador do modelo exatamente como nos documentos da CometAPI (por exemplo, claude-sonnet-4.5 or composer-like-model).

3. verificar A conexão é estabelecida se o Cursor oferecer um botão "Verificar" / "Testar". O mecanismo de modelo personalizado do Cursor geralmente exige que o provedor seja compatível com OpenAI (ou que o Cursor aceite uma URL base + chave). Os guias da comunidade mostram o mesmo padrão (substituir URL base → fornecer chave → verificar).

Etapa C — Selecione o modelo CometAPI no Composer/Agente

1. Abra o Composer ou o Agent (atalho) Ctrl/Cmd + I ou o painel lateral).
2. Altere a seleção de modelo de Automático (ou seu modelo atual) para o provedor/modelo personalizado que você acabou de adicionar.
3. Inicie uma sessão do Composer ou crie um agente e confirme se ele responde usando o modelo CometAPI escolhido. Teste com um pequeno prompt (por exemplo, "pesquise no repositório e adicione testes unitários para as funções que falham"). tests/”) para validar o comportamento.

Conclusão: esta é uma atualização marcante?

O Cursor 2.0 não é apenas uma atualização de recursos; é uma tese de produto que combina um modelo de codificação desenvolvido especificamente para esse fim com primitivas de orquestração que tornam os fluxos de trabalho com agentes práticos. Os elementos surpreendentes — um modelo de agente próprio (Composer) explicitamente otimizado para velocidade, um ambiente de execução multiagente com mecanismos de isolamento concretos e integrações mais profundas com ferramentas, como um navegador GA — sinalizam uma maturidade na forma como a IA se integra à engenharia de software. Para equipes que prezam por revisões, testes e pela qualidade do fluxo de trabalho, o Cursor 2.0 oferece um caminho viável para iterações significativamente mais rápidas e maior automação de tarefas rotineiras de engenharia. Para o ecossistema mais amplo de desenvolvedores de IA, o foco do Cursor em orquestração de agentes e ferramentas provavelmente incentivará outros fornecedores a pensar além das interações com um único assistente e a considerar equipes de agentes, diretrizes operacionais e modelos que levam em conta a latência.