Atualização do Cursor AI de abril de 2026: o que mudou e o que realmente importa

Última atualização: 5 de maio de 2026

A atualização de abril de 2026 do Cursor é mais importante se utiliza ferramentas de IA para programar para mais do que autocomplete. A maior mudança não é um pequeno ajuste à interface nem uma atualização de modelo. É a evolução do Cursor para workflows de desenvolvimento mais orientados para agentes, sobretudo através de Background Agents, execução multietapa mais robusta e melhor suporte para tarefas de programação de longa duração.

Para os programadores, a verdadeira questão não é se o Cursor acrescentou novas funcionalidades. A questão é se essas mudanças tornam o Cursor materialmente melhor para trabalho real. Este guia foca-se nessa resposta prática: o que mudou, quem deve prestar atenção, onde o Cursor melhorou e onde continua a ficar aquém.

Resumo rápido

• A mudança mais importante do Cursor em 2026 é o suporte mais forte para workflows de programação orientados para agentes.
• Background Agents é a atualização que a maioria dos programadores deve avaliar primeiro.
• Esta versão é mais relevante para equipas e utilizadores avançados do que para quem usa apenas autocomplete leve.
• O Cursor melhorou de forma significativa, mas a escolha certa continua a depender do encaixe no workflow, da complexidade do repositório e das preferências de ferramentas.

O que mudou na atualização do Cursor AI de abril de 2026?

O ciclo de lançamentos de 2026 foi o passo mais claro do Cursor na transição de editor com IA para ambiente de desenvolvimento orientado para agentes. O tema central não é apenas melhores sugestões. É mais autonomia, melhor perceção de contexto e melhor suporte para workflows que se estendem por ficheiros, tarefas e tempo.

Tab Completion: para lá de linhas isoladas

O tab completion do Cursor — alimentado por um motor derivado do Supermaven com uma janela de contexto de 100.000 tokens — evoluiu muito para além de sugestões de uma única linha. Em 2026, o Cursor Tab prevê:

• Completações em múltiplas linhas com base no contexto do código à volta — corpos completos de funções, não apenas a linha seguinte
• Próximo local de edição depois de fazer uma alteração — o Cursor antecipa onde vai editar a seguir e posiciona lá o cursor
• Completação de boilerplate e padrões inferidos das convenções da sua codebase, não de modelos genéricos

O modelo que alimenta o tab completion é agora distinto do modelo de chat — optimizado para velocidade e contexto local, e não para profundidade de raciocínio. Esta separação significa que as completações se mantêm rápidas mesmo quando está a executar tarefas complexas do Agent mode em paralelo.

Exemplo prático. Escreva a assinatura de um método numa classe de repositório, e o Cursor prevê a implementação completa com base nos padrões já existentes:

class UserRepository:
    def __init__(self, db_connection):
        self.db = db_connection

    def get_user_by_email(self, email: str):
        # Cursor predicts the entire method body from here
        query = "SELECT * FROM users WHERE email = %s"
        cursor = self.db.cursor(dictionary=True)
        cursor.execute(query, (email,))
        result = cursor.fetchone()
        return result if result else None

Dica profissional: utilize Ctrl+Right Arrow (Windows/Linux) ou Cmd+Right Arrow (macOS) para aceitar as completações uma palavra de cada vez. Isto dá-lhe controlo mais granular sobre sugestões em múltiplas linhas sem assumir toda a previsão de uma só vez.

O que o tab completion não consegue fazer: funciona dentro de um único ficheiro. Não cria novos ficheiros, não executa comandos de terminal e não modifica nada para além do editor activo. Para trabalho em vários ficheiros, use o Agent mode.

Agent Mode: autonomia em várias etapas

O Agent mode representa o maior salto de capacidades do Cursor. Active-o através do alternador no Composer (Cmd+Shift+I / Ctrl+Shift+I), e o Cursor ganha permissão para:

• Ler múltiplos ficheiros em todo o projecto
• Escrever alterações e criar novos ficheiros
• Executar comandos de terminal e ler a respetiva saída
• Iterar com base nos resultados dos testes — autocorrigindo-se sem intervenção manual

Para que o Agent mode é mais indicado:

• Preparar novas funcionalidades de ponta a ponta
• Grandes refactorizações em vários ficheiros
• Sessões de depuração em que quer que ele leia logs de erro e itere
• Gerar boilerplate para um novo módulo

