# Guia Definitivo: Cursor

> Tudo sobre o Cursor IDE — instalação, agent mode, créditos, MCP servers, planos e como tirar o máximo da IDE mais popular de 2026.

Source: https://agentify.ia.br/blog/cursor/

Quando você abre o Cursor pela primeira vez, a sensação é de um VS Code que já nasceu sabendo programar. E não é coincidência — o Cursor é literalmente um fork do VS Code, mas com IA integrada em cada interação: autocompletar, edição multi-arquivo, agentes autônomos e um sistema de indexação que entende seu repositório inteiro. Com mais de um milhão de desenvolvedores pagantes e receita anualizada acima de US$ 1 bilhão, o Cursor se consolidou como a IDE de referência para quem trabalha com agentes de codificação em 2026.

Este guia cobre tudo: da instalação ao uso avançado com MCP servers, passando pelo controverso modelo de créditos e as novidades do Cursor 3.0.

## Overview

### O que é o Cursor

O Cursor é uma IDE standalone desenvolvida pela Anysphere, construída sobre um fork do VS Code. Isso significa que você mantém todas as extensões, keybindings e temas que já usa — mas ganha uma camada de IA profundamente integrada que vai muito além de um plugin.

Diferente do GitHub Copilot (que é uma extensão adicionada ao seu editor), o Cursor controla o ambiente inteiro. Isso permite funcionalidades que plugins simplesmente não conseguem oferecer: indexação semântica do codebase completo, edições coordenadas em múltiplos arquivos, e agentes em background que trabalham enquanto você faz outra coisa.

### Posicionamento no mercado

Em maio de 2026, o Cursor está avaliado em US$ 29,3 bilhões após sua Series D e é usado por 64% das empresas Fortune 500. O cenário competitivo inclui:

- **GitHub Copilot** — plugin que funciona em qualquer editor, a US$ 10/mês

- **Windsurf** — IDE similar (também fork do VS Code), a US$ 20/mês

- **Claude Code** — agente de terminal da Anthropic, complementar ao Cursor

- **Cline** — extensão open-source para VS Code, gratuita (BYO keys)

O diferencial do Cursor é a profundidade da integração: o agente não apenas sugere código — ele lê seu repositório, executa comandos no terminal, navega na web, e itera sobre seus próprios erros.

### Cursor 3.0: a era dos agentes

Em 2 de abril de 2026, o Cursor 3.0 mudou fundamentalmente o que “Cursor” significa. A nova versão introduziu a **Agents Window** — uma interface dedicada construída em torno de agentes, não de arquivos. O IDE tradicional ainda existe (e você pode usar ambos simultaneamente), mas a mensagem é clara: o agente é a unidade de trabalho, não o arquivo.

Novidades do 3.0:

- **Agents Window** — execute múltiplos agentes em paralelo (local, cloud, worktrees, SSH remoto)

- **Design Mode** — selecione elementos visuais no browser integrado e alimente o agente com contexto visual

- **`/best-of-n`** — rode a mesma tarefa em múltiplos modelos simultaneamente, cada um em seu worktree isolado

- **`/worktree`** — agente trabalha em checkout isolado sem tocar seu branch principal

- **Cloud agents** — tarefas longas rodam em VMs Ubuntu na nuvem; resultados ficam esperando quando você volta

- **Composer 2** — modelo próprio do Cursor (baseado em Kimi K2.5), otimizado para coding agentic

[IMAGEM: Interface do Cursor 3.0 mostrando a Agents Window com múltiplos agentes rodando em paralelo]

## Tutorial

### Instalação

O Cursor está disponível para macOS, Windows e Linux. A instalação é direta:

