GitHub Copilot: Guia prático de tokens, modelos e custos
A partir do 1 de Junho de 2026, o GitHub vai mudar a forma de cobrança, substituindo o modelo de Premium Requests por um método baseado no uso (usage-based billing). Isso significa que o custo de cada interação vai depender de dois aspectos principais:
- O modelo utilizado (por exemplo, Claude Opus, GPT-5, Gemini, etc.)
- O número de tokens usados (tanto de entrada, saída, quanto os armazenados)
Referência oficial: Mudanças na cobrança do Copilot
Cada interação consome um número de tokens, que são convertidos em AI Credits. Aqui está a conversão:
1 AI Credit = $0,01 USD
| Plano | Preço/mês | Base Credits | Flex Allotment | Total AI Credits |
|---|---|---|---|---|
| Copilot Pro | $10 | 1.000 | 500 | 1.500 |
| Copilot Pro+ | $39 | 3.900 | 3.100 | 7.000 |
| Copilot Max | $100 | 10.000 | 10.000 | 20.000 |
Os planos agora têm uma estrutura mais flexível, permitindo pacotes de créditos que definem quantas requisições você pode fazer a modelos avançados antes de precisar usar créditos adicionais ou mudar de modelo:
- Base Credits: A quantidade fixa que vem inclusa no valor base do seu plano.
- Flex Allotment: Uma quantidade de créditos adicionais para usar em picos de demanda, evitando bloqueios na conta ou cobranças extras.
- Pooled Credits (Organizações): Para contas corporativas (Copilot Business e Enterprise), os créditos podem ser compartilhados em um fundo comum, facilitando a gestão global do uso.
Referência: Cobrança baseada no uso para indivíduos
Quando você utiliza o Copilot, há três tipos de tokens consumidos:
| Tipo de Token | O que é | Custo relativo |
|---|---|---|
| Input tokens | O que você envia ao modelo (prompts, contexto de arquivos, histórico) | Base |
| Cached tokens | Contexto que o modelo reutiliza de interações anteriores | Entre ~4x e ~10x mais barato (varia por modelo) |
| Output tokens | O que o modelo gera como resposta | Mais caro |
Tokens em cache são significativamente mais acessíveis. Em muitos modelos, o custo de cached input é cerca de 10 vezes mais baixo que input “frio”. Confira um exemplo de preços por milhão (1M) de tokens:
| Modelo | Input (por 1M tokens) | Cached (por 1M tokens) | Output (por 1M tokens) |
|---|---|---|---|
| Claude Haiku 4.5 | $1,00 | $0,10 | $5,00 |
| Claude Sonnet 5.5 | $2,00 | $0,10 | $10,00 |
| Claude Opus 5.5 | $4,00 | $0,20 | $20,00 |
| GPT-5.3-Codex | $1,75 | $0,175 | $14,00 |
| GPT-6 Luna | $0,10 | $0,01 | $0,50 |
| GPT-6.1 Terra | $1,00 | $0,05 | $5,00 |
| Gemini 4 Hydrogen | $1,50 | $0,075 | $7,50 |
| MAI-Code-1.1-Flash | $0,20 | $0,02 | $1,20 |
Referência: Modelos e preços do GitHub Copilot
O caching acontece automaticamente nas seguintes situações:
- Conversas contínuas — O contexto é reutilizado entre mensagens na mesma sessão.
- Arquivos frequentemente abertos/referenciados — O mesmo contexto de código é enviado repetidamente.
- Prompts semelhantes — Quando o início do prompt é idêntico a uma chamada recente anterior.
Se você notar que a maioria dos tokens consumidos são cached no seu relatório de uso, isso significa:
- Você está mantendo sessões de chat mais longas (isso é ótimo!)
- O contexto está sendo reutilizado de forma eficiente.
- Seu custo por interação é muito menor em comparação a quem inicia novas conversas frequentemente.
Vamos calcular os custos usando o Claude Opus 5.5:
| Parâmetro | Valor estimado |
|---|---|
| Input tokens por interação | ~4.000 |
| Output tokens por interação | ~1.000 |
| Custo input (non-cached) | 4.000 ÷ 1M × $4,00 = $0,016 |
| Custo output | 1.000 ÷ 1M × $20,00 = $0,020 |
| Custo total por interação | ~$0,036 = 3,6 AI Credits |
Para quem tem 1.500 AI Credits (Copilot Pro), isso permite aproximadamente 416 interações por mês com o Claude Opus 5.5.
Caso você seja um usuário intenso (50 interações por dia), seus créditos se esgotam em cerca de 8 dias.
Aviso: Os valores apresentados são estimativas baseadas nos preços oficiais por token (Modelos e preços), levando em conta uma interação média de ~4.000 tokens de entrada + ~1.000 tokens de saída, sem cache. Na prática, considerando o cache, o custo real pode ser muito inferior.
| Modelo | Preço Input/1M (doc.) | Preço Output/1M (doc.) | Custo estimado/interação | Interações com 1.500 credits | Interações com 7.000 credits |
|---|---|---|---|---|---|
| GPT-6 Luna | $0,10 | $0,50 | ~0,09 credits | ~16.666 | ~77.777 |
| MAI-Code-1.1-Flash | $0,20 | $1,20 | ~0,20 credits | ~7.500 | ~35.000 |
| GPT-6.1 Terra | $1,00 | $5,00 | ~0,9 credits | ~1.666 | ~7.777 |
| Claude Sonnet 5.5 | $2,00 | $10,00 | ~1,8 credits | ~833 | ~3.888 |
| Claude Opus 5.5 | $4,00 | $20,00 | ~3,6 credits | ~416 | ~1.944 |
Fórmula utilizada: (4.000 ÷ 1.000.000 × preço_input) + (1.000 ÷ 1.000.000 × preço_output) → convertido para AI Credits (÷ $0,01)
Antes de discutir estratégias de redução de custos, vale a pena mencionar um ponto crucial que o workshop do GitHub destaca e que ainda não foi abordado neste artigo:
“Quando os tokens eram baratos, a precisão do Agent não era um fator. Contudo, quando passam a ser caros, exigem esforço adicional de engenharia.”
A lógica é bastante clara:
Agent ROI = Valor do output do Agent / Custo de tokens × 100%
Apenas otimizar a parte do custo (tokens) sem considerar o valor gerado (qualidade) é uma abordagem incompleta.
Agentes interligados potencializam erros. Com uma taxa de acerto de 99% por etapa, um fluxo de trabalho com 50 etapas pode reduzir para apenas ~60% de sucesso. Cada erro gera tokens extras para depuração, retrabalho e novas chamadas ao modelo.
Divida o trabalho em fases utilizando diferentes modelos para cada um:
| Fase | Objetivo | Modelo indicado |
|---|---|---|
| Pesquisa | Exploração e entendimento do contexto | Gemini 2.5 Pro / GPT-4.1 |
| Planejamento | Definição precisa do que será realizado | Claude Opus / GPT-5.5 |
| Implementação | Execução paralela de tarefas bem definidas | GPT-5.4 / Claude Sonnet |
Um prompt impreciso acaba jogando o problema para o modelo. Um prompt claro já facilita a solução e consome muito menos tokens no total.
Exemplo prático:
- “Corrija o bug”
- “A issue #123 descreve um bug onde a API retorna 500 ao chamar /orders com payload vazio. Corrija tratando a validação antes e garantindo a resposta 400.”
Um agente sem guardrails acumula silenciosamente os erros. Para evitar isso, configure:
- Testes unitários que falham rapidamente e com precisão.
- Linters e formatadores automáticos.
- Scans de segurança no pipeline.
Cada erro emparelhado a um teste custa muito menos do que uma sessão de depuração usando um modelo premium.
Instruções persistentes mal redigidas inflamam o prompt do sistema em toda sessão. Algumas boas práticas incluem:
- Mantenha o arquivo pequeno e específico.
- Inclua um log de erros recorrentes do agente (agent misses).
- Adicione diretrizes para respostas concisas (“seja conciso”, “pare se X”).
- Itere com frequência — evite usar IA para gerar as instruções.
Deixe que o Copilot escolha o modelo ideal para tarefas gerais. O sistema tende a priorizar modelos mais leves e econômicos sempre que o prompt não exigir raciocínio complexo, o que reduz bastante o custo médio. Nos planos pagos, a documentação oficial indica um desconto de 10% ao utilizar a seleção automática de modelos no Copilot Chat e no agente de nuvem do Copilot.
Nota temporal: até 30/11/2026, os planos pagos terão um desconto de 30% com o Copilot Fusion (consulte a documentação oficial para verificar a disponibilidade).
| Tarefa | Modelo recomendado | Por quê |
|---|---|---|
| Perguntas simples, snippets | GPT-6 Luna / MAI-Code-1.1-Flash | Muito barato e rápido para tarefas curtas. |
| Desenvolvimento diário, refatoração | GPT-6.1 Terra / Claude Sonnet 5.5 | Melhor equilíbrio entre custo e qualidade. |
| Arquitetura complexa, revisões de código | Claude Opus 5.5 / GPT-5.6 Sol | Use quando precisar de raciocínio mais aprofundado. |
| Resumir e-mails/documentos | Claude Haiku 5.5 / GPT-6 Luna | Tarefa simples, normalmente sem necessidade de maior complexidade. |
- EVITE abrir um novo chat para cada pergunta em uma mesma tarefa.
- Continue a conversa na mesma thread para reutilizar contexto, já que cached tokens são entre ~4x e ~10x mais baratos, dependendo do modelo.
- Use /clear frequentemente ao iniciar uma nova tarefa — o contexto acumulado de tarefas anteriores aumenta o custo sem agregar valor.
- Preste atenção ao ContextRot: a partir de ~50% da janela de contexto, os modelos perdem qualidade nas respostas do meio da conversa (Lost in the Middle).
- Regra geral: forneça o mínimo de contexto necessário, mas o máximo possível para completar a tarefa.
- Feche abas de arquivos que não são relevantes.
- Utilize @file para referenciar apenas o que precisa.
- Prompts mais objetivos resultam em menos tokens de input.
- Sugestões inline e sugestões de próximo edit não consomem AI Credits.
- Para tarefas de completar código, permita que o autocomplete faça seu trabalho.
- GitHub: acesse a visão geral de cobrança da sua conta e abra Orçamentos e alertas para monitorar consumo e configurar alertas.
- Nos planos individuais com cobrança baseada em uso, o painel de uso mostra a cota disponível e o uso acumulado.
- O caminho de menu pode variar de acordo com o tipo de conta, permissões e atualizações da interface.
- Defina um orçamento máximo para AI Credits adicionais.
- Configure alertas em 75%, 90% e 100% do orçamento para se preparar para o esgotamento.
- Após acabar os créditos, o comportamento dependerá do plano e das políticas configuradas: você pode ter continuidade com modelos limitados, ficar bloqueado até o reset mensal ou haver cobrança por créditos adicionais.
Referência1: Configurando orçamentos para controlar gastos Referência2: Sobre a cobrança do GitHub Copilot
O VS Code oferece comandos, variáveis de contexto e ferramentas nativas para ajudar no controle do consumo de tokens. Ao digitar / no chat, você verá os comandos disponíveis. Aqui estão os mais importantes para economizar:
| Comando | O que faz | Impacto no custo |
|---|---|---|
| /clear | Limpa a conversa e inicia uma nova sessão. | Essencial. Remove o contexto acumulado que aumenta os tokens de entrada a cada turno. Use ao mudar de tarefa. |
| /compact | Compacta/resume o contexto da sessão atual sem apagar o histórico. | Alto impacto. Reduz drasticamente os tokens de entrada enviados em turnos seguintes. Ideal para sessões prolongadas onde /clear poderia apagar contexto útil. |
| /new | Inicia uma nova conversa (similar ao /clear). | Mesma função do /clear — útil para separar contextos entre diferentes tarefas. |
| /help | Referência rápida dos comandos do Copilot. | Sem impacto direto, mas ajuda a descobrir funcionalidades que podem otimizar o uso. |
Dica prática: Em sessões longas (>30 turnos), o contexto cresce com cada mensagem. Usar /compact por volta do turno 25-30 pode reduzir significativamente o custo dos turnos seguintes sem perder o fio da conversa.
O /chronicle é uma habilidade nativa do Copilot que analisa seu histórico de sessões e fornece insights personalizados. Para usá-lo, habilite a configuração chat.localIndex.enabled: true no VS Code.
| Subcomando | O que faz | Quando usar |
|---|---|---|
| /chronicle standup | Gera um resumo das suas atividades das últimas 24 horas. | Para rever o que foi realizado e quanto contexto foi utilizado em cada sessão. |
| /chronicle tips | Analisa seus padrões de uso e sugere melhorias no fluxo de trabalho. | Para detectar hábitos que desperdiçam tokens (prompts vagos, sessões longas sem compactação, ferramentas subutilizadas). |
| /chronicle cost-tips | Análise específica de custos com dados reais das suas sessões. | O mais relevante para economizar. Identifica sessões caras, modelos usados em tarefas simples, grandes colagens, e ausência de compactação. |
| /chronicle search | Busca sessões anteriores por palavra-chave, arquivo ou PR. | Evita “redescobrir” contexto que já foi explorado — reutilize em vez de desperdiçar tokens novamente. |
| /chronicle improve | Sugere melhorias para o seu copilot-instructions.md com base no histórico. | Instruções ruins aumentam o prompt do sistema em toda sessão. Boas instruções = menos tokens por turno. |
| /chronicle reindex | Reconstrói o índice local de sessões. | Use se os outros subcomandos não retornarem dados. |
Para obter uma análise detalhada de tokens (por evento, por modelo), habilite também chat.sessionSync.enabled: true — isso desbloqueia dados de cobrança no chronicle.
Cada variável # controla exatamente qual contexto é incluído no prompt. Usar a mais específica reduz os tokens de entrada:
| Variável | O que inclui | Dica de economia |
|---|---|---|
| #file | Conteúdo de um arquivo específico. | Use isso em vez de manter várias abas abertas. O Copilot pode incluir todas as abas como contexto. |
| #selection | Apenas o trecho selecionado no editor. | Muito mais barato do que enviar o arquivo inteiro. |
| #function | A função/método atual. | Ideal para perguntas sobre uma função específica. |
| #block | O bloco de código atual. | Similar ao #function, só que mais granulado. |
| #sym | O símbolo (classe, variável, etc.) atual. | Para questões sobre uma entidade específica do código. |
Regra de ouro: #selection < #function < #file < Workspace em termos de tokens consumidos. Sempre escolha o escopo mais restrito que atenda à sua dúvida.
| Recurso | Como usar | Impacto |
|---|---|---|
| Model picker (menu suspenso no chat) | Clique no nome do modelo no rodapé do chat para trocar. | Trocar de Claude Opus 5.5 para GPT-6 Luna pode reduzir o custo por interação em dezenas de vezes (dependendo do prompt). |
| Auto mode | Selecione “Auto” no model picker. | O Copilot escolhe o modelo mais adequado (e barato) para cada prompt. Um desconto de ~10% é aplicado. |
| Onde | O que mostra |
|---|---|
| Canto inferior direito (barra de status) | Indicador de uso dos AI Credits — mostra o consumo em tempo real. |
| GitHub → Configurações → Cobrança | Painel completo de uso com detalhamento por modelo, tokens de entrada/saída e tendências de consumo. |
| Orçamentos e Alertas | Configure alertas em 75%, 90% e 100% para prever o esgotamento dos créditos. |
1. Comece a tarefa → escolha o modelo adequado (Auto ou manual) 2. Utilize #file ou #selection → não abra abas desnecessárias 3. Mantenha a conversa na mesma thread → cached tokens são mais baratos 4. ~Turno 25-30 → utilize /compact para reduzir o contexto 5. Mudou de tarefa → use /clear ou /new 6. Ao fim do dia → aplique /chronicle cost-tips para revisar seus padrões 7. Periodicamente → use /chronicle improve para otimizar seu copilot-instructions.md
Referência: Guia de atalho do GitHub Copilot Chat
Neste diálogo, utilizamos o processo de criação deste artigo como um estudo de caso sobre custos.
- Modelo premium usado do início ao fim: Claude Opus 5.5
- Conversação iterativa em vários turnos até chegar à versão final.
- Coleta de referências em múltiplas pesquisas separadas.
- Validações e refinamentos feitos a partir de prompts adicionais.
Estimativa de consumo da sessão até o artigo final:
- ~114 AI Credits (aproximadamente $1,14)
- Use GPT-6.1 Terra ou Claude Sonnet 5.5 para redação.
- Execute 1 prompt completo com escopo, estrutura e formatação final.
- Busque apenas as 2 fontes essenciais (mudança de cobrança + preços).
- Solicite no mesmo prompt: premissas, citações e tabelas com estimativas de custo.
Estimativa de consumo com execução otimizada:
- ~20 AI Credits (aproximadamente $0,20)
| Métrica | Jeito mais caro | Jeito otimizado | Economia |
|---|---|---|---|
| Consumo estimado | 114 AI Credits | 20 AI Credits | 94 AI Credits |
| Custo estimado | $1,14 | $0,20 | $0,94 |
| Redução percentual | – | – | ~82% |
- Opus para problemas difíceis; modelo médio para documentação.
- Um prompt completo reduz custos mais do que qualquer ajuste superficial.
- Uma sessão única e contínua ajuda com caching e reduz gastos.
- Menos turnos de validação isolada = menos tokens de entrada/saída.
Aviso: Os valores aqui apresentados são estimativas desta sessão, baseadas nos preços oficiais por token e no padrão de utilização observado enquanto o artigo foi elaborado.
Quando seus AI Credits se esgotam, o que acontece depende do seu plano e das políticas definidas:
- Pode continuar com modelos mais baratos e/ou em modo automático, conforme as políticas do plano/admin e orçamento disponíveis.
- Pode ser bloqueado até o reset mensal, se houver um orçamento com stop usage ativo.
- Pode consumir créditos adicionais ($0,01 por crédito), se você configurou um orçamento extra.
- Completar códigos e sugestões de próximos passos continuam funcionando independentemente do saldo de AI Credits.
- O contador reseta no primeiro dia de cada mês (00:00 UTC).
Não existe garantia automática universal de fallback — sempre verifique as políticas do seu plano.
Para organizações, os AI Credits são compartilhados no nível da entidade de cobrança. Isso quer dizer que um usuário intensivo pode impactar toda a equipe. Portanto, administradores devem:
- Monitorar o consumo por usuário.
- Estabelecer políticas de modelo por equipe.
- Considerar o impacto do Copilot Code Review (que consome tokens + minutos do GitHub Actions).
| Antes (até 31/05) | Depois (a partir de 01/06) |
|---|---|
| Premium Requests (custo fixo por interação) | AI Credits (baseados em tokens reais) |
| Multiplicador por modelo (ex: Opus = 27x) | Custo por token (input/cached/output) |
| 300-1500 requests/mês | 1.500-20.000 AI Credits/mês |
| Sem visibilidade de cache | Cache visível e muito mais barato |
| Modelo ilimitado dentro da cota | Custo proporcional ao uso real |
Share this content:
Discover more from Qureshi
Subscribe to get the latest posts sent to your email.