Para que não é adequado:

• Qualquer coisa que toque em infraestrutura de produção
• Alterações na lógica de autenticação ou segurança (reveja manualmente)
• Migrações de base de dados (reveja o SQL antes de aplicar)
• Alterações à configuração de CI/CD

Uma regra prática: trate o Agent mode como um programador júnior competente. Deixe-o trabalhar, mas reveja o resultado — sobretudo os comandos de terminal e qualquer coisa que toque em dados. As menções de contexto @file e @folder são a melhor ferramenta para manter o agente focado no código relevante.

Background Agents: assíncrono por defeito

Novo no Cursor v3.0, o Background Agents permite-lhe atribuir tarefas que correm de forma assíncrona enquanto continua a editar. Define a tarefa, o Cursor trabalha em segundo plano e recebe uma notificação na barra de estado quando termina.

Isto é ideal para operações longas — refactorizar um módulo, executar uma suite completa de testes ou gerar documentação — que, de outra forma, exigiriam a sua atenção total. No plano Business, os Cloud Agents vão mais longe, executando estas tarefas na infraestrutura cloud da Anysphere em ambientes isolados em sandbox, libertando completamente a sua máquina local.

Plan Mode: pensar antes de construir

O Plan Mode, introduzido no Cursor v2.0 juntamente com o modelo Composer, muda a forma de iniciar trabalho complexo. Em vez de dar um prompt ao agente e esperar que ele se mantenha no rumo certo, o Plan Mode:

1. Percorre o projecto — lendo documentação, regras e estrutura de código
2. Faz perguntas de clarificação (versão-alvo do Node, fornecedor de autenticação, SSR vs. client)
3. Gera um plano em Markdown editável com caminhos de ficheiros, referências de código e lista de tarefas
4. Permite-lhe refinar o plano, guardá-lo no repositório e só depois executá-lo

O plano torna-se um artefacto duradouro que sobrevive à janela de chat. O agente referencia-o ao longo da execução, o que reduz drasticamente a dinâmica de “dar o prompt e rezar”. Para funcionalidades grandes, refactorizações ou qualquer coisa transversal, o Plan Mode produz resultados melhores de forma consistente do que prompts crus no Agent mode.

.cursorrules: a constituição de IA do seu projecto

O ficheiro .cursorrules fica na raiz do projecto e fornece contexto persistente e específico do projecto a cada interacção com IA — Tab completion, edições inline com Cmd+K, Chat, Composer e Agent mode. Nunca precisa de voltar a explicar a sua stack, convenções de nomes ou regras de arquitectura entre sessões.

Um ficheiro .cursorrules fraco:

Use TypeScript. Follow best practices. Write clean code.

Isto é quase inútil — a IA já conhece TypeScript, e “best practices” sem contexto não diz praticamente nada.

Um ficheiro .cursorrules forte diz à IA exactamente que bibliotecas usar e evitar, documenta decisões de arquitectura, assinala restrições críticas e estabelece convenções de nomenclatura:

# Project: TaskFlow API

## Stack
- Runtime: Node.js 22 with TypeScript 5.4
- Framework: Hono (not Express, not Fastify)
- Database: PostgreSQL 16 via Drizzle ORM (not Prisma)
- Auth: Better Auth v1
- Validation: Zod throughout, no exceptions
- Testing: Vitest, not Jest

## Architecture
- Monorepo structure: /apps/api, /apps/web, /packages/shared
- All shared types live in /packages/shared/types
- Repository pattern for all database access
- Service layer between routes and repositories

## Code Style
- Named exports over default exports everywhere
- No any types. Use unknown and narrow properly
- All async functions must have explicit return types

## Multi-tenancy Rules (critical)
- Every table holding user data has an organisationId column
- Every query must scope to the authenticated user's organisationId
- Never trust client-provided organisationId — derive from session

## When Adding New Features
1. Define types in /packages/shared/types first
2. Update database schema, run migrations
3. Write repository, then service, then route handler
4. Write tests before considering the feature complete

Quando tem um .cursorrules com este nível de detalhe, as sugestões da IA alinham-se com o seu projecto real em vez de gerarem código genérico. Faça commit do ficheiro para controlo de versões para que toda a equipa beneficie de um comportamento de IA consistente.

Para templates prontos e exemplos da comunidade, o Cursor Directory é um excelente recurso.