- Acesse [cursor.com](https://cursor.com) e baixe o instalador para seu sistema

- Execute o instalador — no Linux, é um `.AppImage` ou `.deb`

- Na primeira execução, o Cursor oferece importar suas configurações do VS Code

```
# Linux (Debian/Ubuntu)
sudo dpkg -i cursor_*.deb

# Ou via AppImage
chmod +x cursor-*.AppImage
./cursor-*.AppImage
```

### Migração do VS Code

A migração é praticamente automática. Na primeira abertura, o Cursor detecta sua instalação do VS Code e oferece importar:

- **Extensões** — todas as extensões compatíveis com VS Code funcionam no Cursor

- **Keybindings** — seus atalhos personalizados são preservados

- **Settings** — `settings.json` é importado integralmente

- **Temas** — seu tema atual vem junto

A comunidade reporta que a migração completa leva menos de 10 minutos. Você pode manter ambos instalados sem conflito — o Cursor usa diretórios de configuração separados.

**Dica**: se você usa extensões que dependem de APIs específicas do VS Code (como algumas extensões de debug), teste-as após a migração. A grande maioria funciona sem problemas, mas edge cases existem.

### Primeiro uso: os três modos

O Cursor opera em três modos de interação com IA, e entender quando usar cada um é a diferença entre resultados excelentes e frustrantes.

#### Ask Mode (Ctrl+L)

Ask é somente leitura. Ele pesquisa seu codebase, responde perguntas, explica código e elabora planos — mas nunca escreve um arquivo. Use para:

- Explorar código desconhecido: “como funciona o fluxo de autenticação neste serviço?”

- Planejar antes de implementar: “qual a melhor abordagem para adicionar rate limiting aqui?”

- Obter segunda opinião sobre design

```
Prompt exemplo (Ask mode):
"Analise a estrutura de rotas em src/api/ e sugira como
organizar um novo módulo de notificações seguindo o mesmo padrão."
```

#### Agent Mode (Ctrl+I)

Agent é o modo autônomo. Você descreve uma tarefa; o Cursor lê arquivos, edita múltiplos arquivos, executa comandos no terminal, consulta a web se necessário, e itera sobre erros. É onde a mágica acontece — e também onde runs ruins saem dos trilhos.

O Agent mode recompensa tarefas bem delimitadas com critérios claros de aceitação:

```
✅ Bom prompt para Agent:
"Adicione um middleware de rate-limit na rota /api/ingest.
Use express-rate-limit com limite de 100 requests/15min.
Escreva um teste com Vitest. Rode os testes."

❌ Prompt vago:
"Melhore o código de autenticação."
```

#### Manual Edit Mode

Manual (anteriormente chamado “Composer” em versões mais antigas) é para edições cirúrgicas em múltiplos arquivos onde você quer que o modelo proponha mudanças mas não execute comandos ou saia do escopo. Ideal quando você sabe exatamente o que quer alterado.

### O padrão que funciona

A sequência que consistentemente produz os melhores resultados:

- **Explore em Ask** — entenda o contexto

- **Planeje em Ask** — elabore a abordagem sem escrever código

- **Implemente em Agent** — execute o plano com escopo definido

- **Refine em Manual** — ajustes cirúrgicos no resultado

Pular o Ask é a causa mais comum de “o Cursor escreveu lixo” que desenvolvedores reportam.

[IMAGEM: Fluxo de trabalho mostrando a progressão Ask → Agent → Manual com exemplos de cada etapa]

### Uso intermediário: cenário real

Vamos a um exemplo concreto — adicionar upload de arquivos com virus scanning a uma API Next.js:

**Passo 1 — Ask mode:**

```
"Onde o pipeline de upload atualmente coloca os arquivos,
e onde geramos signed URLs?"
```

**Passo 2 — Ainda em Ask:**

```
"Elabore um plano para adicionar virus scanning server-side
antes de gerar a signed URL. Não escreva código ainda."
```

**Passo 3 — Agent mode (com o plano no contexto):**

```
"Implemente apenas o passo 1 do plano.
Pare após o teste unitário passar."
```

**Passo 4 — Revise o diff linha por linha.** Rejeite qualquer coisa que tocou arquivos fora do escopo planejado.

**Passo 5 — Repita para os passos 2 e 3.**

### Configuração avançada: Cursor Rules

Rules são o maior alavanca para fazer o Cursor parar de alucinar no seu codebase. O formato legado `.cursorrules` na raiz do repo foi substituído por **Project Rules**: arquivos `.mdc` dentro de `.cursor/rules/`, versionados por projeto e com escopo por glob patterns.

Exemplo de uma rule eficaz:

```
<!-- .cursor/rules/api-patterns.mdc -->
---
description: Padrões para rotas de API
globs: ["src/api/**/*.ts"]
---

## Convenções de API

- Use o padrão de handler em `src/api/users/route.ts` como referência
- Sempre valide input com Zod antes de processar
- Retorne erros no formato `{ error: string, code: number }`
- Nunca delete `.env` ou `package.json` sem confirmação
- Rode `npm run typecheck && npm run test` antes de declarar concluído
- Se encontrar um problema de segurança, pare e reporte
```

**O que boas rules incluem em 2026:**

- Referências a arquivos canônicos (em vez de inlinar padrões)

- Guardrails explícitos (o que o agente NÃO deve fazer)

- Comandos de verificação (lint, typecheck, test)

- Condições de parada

- Tom e verbosidade esperados

Times que vão de “30% de sugestões aceitas” para “80%+” quase sempre fizeram o salto escrevendo rules focadas, não trocando de modelo.

## Deep Dive

### Modelo de créditos (desde junho 2025)

Em junho de 2025, o Cursor substituiu o modelo simples de “500 fast requests por mês” por um sistema baseado em créditos. A mudança foi controversa — a comunicação foi ruim, cobranças inesperadas apareceram, e o Cursor emitiu um pedido público de desculpas em 4 de julho de 2025, oferecendo reembolsos.

**Como funciona hoje:**

Cada plano pago inclui um pool de créditos igual ao valor da assinatura. Quando você usa features de IA, créditos são consumidos baseado no modelo escolhido e na complexidade da request.

**O que NÃO consome créditos significativamente:**

- Tab completions (autocomplete)

- Auto mode (Cursor escolhe o modelo automaticamente)

**O que consome créditos rapidamente:**

- Selecionar manualmente Claude Opus, GPT-5.x ou Gemini Pro

- Context windows grandes (apontar o Cursor para muitos arquivos)

- Tarefas complexas de Agent multi-arquivo

- Runs de Background Agent

**O insight chave:** se você ficar no Auto mode e Tab completions, o Pro é efetivamente ilimitado para a maioria dos casos. O sistema de créditos só morde quando você manualmente seleciona os modelos frontier mais caros em tarefas pesadas.

Quando seu pool se esgota, você pode pagar por uso adicional a taxas de API ou mudar para Auto mode pelo resto do mês.

**Impacto prático:** o mesmo Pro de US$ 20 que antes parecia “all-you-can-eat” agora visivelmente drena durante sessões pesadas com Opus. Desenvolvedores no plano Pro que rodam sessões frequentes de Agent reportam gasto real mais próximo de US$ 40-50/mês com overages.

### Modelos disponíveis

O Cursor oferece acesso a modelos frontier de múltiplos providers, roteados via sua infraestrutura:

 Modelo Melhor para Custo relativo Composer 2 (próprio) Tarefas agentic de coding, rápido e barato Baixo Claude Opus 4.7 Arquitetura, refactors profundos, debugging complexo Alto GPT-5.5 Coding geral, versatilidade Médio-alto DeepSeek V4 Pro Reasoning a custo baixo, tarefas em volume Baixo Gemini 2.5 Pro Contexto longo (1M+ tokens), passes em repo inteiro Médio

#### Composer 2: o modelo próprio

Lançado em 19 de março de 2026, o Composer 2 é o modelo que alimenta os agentes no novo workspace. Construído sobre uma base Kimi K2.5 da Moonshot AI, com continued pretraining e reinforcement learning 4x.

Números relevantes:

- **Velocidade**: 200+ tokens/segundo

- **Context window**: 200.000 tokens com auto-sumarização

- **Custo**: ~90% mais barato que Claude Opus por token

- **Pricing**: US$ 0,50/1M tokens input (standard) ou US$ 1,50/1M (fast)

O Composer 2 tem seu próprio pool de uso separado dos créditos para modelos frontier selecionados manualmente.

#### Endpoints customizados

Você pode trazer qualquer API OpenAI-compatible para dentro do Cursor: insira nome, base URL e key, e o modelo aparece no picker. Cobranças vão direto para sua conta no provider, bypassando o pool de créditos do Cursor.

Casos de uso comuns:

- Endpoint self-hosted de DeepSeek ou Llama na sua infra

- OpenRouter ou Together para modelos que o Cursor não curou

- Setup privacy-sensitive onde toda request precisa ir para seu VPC

### Indexação do codebase

Quando você abre um repositório, o Cursor:

- Chunka arquivos localmente

- Computa uma Merkle tree de hashes

- Sincroniza hashes com o servidor

- Produz embeddings (armazenados no Turbopuffer, um vector DB remoto)

- Usa os embeddings para recuperar chunks semanticamente relevantes em cada query

Re-indexar o mesmo repo é rápido porque chunks são cacheados por hash. Paths são ofuscados via encriptação por segmento — mesmo com o índice “na nuvem”, sua estrutura de pastas não fica em plaintext no servidor.

**Dica crítica para monorepos:** sem um `.cursorignore` bem configurado, indexar um monorepo de 1M+ arquivos pode saturar disk IO por 5-15 minutos. Com um, são 10-30 segundos.

```
# .cursorignore
node_modules/
dist/
build/
.next/
coverage/
*.generated.*
```

### Privacy Mode

Com Privacy Mode ativado, o backend do Cursor não retém código ou dados após processar uma request. Nenhum código plaintext é persistido server-side; é buscado apenas no momento da inferência, apenas para os arquivos específicos que a request precisa, e descartado depois.

O Cursor mantém acordos de zero-data-retention com todos os model providers que roteia. Para trabalho regulado, Privacy Mode é o mínimo; Enterprise adiciona enforcement org-wide e audit logging.

## Integrações

### MCP Servers

Model Context Protocol (MCP) é o padrão para plugar ferramentas e fontes de dados externas em clientes de IA. O suporte do Cursor a MCP amadureceu de “brinquedo de power user” em 2024 para “feature de primeira classe com one-click install” em 2026.

**Como funciona na prática:**

- **Três tipos de transporte:** stdio (mais simples, local), SSE, e Streamable HTTP

- **Dois escopos:** global (`Cursor Settings → Tools & MCP`) ou por projeto via `.cursor/mcp.json`

- **One-click installs** do catálogo curado (GitHub, Linear, Sentry, Postgres, Notion, Stripe, etc.)

- **Limite de 40 tools** por sessão — exceda e o Cursor para de expor tools adicionais ao modelo

```
// .cursor/mcp.json (exemplo por projeto)
{
 "mcpServers": {
 "github": {
 "command": "npx",
 "args": ["-y", "@modelcontextprotocol/server-github"],
 "env": {
 "GITHUB_TOKEN": "env:GITHUB_TOKEN"
 }
 },
 "postgres": {
 "command": "npx",
 "args": ["-y", "@modelcontextprotocol/server-postgres"],
 "env": {
 "DATABASE_URL": "env:DATABASE_URL"
 }
 }
 }
}
```

**Combinação que entrega mais valor:**

- **GitHub** — PRs, issues, code search

- **Database** (Postgres ou seu warehouse) — read-only por padrão

- **Docs-search** (Notion, Confluence) — documentação interna

- **Linear/Jira** — tickets e contexto de produto

- **Playwright** — quando o agente precisa navegar um browser

Cinco servers, bem abaixo do limite de 40 tools, e o agente para de precisar perguntar por contexto que ele pode buscar sozinho.

### Extensões VS Code compatíveis

Por ser um fork do VS Code, o Cursor suporta o ecossistema inteiro de extensões. Extensões populares que funcionam sem problemas:

- **Prettier, ESLint, Biome** — formatação e linting

- **GitLens** — histórico e blame

- **Docker** — containers

- **Prisma, Drizzle** — ORMs

- **Tailwind CSS IntelliSense** — autocomplete de classes

- **Thunder Client, REST Client** — testes de API

- **Language servers** (Python, Go, Rust, etc.)

**Exceções conhecidas:** algumas extensões que dependem de APIs internas muito específicas do VS Code podem ter comportamento inesperado. Teste após migrar.

### Cursor Marketplace

Além das extensões VS Code, o Cursor tem seu próprio Marketplace de plugins que adicionam capacidades ao agente:

- **Skills** — prompts que agentes podem invocar sob demanda

- **Subagents** — agentes especializados

- **MCP servers** — com OAuth integrado

- **Hooks** — automações pré/pós ação

- **Rules** — regras compartilháveis

Plugins disponíveis incluem: AWS, Figma, Linear, Stripe, Vercel, Datadog, Snowflake, entre outros.

[IMAGEM: Cursor Marketplace mostrando plugins disponíveis com categorias e one-click install]

### Automations

Lançadas em 5 de março de 2026, Automations são agentes always-on disparados por eventos externos:

- Schedules (cron)

- Mensagens no Slack

- Issues no Linear

- Eventos no GitHub

- Incidentes no PagerDuty

O agente sobe um sandbox cloud e segue instruções usando MCPs e modelos configurados. Com memory ativada, o agente mantém notas persistentes entre runs (como um `MEMORIES.md`).

## Planos e Preços

 Plano Preço Melhor para Inclui Hobby Grátis Avaliação Completions e agent requests limitados Pro US$ 20/mês Devs individuais Pool de US$ 20 em créditos, todos os modelos frontier, cloud agents, Tab ilimitado Pro+ US$ 60/mês Heavy users 3x créditos do Pro (pool de ~US$ 70) Ultra US$ 200/mês Dev AI-native full-time 20x créditos, acesso prioritário a features Teams US$ 40/user/mês Times de engenharia Billing centralizado, rules compartilhadas, SSO, RBAC, analytics Enterprise Custom Grandes orgs Pooled usage, SCIM, audit logs, self-hosted cloud agents

Billing anual economiza 20% em todos os planos pagos.

### Qual plano escolher?

**Comece com Hobby** se nunca usou o Cursor e quer avaliar antes de migrar. Não espere usar como editor principal — você vai bater nos limites no meio de uma feature.

**Vá de Pro** se você programa diariamente e quer assistência de IA no workflow inteiro. A maioria dos desenvolvedores acha o Pro suficiente, a menos que rode tarefas pesadas de Agent constantemente.

**Upgrade para Pro+** se seus overages no Pro regularmente excedem US$ 20-40/mês. A matemática favorece Pro+ quando você bate limites consistentemente.

**Considere Ultra** apenas se seus overages no Pro+ são substanciais e você trata o Cursor como infraestrutura, não como assinatura.

**Escolha Teams** no momento em que precisar de billing centralizado ou contexto compartilhado entre um time de desenvolvedores.

### Desconto para estudantes

O Cursor oferece acesso gratuito para estudantes. Cadastre-se com email institucional e verifique na página de estudantes. Se já tiver um plano pago, o Cursor reembolsa o saldo restante automaticamente.

## Avaliação: Spider Chart

Notas de 1 a 10 baseadas em benchmarks públicos + avaliação prática.

 Eixo Nota Justificativa Código (qualidade) 8/10 Composer 2 atinge 73.7% no SWE-bench Multilingual e 61.3 no CursorBench (supera Opus 4.6). Com Claude Opus 4.7 via routing, chega a ~87.6% no SWE-bench Verified. Aider top-tier. Contexto (compreensão) 9/10 Indexação semântica avançada do codebase via embeddings (Turbopuffer), @symbols para referência precisa, multi-file awareness excelente. Merkle tree de hashes para re-indexação rápida. Autonomia 8/10 Agent mode robusto com iteração sobre erros, execução de terminal, web browsing. Composer 2 marca 61.7 no Terminal-Bench 2.0. /multitask com subagents paralelos desde abril/2026. Velocidade 9/10 Supermaven autocomplete (mais rápido do mercado), Composer 2 a 200+ tokens/s. Streaming otimizado. Cloud agents eliminam espera local em tarefas longas. Custo-benefício 7/10 Pro US$ 20/mês com pool de créditos equivalente, mas heavy users reportam gasto real de US$ 40-50/mês com overages. Modelo de créditos variáveis desde jun/2025 torna custo imprevisível. Especialização (skills) 8/10 Project Rules (.mdc com glob patterns), .cursorrules legado, Notepads para contexto reutilizável. Sistema maduro e versionável por projeto. Multi-agente 8/10 Agents Window (Cursor 3.0) com agentes paralelos em worktrees, /best-of-n , /multitask com subagents assíncronos, cloud agents em VMs isoladas. Evolução significativa desde abril/2026. Ecossistema 7/10 Extensões VS Code 100% compatíveis, MCP servers com one-click install (limite de 40 tools), Marketplace próprio com plugins. Ecossistema proprietário menor que VS Code/Copilot nativos.

**Média geral: 8.0/10**

> **Metodologia**: Código baseia-se em SWE-bench Verified, SWE-bench Multilingual e CursorBench. Autonomia em Terminal-Bench 2.0 + avaliação prática. Demais eixos são avaliação prática comparativa com concorrentes diretos (Claude Code, Copilot, Windsurf, Cline). Escala: 1-4 (fraco), 5-6 (adequado), 7-8 (bom), 9-10 (excelente/líder). Dados de maio/2026.

[IMAGEM: Spider chart radar com 8 eixos mostrando as notas do Cursor — destaque em Velocidade (9) e Contexto (9), com Custo-benefício (7) como ponto mais baixo]

## Prós e Contras

### Prós

- **Integração profunda com o codebase** — o Cursor entende seu repositório inteiro via indexação semântica, não apenas o arquivo aberto. Isso produz sugestões dramaticamente melhores que plugins que só veem o contexto local.

- **Migração zero-friction do VS Code** — extensões, temas, keybindings, tudo funciona. Você não perde nada da sua configuração atual.

- **Multi-modelo com routing inteligente** — acesso a Claude, GPT, Gemini, DeepSeek e Composer 2 no mesmo lugar. Auto mode escolhe o melhor modelo para cada tarefa sem você pensar nisso.

- **Agentes paralelos (Cursor 3.0)** — `/best-of-n` e worktrees isolados permitem rodar múltiplas abordagens simultaneamente e escolher a melhor. Game-changer para refactors complexos.

- **Ecossistema MCP maduro** — one-click install de dezenas de integrações. O agente busca contexto sozinho em vez de perguntar para você.

- **Cloud agents** — tarefas longas rodam na nuvem enquanto você fecha o laptop. Resultados com screenshots e demos esperando quando você volta.

- **UX polida** — a experiência de usar o Cursor é consistentemente elogiada. Diffs claros, inline suggestions suaves, chat integrado sem fricção.

### Contras

- **Modelo de créditos confuso** — a transição de 2025 ainda gera frustração. Desenvolvedores heavy users no Pro frequentemente gastam mais que os US$ 20 esperados. Monitorar o dashboard de uso é obrigatório.

- **Degradação em sessões longas** — qualidade do Agent cai em sessões muito extensas. Contexto fragmenta, tool calls inflam. Reinicie a sessão em pontos naturais (por tarefa, por PR).

- **Monorepos são problemáticos** — sem `.cursorignore` bem configurado, indexação trava. Mesmo com, o agente pode sugerir imports cross-package indevidos. Codifique boundaries em Project Rules.

- **Diffs grandes e difíceis de revisar** — refactors multi-arquivo podem produzir PRs tecnicamente corretos mas praticamente irrevisáveis. Force o agente a trabalhar em escopos menores.

- **Alucinação de APIs** — mesmo modelos top inventam métodos que parecem corretos. Faça “verificar que o package e método existem antes de chamar” uma rule.

- **Requer conexão com internet** — o Cursor precisa de cloud inference para chat e agent. Se você precisa de inferência 100% local, considere alternativas como Void AI ou Cline com modelo local.

- **Limite de 40 tools MCP** — exceder silenciosamente faz o modelo perder acesso a tools posteriores. Curadoria é obrigatória.

- **Vendor lock-in relativo** — embora baseado em VS Code, features como rules, MCP configs e workflows são específicos do Cursor. Migrar para outro editor significa perder essa camada.

### Veredicto

**Ideal para:** desenvolvedores que usam VS Code como editor principal e querem IA profundamente integrada no workflow diário. Times que precisam de controles enterprise (SSO, audit, privacy). Quem trabalha em projetos de médio porte com codebase bem estruturado.

**NÃO ideal para:** quem precisa de inferência 100% local (regulação, air-gap). Desenvolvedores em monorepos massivos sem disposição para configurar `.cursorignore` e rules. Quem tem orçamento apertado e usa IA intensivamente (o Pro pode não ser suficiente). Quem prefere workflow de terminal puro (considere [Claude Code](/guias/claude-code/)).

**Recomendação prática:** comece no Pro, monitore seu dashboard de uso no primeiro mês, e faça upgrade apenas se bater limites consistentemente. Para a maioria dos desenvolvedores, US$ 20/mês é exatamente o ponto certo.

---

Se você está implementando agentes de codificação no seu time e precisa de ajuda com configuração de rules, MCP servers, ou estratégia de adoção, a [ft.ia.br](https://ft.ia.br) oferece consultoria especializada para times que querem extrair o máximo dessas ferramentas.

-->