Eu uso o Claude Code com modelos gratuitos na nuvem — veja como

Eu uso o Claude Code com modelos gratuitos na nuvem — veja como

Minha GPU estava a 94 graus Celsius, os coolers soavam como um motor a jato se preparando para decolar, e o modelo de 70B parâmetros que eu executava localmente já estava há dezenove segundos gerando uma única resposta.

Dezenove segundos. Para uma chamada de API. Em um fluxo de trabalho agêntico que precisaria de mais trinta ou quarenta chamadas para concluir a tarefa.

Eu tinha passado a maior parte de um fim de semana tentando fazer a inferência local de modelos open-source funcionar com o Claude Code. A ideia era atraente — baixar modelos open-source poderosos, executá-los no próprio hardware via Ollama, apontar o Claude Code para um endpoint local e aproveitar IA ilimitada e gratuita para sempre. Sem custos de API. Sem limites de taxa. Privacidade total. A configuração dos sonhos para qualquer desenvolvedor que viu sua conta da Anthropic subir.

A realidade? Meu M2 MacBook Pro com 32 GB de memória unificada mal conseguia acompanhar um modelo quantizado de 70B. As respostas eram lentas. A qualidade degradava visivelmente com a quantização. E os modelos que realmente competem com ofertas na nuvem — as arquiteturas de 120B parâmetros, os enormes sistemas mixture-of-experts — nem cabiam na memória sem serem mutilados até virarem uma sombra de sua capacidade real.

Eu estava prestes a desistir de todo o conceito de executar modelos open-source com o Claude Code quando um colega soltou um link no chat da equipe. "Pula a configuração local," ele escreveu. "Aponta o Claude Code pro OpenRouter. Vinte e nove modelos gratuitos. Inferência na nuvem. O mesmo fluxo de trabalho agêntico."

Oito minutos depois, eu tinha o Claude Code rodando no Nemotron 3 Super da NVIDIA — um modelo de 120B parâmetros que eu nem conseguia carregar localmente — gerando uma landing page SaaS completa na velocidade da nuvem. De graça.

Isso foi há três semanas. Não toquei em inferência local desde então.

Por que a inferência local me decepcionou (e provavelmente decepciona você também)

Preciso explicar por que abandonei modelos locais, porque se você está lendo isto, provavelmente considerou o mesmo caminho. Ou está nele agora, vendo seu notebook virar um aquecedor.

A conta simplesmente não fecha para a maioria do hardware de consumo.

Modelos pequenos — 7B e 13B parâmetros — rodam bem localmente. São rápidos, cabem na memória e não sobrecarregam a máquina. Mas a qualidade da saída para trabalho real de desenvolvimento é fraca. Peça a um modelo de 7B para refatorar um handler Express.js de 200 linhas em módulos limpos, e você vai receber algo que tecnicamente funciona mas estruturalmente parece trabalho de um calouro de ciência da computação. Os nomes de variáveis são genéricos. O tratamento de erros está ausente ou foi copiado sem critério. As decisões arquiteturais são superficiais.

Os modelos que produzem código genuinamente útil começam nos 70B parâmetros. E 70B é onde o hardware de consumo começa a suar. No meu M2 com 32 GB de memória unificada, um modelo Llama 3.3 70B quantizado em 4 bits via Ollama me dava tempos de resposta de 12-20 segundos por geração. Isso por uma única resposta. Os fluxos de trabalho agênticos do Claude Code encadeiam dezenas dessas chamadas — planejamento, geração de código, escrita de arquivos, execução de testes, correção de erros. A 15 segundos por chamada ao longo de 30 chamadas, uma tarefa que leva 4 minutos em inferência na nuvem leva 7-8 minutos localmente. Essa diferença se acumula ao longo de um dia de trabalho em horas de produtividade perdida.

E esse é o melhor cenário. Os modelos de 120B+ que realmente rivalizam com ofertas pagas na nuvem? Minha máquina não consegue executá-los de jeito nenhum. Nem em precisão total. Nem com quantização agressiva. Você precisaria de no mínimo 64 GB+ de RAM, e mesmo assim, estaria trocando qualidade significativa pelo privilégio de rodar localmente.

Uma vez fiz uma sessão de programação de quatro horas com inferência local, só para ver como era o uso contínuo. Minha bateria foi de 100% para 12%. O chassi do notebook estava quente demais para apoiar nas pernas. O custo de energia provavelmente superou o que as chamadas de API equivalentes na nuvem teriam me cobrado.

Inferência local é um exercício técnico fascinante. Para trabalho de desenvolvimento diário com modelos potentes o suficiente para serem úteis? Inferência na nuvem através de um serviço como o OpenRouter é a resposta prática.