Integração MCP: ligar o Cursor à sua stack

O suporte para MCP (Model Context Protocol) permite que a IA do Cursor vá para lá do editor e aceda a fontes de dados e serviços externos. Com servidores MCP configurados, o Cursor pode:

• Consultar o esquema real da sua base de dados antes de escrever código (Postgres, Supabase)
• Ler issues e PRs do GitHub ou do Linear para compreender requisitos
• Aceder à documentação interna da equipa para referenciar decisões reais
• Chamar as suas próprias APIs internas como parte de uma sessão de programação

Configurar um servidor MCP é simples — basta adicioná-lo ao JSON de definições do Cursor:

{
  "mcpServers": {
    "supabase": {
      "command": "npx",
      "args": ["-y", "@supabase/mcp-server-supabase@latest"],
      "env": {
        "SUPABASE_URL": "https://yourproject.supabase.co",
        "SUPABASE_SERVICE_ROLE_KEY": "your-key"
      }
    },
    "github": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-github"],
      "env": {
        "GITHUB_PERSONAL_ACCESS_TOKEN": "your-token"
      }
    }
  }
}

Com MCP, o Cursor deixa de adivinhar aquilo que pode consultar. Um prompt como “Verifica o esquema actual e escreve uma query Drizzle que faça join entre users, organisations e memberships” passa a produzir código compatível com a sua base de dados real, e não uma suposição.

Quem deve prestar atenção a esta atualização do Cursor?

Esta versão é mais importante para programadores que usam o Cursor como algo mais do que um assistente de autocomplete. Se o seu workflow inclui edições em múltiplos ficheiros, tarefas de implementação mais longas ou padrões de programação orientados para agentes, então Background Agents e as melhorias relacionadas são as actualizações a avaliar primeiro.

Se usa o Cursor apenas para completação inline leve, o impacto prático é menor. Quanto mais o seu workflow depender de execução assíncrona, contexto de repositório e ciclos de programação assistidos por ferramentas, mais significativa esta atualização se torna.

Cursor vs. alternativas: quando usar o quê

O panorama das ferramentas de IA para programação em 2026 está cheio. Eis como o Cursor se compara com as duas alternativas mais comuns.

Cursor vs. Claude Code

Tanto o Cursor como o Claude Code são excelentes. A escolha depende de querer um parceiro autónomo ou um copiloto de precisão.

Escolha o Cursor se: valoriza o ecossistema do VS Code, precisa de revisão visual de diffs, quer flexibilidade multimodelo e prefere manter controlo apertado sobre alterações geradas por IA.

Escolha o Claude Code se: trabalha sobretudo no terminal, gere codebases grandes que beneficiam de execução autónoma em várias etapas e prefere especificar resultados em vez de supervisionar edições.

Muitos programadores usam ambos: Cursor para programação diária com tab completion e edição inline, Claude Code para tarefas agentic longas e automação CI/CD.

Cursor vs. GitHub Copilot

GitHub Copilot e Cursor seguem abordagens fundamentalmente diferentes à programação assistida por IA.

A vantagem do Cursor é ter sido reconstruído de raiz em torno de IA, enquanto o Copilot acrescenta IA a editores já existentes. Isto vê-se com maior clareza nos workflows com múltiplos ficheiros: o Composer do Cursor cria, modifica e coordena alterações entre ficheiros numa única sessão, enquanto as funcionalidades equivalentes do Copilot ainda estão a amadurecer. Para programadores que passam a maior parte do dia no editor, a integração mais profunda do Cursor tende a ganhar. Para equipas profundamente inseridas no ecossistema GitHub, a integração nativa do Copilot com Issues, PRs e Actions pode ser apelativa.

Guia de resolução de problemas do Cursor

Erros de ligação: 5 soluções que funcionam

Erros de ligação durante completações ou no chat são o problema do Cursor mais pesquisado. A causa de raiz é quase sempre relacionada com a rede — o Cursor requer acesso directo às APIs dos fornecedores de IA.

Causas mais comuns:

1. Interferência de VPN — VPNs com deep packet inspection podem bloquear ou limitar chamadas de API
2. Bloqueio por firewall corporativa — redes empresariais podem restringir o acesso a endpoints de fornecedores de IA
3. Rate limits — completações muito frequentes podem activar limitação temporária
4. Disponibilidade do modelo — problemas ocasionais a montante na disponibilidade dos modelos

Soluções a testar por ordem:

1. Verifique cursor.sh/status para incidentes de serviço
2. Mude para outro modelo: Settings → Models → seleccione uma alternativa
3. Desactive temporariamente a VPN e teste
4. Reinicie o Cursor por completo — feche a aplicação, não apenas a janela
5. Termine a sessão e volte a iniciar para actualizar os tokens de autenticação

Se nada disto resolver o problema, confirme que cursor.com, api.cursor.sh e os endpoints do fornecedor de IA seleccionado (api.anthropic.com, api.openai.com) estão na whitelist da sua firewall ou configuração de proxy.

Desempenho: quando o Cursor parece lento

Se o Cursor ficar lento no uso diário:

• Reduza os ficheiros abertos no contexto. Cada separador aberto consome recursos de indexação. Feche ficheiros que não está a editar activamente.
• Desactive a indexação para directórios grandes. Settings → Indexing → adicione caminhos ao .cursorignore para node_modules/, dist/, build/ e outros directórios gerados.
• Verifique tarefas em segundo plano. View → Background Agents para ver se operações longas estão a consumir recursos.
• Reinicie periodicamente. Em projectos intensivos, um reinício diário repõe a acumulação de memória dos processos de extension host e indexador.

Para máquinas com 8 GB de RAM, feche outras aplicações exigentes em memória antes de executar o Agent mode em projectos grandes. O mínimo recomendado para uma utilização confortável do Cursor é 16 GB, sendo 32 GB aconselháveis para monorepos.

Tab completions não aparecem

Se o ghost text deixar de aparecer enquanto escreve:

1. Verifique em Settings → Features → Cursor Tab se o alternador está activo
2. Vá a Settings → Account para ver as completações mensais restantes (escalão gratuito: 2.000/mês)
3. Confirme que o motor de completação terminou a inicialização — projectos grandes podem demorar vários minutos na primeira abertura
4. Verifique em Settings → AI → Autocomplete → Disabled Languages se houve exclusões acidentais

Agent mode entra em loop ou bloqueia

Se uma tarefa do Agent mode correr indefinidamente sem progresso visível:

1. Clique em “Pause Agent” no painel do Composer
2. Reveja o log de acções do agente para identificar onde ficou preso
3. Intervenha manualmente — corrija o erro subjacente, esclareça o requisito ou actualize uma dependência
4. Retome com um âmbito mais restrito, ou reinicie a tarefa dividindo-a em subtarefas menores

O Agent mode funciona melhor com prompts bem delimitados. “Refactor the auth module” costuma bloquear; “Refactor the JWT validation in src/middleware/auth.ts to use the new token service pattern from src/services/tokenService.ts” raramente o faz.

Dicas avançadas e boas práticas do Cursor

Templates de .cursorrules para stacks comuns

Para um projecto Next.js App Router:

## Routing
- Always use App Router, never Pages Router
- Server Components are the default. Only add 'use client' when needed
- Data fetching belongs in Server Components, not useEffect
- Loading states use loading.tsx files

## State Management
- Zustand for global client state
- React Query (TanStack Query) for server state and caching
- No Redux under any circumstances

## Styling
- Tailwind CSS only
- shadcn/ui components as the base layer
- No styled-components, no CSS modules

Para um projecto Python FastAPI:

## Stack
- Python 3.12
- FastAPI with async throughout
- SQLAlchemy 2.0 (async) with Alembic for migrations
- Pydantic v2 for all schemas
- pytest with pytest-asyncio for tests

## Conventions
- All route handlers are async
- Dependency injection via FastAPI's Depends()
- No business logic in route handlers — delegate to service layer
- Type hints mandatory on all function signatures
- Use Python 3.10+ union types (X | None) not Optional[X]

Para um monorepo TypeScript genérico:

## Code Style
- Named exports over default exports everywhere
- Prefer interface over type for object shapes
- No any types. Use unknown and narrow properly
- All API responses use the ApiResponse<T> wrapper
- Never hardcode secrets; always read from environment variables

## Testing
- Vitest with describe/it blocks
- Test files adjacent to source: userService.test.ts next to userService.ts
- Mock external services with msw
- Every public function requires a corresponding unit test

Gestão da janela de contexto