O que o OpenRouter faz (e por que existem 29 modelos gratuitos)

O OpenRouter é uma camada de roteamento de API que fica entre sua ferramenta de desenvolvimento e dezenas de provedores de modelos. Uma chave de API, um endpoint, acesso a mais de 400 modelos da OpenAI, Google, Meta, Mistral, NVIDIA, Anthropic e outros.

A parte que importa para este artigo: o OpenRouter mantém uma coleção curada de modelos completamente gratuitos. Em março de 2026, 29 modelos estão disponíveis sem custo algum — sem cartão de crédito, sem período de teste, sem pegadinhas além dos limites de taxa.

Por que alguém ofereceria modelos de 120B parâmetros de graça? Duas razões.

Primeiro, empresas como NVIDIA e Meta lançam modelos open-source como investimentos estratégicos. O Nemotron 3 Super da NVIDIA não é gratuito porque a NVIDIA está sendo generosa — é gratuito porque a adoção em massa impulsiona a demanda pela infraestrutura de treinamento e serviços de computação em nuvem da NVIDIA. Os modelos Llama da Meta servem ao mesmo propósito para seu ecossistema de IA. O modelo é o produto isca. A infraestrutura é o negócio.

Segundo, o OpenRouter subsidia o acesso gratuito a modelos como estratégia de crescimento. Usuários gratuitos se tornam usuários pagantes quando suas necessidades escalam. É o mesmo playbook que o GitHub, a Vercel e toda ferramenta de desenvolvedor bem-sucedida executaram — dar valor suficiente para criar hábito, depois capturar receita quando o uso cresce.

O resultado para nós: modelos legítimos, hospedados na nuvem, em precisão total, rodando em infraestrutura GPU profissional, acessíveis por uma API simples — sem pagar um centavo.

Aqui está o insight crucial que torna isso relevante especificamente para o Claude Code: O poder do Claude Code está no seu framework de agentes, não no modelo. O motor de planejamento, o acesso ao sistema de arquivos, a execução de comandos shell, a coordenação de sub-agentes, a busca web, a exploração de código — tudo isso é infraestrutura a nível de framework. Funciona independentemente de qual modelo fornece o raciocínio. Troque o Opus da Anthropic pelo Nemotron 3 Super da NVIDIA, e o Claude Code continua lendo arquivos, escrevendo código, executando testes e executando comandos de terminal exatamente da mesma forma.

A inteligência muda. As capacidades não.

Essa separação é a base completa do que vou te explicar agora.

A configuração completa: menos de dez minutos, do início ao fim

Vou te dar os passos exatos que segui, incluindo o erro de depuração que me custou dez minutos extras. Se você pular meu erro, estará rodando em menos de oito.

Passo 1: Confirme que o Claude Code está instalado

Se você já tem o Claude Code, pule para o Passo 2. Caso contrário:

npm install -g @anthropic-ai/claude-code

Ou no macOS via Homebrew:

brew install claude-code

Verifique com claude --version. Se você nunca usou o Claude Code, meu guia para iniciantes cobre tudo, da instalação ao seu primeiro build.

Passo 2: Crie uma conta gratuita no OpenRouter

Acesse openrouter.ai e cadastre-se. Email e senha — sem necessidade de cartão de crédito para o plano gratuito.

Navegue até a seção API Keys no seu painel. Clique em Create Key. Copie a chave imediatamente — ela começa com sk-or-v1- e o OpenRouter não vai mostrá-la novamente depois que você sair da página.

Passo 3: Configure três variáveis de ambiente

Abra seu arquivo de configuração do shell. No macOS (shell zsh padrão), é o ~/.zshrc. No Linux com bash, ~/.bashrc. Adicione estas três linhas:

export ANTHROPIC_BASE_URL="https://openrouter.ai/api"
export ANTHROPIC_AUTH_TOKEN="sk-or-v1-your-actual-key-here"
export ANTHROPIC_API_KEY=""

Aquela terceira linha — o ANTHROPIC_API_KEY vazio — parece inútil. Da primeira vez eu pulei. Péssima decisão.

Eis o que acontece sem ela: se você já autenticou o Claude Code com uma conta da Anthropic (o que a maioria dos usuários fez), o Claude Code armazena essas credenciais em cache. Quando uma chave da Anthropic e um token do OpenRouter existem simultaneamente, o Claude Code não sabe qual priorizar. As requisições falham com erros de autenticação crípticos ou — o modo de falha sorrateiro — têm sucesso mas são roteadas pela API paga da Anthropic, queimando silenciosamente seus créditos enquanto você acha que está no plano gratuito.