A qualidade das sugestões de IA degrada-se quando a janela de contexto fica cheia de conteúdo irrelevante. Utilizadores eficazes do Cursor são deliberados sobre aquilo que a IA vê:

• Use @file com precisão, não de forma ampla. @codebase é útil para descoberta (“onde tratamos X?”), mas ruidoso para implementação. Depois de identificar os ficheiros relevantes, mude para menções específicas de @file.
• Divida tarefas grandes em sessões focadas. Uma refactorização de 500 linhas em 20 ficheiros numa única sessão produzirá pior resultado do que a mesma refactorização feita em cinco sessões focadas de 100 linhas.
• Comece sessões novas para novas funcionalidades. O contexto da conversa anterior é ruído para uma nova tarefa. O seu .cursorrules e o índice da codebase persistem, por isso não perde contexto do projecto — apenas o histórico irrelevante.
• Use /summarize quando o contexto crescer demasiado. O Cursor pode resumir a conversa actual para preservar decisões importantes enquanto liberta espaço na janela de contexto.

Atalhos de teclado que poupam horas

Estender o Cursor para lá do código

O Cursor lida excepcionalmente bem com raciocínio sobre código. Mas foi construído para editar código — não para gerar imagens, pesquisar na web, produzir vídeos ou publicar conteúdo.

Os cenários mais comuns em que os utilizadores do Cursor encontram esta limitação:

• Desenvolvimento de UI: precisa de uma imagem hero ou mockup, mas o Cursor não consegue gerar visuais
• Investigação técnica: precisa de documentação actual, mas o conhecimento do Cursor está congelado no seu cutoff de treino
• Publicação de conteúdo: já construiu algo, mas publicar uma página ou partilhar resultados exige sair do editor
• Criação de demos: quer gravar uma demonstração do produto, mas o Cursor não produz vídeo

Tornar o Cursor mais capaz com o AnyCap

O AnyCap é uma agent CLI que se liga directamente ao Cursor, dando-lhe capacidades que ele nunca foi concebido para tratar de forma nativa. Depois de instalado, o agente do Cursor passa a conseguir gerar imagens, pesquisar na web, criar vídeos e publicar páginas — tudo sem sair do seu fluxo de desenvolvimento.

Pense nisto como dar ao Cursor um conjunto extra de ferramentas a que pode recorrer, da mesma forma que já recorre ao terminal, ao sistema de ficheiros e ao índice da codebase. Quando pede ao Cursor para gerar uma imagem hero para uma landing page, ele delega no AnyCap. Quando pede a documentação mais recente sobre uma alteração de API com breaking changes, o AnyCap pesquisa na web e devolve os resultados ao contexto do Cursor. O agente continua no lugar do condutor — o AnyCap apenas expande aquilo que ele consegue fazer.

# Install AnyCap (agent CLI)
curl -fsSL https://anycap.ai/install.sh | sh

# Add the AnyCap skill to Cursor — Cursor recognizes it automatically
npx -y skills add anycap-ai/anycap -a cursor -y

# Restart Cursor after installation

Depois de instalado, pode pedir directamente ao Cursor:

“Gera uma imagem hero para esta landing page e guarda-a em src/assets/”

O Cursor delega no AnyCap, que trata da geração da imagem e devolve o resultado — tudo dentro da mesma conversa do agente. Sem trocar de separador, sem perder contexto.

“Pesquisa na web o guia mais recente de migração do Prisma v6 — preciso de saber as breaking changes”

O AnyCap obtém documentação actual e introduz essa informação na janela de contexto do Cursor, para que o agente programe com informação real e actualizada, em vez de depender apenas do seu cutoff de treino.

“Cria um vídeo demo a mostrar como este fluxo de autenticação funciona”

O AnyCap produz o vídeo. O Cursor mantém-se focado no código enquanto o AnyCap trata de tudo o que está fora do âmbito nativo do editor.

Para programadores que vivem no Cursor o dia todo, isto elimina o atrito de mudar para ferramentas separadas para media, investigação e publicação. O Cursor torna-se a interface única para todo o workflow de desenvolvimento — não apenas para o código.

Perguntas frequentes

O Cursor substitui competências de programador?

Não. O Cursor acelera tarefas repetitivas e cria scaffolds rapidamente, mas continua a ser o programador a desenhar sistemas, rever diffs e assumir a responsabilidade pela correcção. Trate-o como um pair programmer rápido e conhecedor — não como autoridade. A competência mais importante com o Cursor não é escrever código, mas sim ler e avaliar código.