Configurar ANTHROPIC_API_KEY como string vazia diz explicitamente ao Claude Code para ignorar quaisquer credenciais da Anthropic em cache e rotear tudo pela URL base que você especificou.

Mais um passo se você estava logado antes: Inicie o Claude Code e execute /logout dentro da sessão. Isso limpa o token OAuth do fluxo de autenticação baseado em navegador. Sem isso, o token OAuth em cache pode sobrescrever suas variáveis de ambiente.

Passo 4: Escolha seu modelo gratuito

Navegue pela página de modelos gratuitos do OpenRouter e escolha um modelo. Vou te dizer qual começar na próxima seção, mas mecanicamente, aqui está como configurar:

Adicione esta linha ao seu perfil de shell:

export ANTHROPIC_DEFAULT_SONNET_MODEL="nvidia/nemotron-3-super:free"

Isso diz ao Claude Code qual modelo usar para suas tarefas principais de raciocínio. Substitua o identificador do modelo por qualquer ID de modelo gratuito do catálogo do OpenRouter — cada página de modelo tem um botão de copiar para a string exata.

Passo 5: Recarregue e verifique

Recarregue seu perfil atualizado:

source ~/.zshrc

Ou simplesmente abra uma nova janela de terminal. Depois inicie o Claude Code em qualquer diretório de projeto:

claude

Execute /status dentro da sessão. Você deve ver seu modelo escolhido como ativo e o endpoint da API apontando para o OpenRouter. Se ainda vir um modelo ou endpoint da Anthropic, verifique novamente a chave API vazia e o passo do /logout.

Essa é toda a configuração. Cada prompt, cada ação do agente, cada chamada de sub-agente agora é roteada pelo OpenRouter para o seu modelo gratuito selecionado.

Qual modelo gratuito você deve realmente usar? Eu testei cinco.

É aqui que a maioria dos guias do OpenRouter termina — "aqui está como conectar, boa sorte escolhendo um modelo." Isso não ajuda. A diferença entre escolher o modelo gratuito certo e o errado é a diferença entre uma tarde produtiva e uma frustrante.

Passei uma semana executando cinco modelos gratuitos na mesma bateria de tarefas reais de desenvolvimento. Não benchmarks sintéticos. Trabalho real que eu normalmente faria com Opus ou Sonnet.

A bateria de testes:

1. Geração de landing page SaaS — página completa com hero, grid de funcionalidades, tabela de preços, footer. Tailwind CSS. Responsiva.
2. Refatoração de código — pegar um handler Express.js bagunçado de 200 linhas e refatorar em módulos limpos e separados.
3. Diagnóstico de bugs — fornecer logs de erro e um trecho de código com um bug sutil de timing async/await. Encontrar e corrigir.
4. Tarefa agêntica de múltiplos passos — pesquisar preços atuais de armazenamento em nuvem, criar uma tabela comparativa, salvar em um arquivo markdown. Isso testa chamadas de ferramentas, busca web e operações com arquivos.

NVIDIA Nemotron 3 Super — Meu modelo gratuito do dia a dia

É este. Se você vai configurar apenas um modelo gratuito, faça-o ser este.

O Nemotron 3 Super é um modelo mixture-of-experts de 120B parâmetros que ativa apenas 12B parâmetros por requisição. Essa escolha arquitetural é o motivo pelo qual pode ser oferecido gratuitamente enquanto ainda entrega saída que compete genuinamente com modelos pagos. De acordo com o relatório técnico da NVIDIA, ele atinge até 2,2x mais throughput de inferência que modelos comparáveis de 120B como o GPT-OSS, graças à sua arquitetura híbrida Mamba-Transformer.

A janela de contexto de 262K tokens é enorme para um modelo gratuito — grande o suficiente para comportar codebases substanciais sem truncamento.

Teste de landing page: Gerou uma página completa e responsiva com esquema de cores coeso, classes Tailwind corretas e texto que não parecia Lorem Ipsum com delírios de grandeza. A estrutura de componentes estava limpa o suficiente para colocar em um projeto real com pequenos ajustes de espaçamento.

Teste de refatoração: Aqui o Nemotron me surpreendeu. Identificou os pontos óbvios de extração — validação separada, extrair consultas ao banco — mas também detectou uma condição de corrida no código original que eu havia deixado deliberadamente como armadilha. Ele a encontrou. Nem todo modelo faz isso.

Diagnóstico de bug: Identificou corretamente o problema de timing async na primeira tentativa, explicou o mecanismo com clareza e forneceu uma correção com tratamento de erros adequado. Sólido.

Tarefa agêntica: Funcional mas um pouco tosca nos detalhes. O modelo fez as chamadas corretas às ferramentas — busca web, criação de arquivos — mas a formatação da tabela comparativa precisou de limpeza manual. O conteúdo da pesquisa estava preciso.