Em que é que o Cursor é diferente do VS Code com Copilot?

O Cursor é um fork do VS Code nativo de IA — reconstruído com a IA como principal modelo de interacção. O Copilot acrescenta IA como plugin a editores existentes. A integração mais profunda do Cursor vê-se em workflows com múltiplos ficheiros (Composer), contexto ao nível do projecto (.cursorrules + índice semântico) e capacidades autónomas (Agent mode, Background Agents).

Que plano do Cursor devo escolher?

O escalão Free (2.000 completações/mês) é adequado para avaliação, mas esgota-se rapidamente no uso profissional diário. O Pro (20 dólares/mês) oferece Tab completion ilimitado e limites alargados para Agent — é o escalão certo para a maioria dos programadores profissionais. O Pro+ (60 dólares/mês) acrescenta 3x de utilização em modelos suportados. O Business (40 dólares/utilizador/mês) acrescenta SSO, aplicação de privacidade em toda a organização e Cloud Agents.

O Cursor suporta a minha linguagem de programação?

O Cursor herda o suporte linguístico do VS Code através do seu ecossistema de extensões. Se uma linguagem tiver uma extensão do VS Code — syntax highlighting, language server, debugger — então funciona no Cursor. As funcionalidades de IA são agnósticas em relação à linguagem e funcionam melhor com linguagens populares como TypeScript, Python, Rust, Go e Java, onde há mais dados de treino.

Posso usar as minhas próprias chaves de API com o Cursor?

Sim. Em Settings → AI → API Keys, pode fornecer as suas próprias chaves da OpenAI, Anthropic ou Google. Ao usar as suas próprias chaves, contorna o sistema de alocação de modelos do Cursor e a cobrança é feita directamente na conta do fornecedor. Isto é útil para equipas com contratos enterprise já existentes ou requisitos específicos de conformidade.

O meu código é privado quando uso o Cursor?

Active o Privacy Mode em Cursor Settings → Privacy. Neste modo, o seu código não é armazenado nos servidores da Anysphere depois de o pedido à API terminar. Subscritores do plano Business podem impor o privacy mode a toda a organização. Se trabalha com código proprietário, sectores regulados ou sob NDA, active esta definição.

Como é que o Cursor lida com codebases muito grandes?

O Cursor indexa a sua codebase semanticamente e expõe-a através da menção @codebase. Para monorepos ou projectos com centenas de milhares de ficheiros, crie um ficheiro .cursorignore para excluir directórios não-source como node_modules/, dist/, build/, .next/ e outros. O índice semântico é o que faz as queries @codebase funcionarem bem — não é pesquisa full-text, por isso é importante mantê-lo limpo de ficheiros gerados.

Qual é a diferença entre Chat, Composer e Agent mode?

• Chat (Cmd+L): interface conversacional para perguntas sobre a codebase, explicações e planeamento
• Composer (Cmd+Shift+I): edição em múltiplos ficheiros com revisão de diffs antes de aplicar as alterações
• Agent mode (alternador dentro do Composer): execução autónoma — lê ficheiros, escreve alterações, executa comandos de terminal e itera sem aprovação mudança a mudança

Resumo

Em 2026, o Cursor já não é apenas “VS Code com IA”. Com Agent mode, Background Agents, Plan Mode, integração MCP e a constituição de projecto .cursorrules, tornou-se uma plataforma de desenvolvimento em que a camada de raciocínio da IA é a principal preocupação e o editor é a interface.

Os programadores que tiram mais partido do Cursor investem em competências complementares: escrever prompts precisos, manter ficheiros .cursorrules sólidos, gerir contexto de forma deliberada e rever código gerado por IA com o mesmo rigor que aplicariam ao trabalho de qualquer colaborador. O Cursor trata de grande parte do como. O quê e o porquê continuam a ser inteiramente seus.

Escrito pela equipa da AnyCap. O AnyCap é uma agent CLI que se liga ao Cursor e a outras ferramentas de IA para programação, acrescentando geração de imagens, pesquisa na web, criação de vídeos e publicação directamente no workflow do seu agente — para que o Cursor possa fazer mais sem que tenha de sair do editor. Saiba mais sobre o AnyCap para Cursor.