A velocidade de resposta ficou na média de 3-4 segundos por geração. Comparado com os 15-20 segundos que eu obtinha da inferência local com um modelo menor, o Nemotron hospedado na nuvem pareceu como trocar internet discada por banda larga.

Qwen3 Coder 480B — O especialista em código

Atualmente o modelo gratuito mais forte para programação no OpenRouter, com janela de contexto de 262K tokens e benchmarks que o colocam próximo ao topo em tarefas de geração de código.

Nos testes de landing page e refatoração, o Qwen3 Coder superou ligeiramente o Nemotron — código mais enxuto, menos comentários desnecessários, nomes de variáveis melhores. O diagnóstico de bug foi comparável. Onde ele caiu foi na tarefa agêntica de propósito geral. Peça para pesquisar e sintetizar informações fora da geração pura de código, e a qualidade cai visivelmente.

Se seu trabalho é 90%+ geração de código, o Qwen3 Coder pode ser a melhor escolha padrão. Para fluxos de trabalho mistos que incluem pesquisa, documentação e raciocínio geral junto com programação, a versatilidade do Nemotron vence.

Mantenho o Qwen3 Coder disponível como modelo secundário:

export CLAUDE_CODE_ALTERNATE_MODEL="qwen/qwen3-coder-480b:free"

Llama 3.3 70B — O backup confiável

O Llama 3.3 70B da Meta é o Toyota Corolla dos modelos gratuitos. Nada nele vai te empolgar. Nada nele vai te frustrar também.

Passou nos quatro testes adequadamente. A landing page era funcional mas visualmente simples. A refatoração foi correta mas conservadora — não detectou a condição de corrida. O diagnóstico de bug foi preciso mas a explicação faltou profundidade. A tarefa agêntica foi concluída sem problemas.

Se o Nemotron 3 Super for removido do plano gratuito (modelos rotacionam periodicamente), o Llama 3.3 70B é meu substituto imediato. Consistência previsível tem valor real quando você depende de um plano gratuito.

GPT-OSS 120B — Brilhante e imprevisível

O modelo open-source de 120B da OpenAI produziu a melhor landing page individual de toda minha bateria de testes. Layout limpo. Micro-interações bem pensadas. Texto que realmente soava persuasivo.

Depois executei o mesmo prompt novamente e recebi uma página com flexbox quebrado, valores de pixels fixos no código e uma tabela de preços que se sobrepunha no celular.

Essa inconsistência é eliminatória para fluxos de trabalho agênticos. Uma única resposta ruim em uma cadeia de agentes pode se propagar — o modelo escreve um arquivo com bugs, o próximo passo tenta construir sobre esse arquivo bugado, e de repente você está três iterações dentro de erros acumulados. Eu usaria o GPT-OSS para gerações pontuais onde posso verificar a saída imediatamente. Para trabalho agêntico de múltiplos passos, a variação é alta demais.

openrouter/free (o auto-roteador) — Não vale a pena

O OpenRouter oferece uma meta-opção chamada openrouter/free que seleciona automaticamente entre modelos gratuitos disponíveis com base na sua requisição. Testei por um dia.

O problema: você nunca sabe qual modelo está processando cada requisição. Uma resposta vem do Nemotron, a próxima de algo completamente diferente com forças diferentes, peculiaridades diferentes, formatação de saída diferente. Para uma pergunta de chat avulsa, funciona. Para um fluxo de trabalho agêntico coerente de múltiplos passos onde a consistência entre chamadas importa, cria caos. Pule essa opção.

O que realmente funciona em modelos gratuitos (e o que quebra)

As capacidades agênticas do Claude Code são funcionalidades a nível de framework — operam independentemente do modelo backend. Mas a qualidade com que o modelo aciona essas capacidades varia. Aqui está o que descobri após três semanas de uso diário.

Funciona perfeitamente:

Operações de sistema de arquivos. Ler, criar, editar, excluir arquivos. O modelo decide o conteúdo; o Claude Code cuida da interação com o sistema de arquivos. Sem diferença em relação a modelos pagos.

Execução de comandos shell. Instalar pacotes, executar scripts de build, rodar suítes de teste, verificar status do Git. O modelo decide quais comandos executar; o agente os executa. Modelos gratuitos lidam com tarefas bem definidas aqui tão confiavelmente quanto o Opus.

Busca web integrada. A busca web do Claude Code funciona pelo framework de agentes independentemente do modelo backend. Usei o Nemotron para pesquisar documentação de APIs, verificar versões de pacotes npm e confirmar dados de preços atuais. Os resultados de busca voltam idênticos — o modelo só precisa formular consultas razoáveis e sintetizar resultados.

Exploração de código e descoberta de arquivos. Padrões glob, análise de estrutura de projeto, mapeamento de dependências. Capacidades a nível de framework que funcionam independentemente da qualidade do modelo.

Prompts agendados. Configurar o Claude Code para executar tarefas recorrentes — relatórios diários, verificações automatizadas, revisões de código periódicas — funciona com modelos gratuitos. É aqui que a economia se torna mais expressiva. Uma tarefa agendada rodando quatro vezes por dia sem custo versus $0,30-$0,50 por execução em um modelo pago economiza $36-$60 por mês em uma única tarefa recorrente.

Funciona com ressalvas:

Planejamento complexo de múltiplos passos. Modelos gratuitos lidam bem com planos de 4-5 passos. Além disso, passos são pulados, a sequência se perde ou o modelo esquece o que já fez. A solução: seja mais explícito. Em vez de "construa um sistema de autenticação completo," decomponha a tarefa você mesmo — "Primeiro, crie o modelo de usuário. Depois construa o endpoint de registro. Depois construa o endpoint de login com JWT." Mais estrutura no prompt compensa menos capacidade de planejamento no modelo.

Coordenação de sub-agentes. O Claude Code pode criar sub-agentes para tarefas paralelas. Com modelos gratuitos, a execução funciona mas a síntese fica confusa — o agente principal às vezes ignora a saída do sub-agente ou mescla resultados de forma incoerente. Evito fluxos de trabalho complexos com sub-agentes em modelos gratuitos a menos que as sub-tarefas sejam genuinamente independentes.

Não funciona bem:

Raciocínio arquitetural sobre grandes codebases. Apesar da janela de contexto de 262K tokens do Nemotron, a qualidade do raciocínio entre arquivos é visivelmente mais fraca que a do Opus. O modelo consegue manter o contexto fisicamente mas não raciocina sobre dependências entre arquivos, padrões de design e implicações arquiteturais com a mesma profundidade. Para trabalho em arquivo único ou projetos pequenos, a diferença mal se nota. Para um monorepo de 50 arquivos com cadeias de dependências complexas, você vai sentir imediatamente.

Manipulação de histórico Git. Operações básicas — commit, push, criação de branches — funcionam bem. Rebase interativo, resolução de conflitos de merge, fluxos de trabalho de squash de múltiplos commits? Modelos gratuitos têm dificuldade com a nuance e precisão que essas operações exigem. Aprendi isso da pior forma quando um modelo gratuito tentou um force push mal raciocínado. Mantenha a complexidade do Git em modelos pagos.

Os limites de taxa: números reais e como lidar com eles

O plano gratuito te dá 200 requisições por dia e 20 requisições por minuto. Esses números parecem generosos até você ver um fluxo de trabalho agêntico em ação.

Uma única tarefa do Claude Code como "crie um componente React com testes" pode gerar 5-30 chamadas de API internamente. Chamadas de planejamento. Chamadas de geração de código. Chamadas de escrita de arquivos. Chamadas de execução de testes. Chamadas de correção de erros. Uma tarde de desenvolvimento ativo consome 200 requisições mais rápido do que você esperaria.

Estratégia 1: Agrupe seu trabalho. Em vez de usar o Claude Code esporadicamente ao longo do dia, concentro as sessões com modelos gratuitos em blocos focados. Manhã: criar esqueletos de componentes e escrever testes. Tarde: pesquisa e documentação. Assim fico confortavelmente dentro do limite diário.

Estratégia 2: O truque do depósito de $10. O OpenRouter tem um mecanismo inteligente — mantenha pelo menos $10 de créditos na sua conta, e seu limite diário de requisições pula para 1.000 mesmo para modelos gratuitos. Você não gasta esses créditos em requisições de modelos gratuitos. Eles ficam como saldo. Pense nisso como um depósito reembolsável que quintuplica sua capacidade. Com 1.000 requisições por dia, nunca cheguei perto do limite durante um dia de trabalho completo.

Estratégia 3: Roteamento híbrido. Mantenho minhas credenciais da Anthropic em um perfil de shell separado. Quando preciso de raciocínio nível Opus ou quando estou chegando perto do meu limite gratuito em um dia movimentado, carrego o perfil da Anthropic e volto. Escrevi sobre esse tipo de alocação estratégica de modelos no meu guia de otimização de custos de agentes IA. O segredo é decidir antes de começar uma tarefa se ela precisa de um modelo pago ou gratuito — trocar no meio da tarefa desperdiça contexto.

Estratégia 4: Monitoramento em tempo real. O painel do OpenRouter mostra seu contador de requisições ao vivo. Verifico no meio da tarde. Se estou em 150/200, mudo as tarefas restantes para modelos pagos em vez de arriscar bater no limite durante algo importante.

A prova que me convenceu: uma landing page SaaS em seis minutos

Teoria é bom. Prova é melhor.

Três dias depois de começar meu experimento com o OpenRouter, dei ao Nemotron 3 Super uma tarefa que normalmente reservaria para o Sonnet ou Opus:

Build a modern SaaS landing page for a project management tool called "FlowBoard."
Include: hero section with gradient background, feature grid with 4 features and icons,
pricing table with 3 tiers, testimonial section, and footer.
Use Tailwind CSS. Make it responsive. Primary color: indigo. Secondary: slate.

O Nemotron planejou a abordagem — um único arquivo HTML com Tailwind CDN, geração componente por componente, design responsivo mobile-first. Depois começou a construir.

Seis minutos depois, uma landing page completa estava aberta no meu navegador.

A seção hero tinha um degradê limpo de índigo para roxo que não parecia um template padrão. O grid de funcionalidades usava CSS Grid com Heroicons — o modelo escolheu uma biblioteca de ícones apropriada sem ser solicitado. A tabela de preços tinha três níveis estruturados com o do meio destacado como "recomendado." A seção de depoimentos incluía conteúdo placeholder de aparência realista com molduras circulares de avatar.

As falhas eram específicas e menores: padding uniforme py-16 entre seções em vez de espaçamento variado para ritmo visual. Uma borda de nível de preço não alinhava perfeitamente em telas móveis pequenas. Links do footer precisavam de URLs reais.

São correções de cinco minutos. Os 95% do trabalho — arquitetura de layout, comportamento responsivo, estrutura de componentes, sistema de cores, hierarquia tipográfica — estavam prontos. Por um modelo gratuito. Rodando na nuvem. Em seis minutos.

Eu já construí landing pages profissionalmente. Essa saída me levaria 2-3 horas manualmente e ficaria mais ou menos igual. O Opus teria acertado as nuances de espaçamento na primeira tentativa, mas para prototipagem, demos para clientes e ferramentas internas? A saída do Nemotron é mais que suficiente.

Esse build de seis minutos foi quando parei de pensar em modelos gratuitos como compromisso e comecei a vê-los como uma ferramenta legítima no stack.

A avaliação honesta: quando modelos gratuitos custam mais do que economizam

Vou ser direto sobre algo que a maioria dos artigos "use IA de graça" pula.

Houve uma quarta-feira à tarde em que tentei construir um componente de formulário Next.js moderadamente complexo no Nemotron 3 Super. Geração dinâmica de campos, lógica de visibilidade condicional, validação em tempo real, painel de pré-visualização. Não trivial, mas o tipo de coisa que o Opus resolve em uma única tentativa.

O Nemotron precisou de três tentativas. A primeira tinha um bug sutil de gerenciamento de estado. A segunda corrigiu esse bug mas introduziu um problema de renderização com os campos condicionais. A terceira tentativa funcionou, mas tive que corrigir manualmente dois casos extremos que o modelo não percebeu.

Tempo total: aproximadamente 40 minutos. Custo total: R$ 0.

No dia seguinte, executei a tarefa idêntica no Opus. Uma tentativa. Código limpo. Casos extremos corretos. Seis minutos. Custo: cerca de $0,30 em tokens.

Se meu tempo vale algo — e o seu também — gastar 34 minutos extras para economizar $0,30 é objetivamente um mau negócio. Isso dá uma taxa horária efetiva de $0,53. Mesmo no salário mínimo, você perdeu dinheiro com o modelo "gratuito."

Chamo isso de armadilha da falsa economia. O modelo é grátis. Seu tempo não é.

Modelos gratuitos fazem sentido econômico quando:

• A tarefa é simples o suficiente para o modelo acertar na primeira tentativa
• Você está experimentando e a qualidade da saída não importa
• Você está aprendendo e o processo de depuração em si é educativo
• Você executa tarefas agendadas ou em massa com prompts bem estruturados
• Você está prototipando algo que planeja reconstruir de qualquer forma

Modelos pagos fazem sentido econômico quando:

• A tarefa é complexa o suficiente para que erros custem mais tempo de depuração que a chamada de API
• Você está escrevendo código de produção onde confiabilidade importa
• Você tem um prazo e não pode se dar ao luxo de ciclos de iteração
• Você está trabalhando com código sensível à segurança
• A codebase é grande e requer raciocínio profundo entre arquivos

O ponto ideal que encontrei: modelos gratuitos lidam com 60-70% do meu uso diário do Claude Code — scaffolding, boilerplate, geração de testes, documentação, pesquisa, tarefas agendadas. Modelos pagos lidam com os 30-40% que exigem raciocínio de primeiro nível. A qualidade geral do meu trabalho não caiu. Meus custos mensais de API caíram cerca de 60%.

Cinco armadilhas em que caí para que você não precise

Três semanas de uso diário revelaram estes problemas:

Armadilha 1: A fatura fantasma da Anthropic. Se suas requisições funcionam mas seu painel da Anthropic continua mostrando cobranças crescentes, você não esvaziou a chave API corretamente ou não limpou o cache OAuth. Este é o modo de falha mais comum e o mais caro — você pensa que está no plano gratuito enquanto queima silenciosamente créditos pagos.

Armadilha 2: IDs de modelo que mudam. Identificadores de modelos gratuitos no OpenRouter podem mudar. Eu tinha nvidia/nemotron-3-super:free na minha configuração por duas semanas, e uma manhã o Claude Code começou a dar erros. O ID do modelo havia mudado ligeiramente no catálogo do OpenRouter. Se algo parar de funcionar de repente, verifique a página de modelos e atualize a string do ID no seu .zshrc.

Armadilha 3: Instruções do CLAUDE.md precisam de ajuste. Se você usa um arquivo CLAUDE.md de projeto (e deveria), suas instruções provavelmente estão otimizadas para o modelo com o qual foram escritas. Modelos gratuitos respondem de forma diferente às mesmas diretivas. Tive que simplificar algumas instruções — frases mais curtas, estrutura passo a passo mais explícita — para obter resultados consistentes do Nemotron.

Armadilha 4: Variação de latência entre dias. O desempenho de modelos gratuitos flutua com a carga do servidor. Alguns dias o Nemotron responde em 2 segundos; outros dias leva 5-6 segundos. A qualidade da saída permanece consistente, mas oscilações de latência podem atrapalhar fluxos de trabalho sensíveis ao tempo. Incorpore tratamento de timeout em qualquer automação que dependa de modelos gratuitos.

Armadilha 5: Depender demais de modelos gratuitos para operações Git. Commits e pushes básicos funcionam bem. Fluxos de trabalho Git complexos — rebase interativo, resolução de conflitos, reescrita de histórico — exigem o tipo de precisão que modelos gratuitos não entregam consistentemente. Um rebase mal fundamentado pode danificar seu histórico de commits. Mantenha a complexidade do Git em modelos pagos.

O que vem por aí para a qualidade dos modelos gratuitos

Três tendências estão tornando esta configuração mais poderosa a cada trimestre.

A qualidade dos modelos open-source está acelerando. Seis meses atrás, modelos gratuitos não conseguiam gerar de forma confiável um componente React funcional. O Nemotron 3 Super e o Qwen3 Coder produzem hoje uma saída que rivaliza com o que o Sonnet 3.5 entregava um ano atrás. A diferença entre modelos gratuitos e pagos está diminuindo rapidamente. NVIDIA, Meta, Alibaba e Mistral estão investindo pesado em modelos open-source porque a adoção em massa impulsiona seus negócios de infraestrutura. De acordo com a Artificial Analysis, o Nemotron 3 Super já lidera o benchmark de eficiência open-source — e foi lançado em março de 2026.

O catálogo de modelos gratuitos continua expandindo. A coleção gratuita do OpenRouter cresceu de cerca de 20 modelos no final de 2025 para 29 em março de 2026. Cada adição eleva o patamar do que está disponível sem custo. Os incentivos econômicos que impulsionam a disponibilidade de modelos gratuitos — modelos de negócio baseados em adoção, crescimento do ecossistema de desenvolvedores — não vão desaparecer.

O framework de agentes do Claude Code continua melhorando. Cada atualização que a Anthropic lança para o planejamento, uso de ferramentas e capacidades de sub-agentes do Claude Code beneficia todo modelo que você roteia por ele — incluindo os gratuitos. Melhor estrutura ao redor de um modelo mais fraco pode produzir resultados que se igualam a um modelo mais forte com menos estrutura. Esse efeito de alavancagem se acumula com o tempo.

A previsão honesta: dentro de um ano, modelos open-source gratuitos vão lidar com 80-90% das tarefas típicas de desenvolvimento em um nível de qualidade indistinguível do que modelos pagos de faixa média entregam hoje. As ferramentas para alternar entre gratuito e pago de forma transparente — sendo o OpenRouter a opção mais madura agora — se tornarão infraestrutura padrão para desenvolvedores.

Ainda não chegamos lá completamente. Mas oito minutos de configuração te levam mais perto do que você esperaria.

A configuração que mudou a matemática do meu fluxo de trabalho

Três semanas atrás, eu executava cada tarefa do Claude Code pela API da Anthropic. Cada scaffold de boilerplate. Cada geração de testes. Cada passada de documentação. Tudo cobrado em tarifas premium.

Hoje, essas tarefas rotineiras vão para o Nemotron 3 Super da NVIDIA pelo OpenRouter sem custo algum. O trabalho complexo de arquitetura, a depuração em produção, os projetos de clientes — esses ainda rodam no Opus, onde a precisão justifica o preço.

O resultado não é apenas economia, embora isso seja real — cerca de 60% de redução nos meus gastos mensais com API. A mudança maior é psicológica. Quando cada chamada de API custa dinheiro, você se autocensura inconscientemente. Hesita antes de executar consultas exploratórias. Pula o experimentar "deixa eu tentar três abordagens diferentes" que produz as melhores soluções. Otimiza para menos chamadas em vez de melhores resultados.

Quando 60% das suas chamadas são gratuitas, essa fricção desaparece. Você experimenta mais. Itera mais rápido. Pede ao Claude Code para tentar a abordagem especulativa porque o risco negativo é zero. E às vezes essa abordagem especulativa se revela a certa.

A configuração de oito minutos que te mostrei não é apenas uma otimização de custos. É uma estrutura de permissão. Permissão para usar assistência de IA da forma como funciona melhor — com frequência, experimentalmente, sem contar tokens.

Sua tarefa para esta noite: crie a conta no OpenRouter, configure três variáveis de ambiente, escolha o Nemotron 3 Super como seu padrão e execute a mesma tarefa que normalmente enviaria para um modelo pago. Compare a saída lado a lado. A diferença é menor do que você pensa — e para as tarefas onde mal importa, você acabou de eliminar a conta inteiramente.

Perguntas frequentes

Posso usar o Claude Code completamente de graça com o OpenRouter?

Sim. Crie uma conta gratuita no OpenRouter, gere uma chave de API e configure três variáveis de ambiente para redirecionar o Claude Code para o endpoint do OpenRouter. Sem necessidade de cartão de crédito. Você recebe 200 requisições por dia em 29 modelos open-source gratuitos com acesso completo às funcionalidades agênticas do Claude Code — gerenciamento de arquivos, comandos shell, busca web e prompts agendados.

Qual é o melhor modelo gratuito para programar com Claude Code em 2026?

O NVIDIA Nemotron 3 Super oferece o melhor desempenho geral para fluxos de trabalho mistos de desenvolvimento — geração de código, refatoração, pesquisa e documentação. Para geração de código puro, o Qwen3 Coder 480B é a opção gratuita mais forte no OpenRouter. Ambos têm janelas de contexto de 262K tokens. Para a comparação completa de modelos, veja a seção de testes acima.

Como aumento o limite diário de requisições do OpenRouter para modelos gratuitos?

Deposite $10 na sua conta do OpenRouter. Os créditos não são gastos em requisições de modelos gratuitos — ficam como saldo. Mas manter esse saldo desbloqueia 1.000 requisições diárias em vez das 200 padrão. Para desenvolvedores que executam fluxos de trabalho agênticos que geram dezenas de chamadas de API por tarefa, esse limite expandido cobre um dia de trabalho completo.

O Claude Code perde alguma funcionalidade ao usar modelos que não são da Anthropic?

O framework de agentes — operações com arquivos, comandos shell, busca web, tarefas agendadas, exploração de código — funciona de forma idêntica independentemente do modelo backend. O que muda é a qualidade do raciocínio do modelo, a profundidade de planejamento e a qualidade do código gerado. Modelos gratuitos lidam bem com tarefas simples mas têm dificuldade com planejamento complexo de múltiplos passos e raciocínio sobre grandes codebases comparados ao Opus ou Sonnet.

Por que o Claude Code continua cobrando minha conta da Anthropic depois de configurar o OpenRouter?

Duas causas comuns: você não configurou ANTHROPIC_API_KEY="" no seu perfil de shell (o que mantém credenciais em cache ativas), ou não executou /logout dentro do Claude Code para limpar o token OAuth. Ambos os passos são obrigatórios. Verifique sua configuração executando /status dentro do Claude Code — deve mostrar seu modelo e endpoint do OpenRouter, não um da Anthropic.

Vamos trabalhar juntos

Quer construir sistemas de IA, automatizar fluxos de trabalho ou escalar sua infraestrutura tecnológica? Adoraria ajudar.

• Fiverr (builds personalizados e integrações): fiverr.com/s/EgxYmWD
• Portfólio: mejba.me
• Ramlit Limited (soluções empresariais): ramlit.com
• ColorPark (design e branding): colorpark.io
• xCyberSecurity (serviços de segurança): xcybersecurity.io