Guia prático para encontrar, configurar e testar modelos de IA sem pagar pelo uso do modelo

Você não precisa necessariamente pagar por um modelo de inteligência artificial para começar a usar o OpenCode.

O OpenCode pode trabalhar com diversos provedores de modelos de IA e também oferece suporte a modelos executados localmente. A documentação oficial informa que a ferramenta atualmente suporta mais de 75 provedores LLM, além de modelos locais.

Mas existe uma diferença importante:

usar o OpenCode sem pagar pelo software não significa que todos os modelos disponíveis dentro dele sejam gratuitos.

Alguns modelos podem ser gratuitos, outros podem exigir pagamento, alguns podem oferecer utilização gratuita com limites e outros podem funcionar localmente no próprio computador.

Neste guia, você vai aprender a encontrar uma opção gratuita disponível, conectá-la ao OpenCode, selecioná-la e fazer um primeiro trabalho de programação com ela.

Mais importante: você vai aprender como avaliar um modelo gratuito, em vez de depender de uma lista fixa que pode ficar desatualizada.

Última revisão: setembro de 2026.

OpenCode + modelo gratuito: como funciona?

Antes de começar, vale entender a estrutura.

Pense no processo desta maneira:

OpenCode → Provedor → Modelo de IA → Seu projeto

O OpenCode é o ambiente que coordena o trabalho.

O provedor disponibiliza o acesso ao modelo.

O modelo é quem interpreta suas instruções, analisa o código e pode utilizar as ferramentas disponíveis para trabalhar no projeto.

Por isso, é perfeitamente possível ter:

OpenCode instalado gratuitamente;
um provedor com uma opção gratuita;
um modelo gratuito;
ou um modelo local executado no próprio computador.

Mas essas quatro coisas não são a mesma coisa.

Uma distinção importante

OpenCode é o software.

Modelo de IA é o sistema que gera respostas e código.

Provedor é o serviço que disponibiliza o modelo.

Modelo local é aquele que pode ser executado no seu próprio computador, dependendo da configuração e do hardware.

A documentação oficial do OpenCode confirma que a ferramenta pode trabalhar tanto com provedores externos quanto com modelos locais.

Antes de começar: o que você precisa

Para acompanhar este tutorial, você deverá ter:

o OpenCode instalado;
um projeto para testar;
acesso à internet, caso utilize um modelo hospedado;
uma conta em um provedor, quando ela for necessária;
um modelo disponível para utilização.

Se você ainda não instalou o OpenCode no Windows, recomendamos começar pelo nosso tutorial:

Como instalar o OpenCode no Windows: guia passo a passo

O importante é que, ao terminar este artigo, você não apenas tenha conectado um modelo, mas tenha usado esse modelo em uma tarefa real.

O caminho que vamos percorrer

Para facilitar, este será o nosso percurso:

1. Encontrar uma opção gratuita

↓

2. Conectar o provedor

↓

3. Selecionar o modelo

↓

4. Fazer um teste somente de leitura

↓

5. Pedir uma pequena alteração

↓

6. Revisar o resultado

↓

7. Avaliar se o modelo realmente serve para programação

Essa ordem é proposital.

Em vez de entregar imediatamente o controle do projeto à IA, vamos primeiro observar o que ela consegue fazer.

O que significa “modelo gratuito”?

Essa é uma das partes mais importantes do artigo.

Quando alguém diz que um modelo é “gratuito”, isso pode significar coisas diferentes.

Por exemplo:

Gratuito com limites

O serviço pode permitir utilização sem cobrança, mas estabelecer limites de uso.

Gratuito temporariamente

Uma determinada oferta pode estar disponível sem cobrança durante um período promocional.

Gratuito em determinadas condições

O provedor pode oferecer uma quantidade limitada de utilização gratuita ou restringir determinados recursos.

Modelo local

Nesse caso, você não está necessariamente pagando por chamadas a uma API remota. O modelo é executado na sua própria máquina.

Isso não significa, porém, que modelos locais sejam sempre “sem custo”: o computador, a eletricidade e eventualmente o hardware necessário também fazem parte da equação.

Por isso, gratuito não significa necessariamente ilimitado.

E essa é uma das razões pelas quais este artigo não apresenta uma lista definitiva de “modelos gratuitos”.

A própria documentação do OpenCode informa que novos modelos são lançados regularmente e que sua lista de modelos recomendados não é exaustiva nem necessariamente atualizada.

Como encontrar modelos gratuitos disponíveis

Aqui está uma regra que vale mais do que decorar nomes de modelos:

Procure primeiro o que está disponível atualmente no provedor que você pretende utilizar.

O OpenCode permite configurar provedores e, depois, selecionar os modelos disponíveis através do comando:

/models

A documentação oficial explica que, depois de configurar um provedor, o comando /models permite selecionar o modelo desejado.

Isso é importante porque o catálogo de modelos pode mudar.

Um modelo que hoje aparece como gratuito pode amanhã ter limite diferente, mudar de provedor ou deixar de estar disponível.

Por isso, o procedimento mais confiável é:

Escolher um provedor.
Verificar as condições atuais desse provedor.
Procurar uma opção gratuita.
Conectar o provedor ao OpenCode.
Abrir /models.
Selecionar o modelo disponível.
Testar antes de utilizá-lo em trabalhos importantes.

Como conectar um provedor ao OpenCode

Com o OpenCode aberto, utilize:

/connect

O comando /connect é utilizado para adicionar as credenciais de um provedor.

A documentação oficial informa que as credenciais adicionadas dessa maneira são armazenadas localmente em:

~/.local/share/opencode/auth.json

Depois de executar:

/connect

o OpenCode apresenta os provedores disponíveis.

Escolha aquele que oferece o modelo que você pretende testar.

Dependendo do provedor, você poderá precisar:

fazer login;
autorizar o acesso;
criar uma chave de API;
copiar uma chave;
ou utilizar outro método de autenticação disponibilizado pelo serviço.

Importante

O fato de o OpenCode aceitar um provedor não significa que o provedor seja gratuito.

Sempre confira as condições atuais do serviço antes de inserir uma forma de pagamento ou utilizar uma API que possa gerar cobrança.

Como escolher o modelo com `/models`

Depois de configurar o provedor, execute:

/models

O OpenCode apresentará os modelos disponíveis para seleção.

É aqui que muitas pessoas cometem um erro.

Elas simplesmente escolhem o modelo que aparece primeiro ou aquele cujo nome parece mais poderoso.

Para programação, isso não é suficiente.

Não escolha apenas porque está escrito “Free”

Um modelo gratuito precisa ser avaliado pelo que consegue fazer.

Antes de escolhê-lo para trabalhar no seu projeto, procure responder:

1. Ele é adequado para programação?

Um modelo pode ser excelente para conversas gerais e ainda assim não ser particularmente adequado para desenvolvimento de software.

2. Ele consegue utilizar ferramentas?

Esse ponto é especialmente importante no OpenCode.

O OpenCode não é apenas uma interface de conversa. Seus modelos podem utilizar ferramentas para ler arquivos, pesquisar conteúdo, editar código, executar comandos e realizar outras ações, dependendo da configuração e das permissões.

3. Existem limites?

Verifique quantidade de solicitações, velocidade, contexto ou outras restrições impostas pelo provedor.

4. A gratuidade é permanente?

Não presuma isso.

5. Ele funciona bem com a tarefa que você pretende executar?

Essa é a pergunta mais importante.

Um modelo pode ser perfeitamente adequado para explicar um trecho de código, mas ter mais dificuldade em uma tarefa complexa que envolve muitos arquivos.

Primeiro teste: não altere nada

Agora vamos realmente testar o modelo.

Mas não vamos começar pedindo para ele modificar o projeto.

Essa é uma boa prática.

Abra o OpenCode dentro de um projeto de teste e peça:

Analise este projeto e explique como ele está organizado.
Identifique os principais arquivos e explique a função de cada parte.
Não altere nenhum arquivo.

Observe a resposta.

O modelo conseguiu identificar corretamente os arquivos?

Entendeu a estrutura?

Conseguiu explicar a finalidade do projeto?

Se a resposta for confusa ou muito superficial, isso já fornece uma informação importante sobre a capacidade daquele modelo.

Por que começar com uma tarefa somente de leitura?

Porque estamos fazendo um teste controlado.

Imagine que você acabou de encontrar um modelo gratuito e imediatamente pede:

“Reescreva todo o sistema de autenticação do meu projeto.”

Se algo der errado, você terá dificuldade para saber se o problema veio:

do modelo;
do prompt;
da configuração;
da compreensão do projeto;
ou da própria tarefa.

Começando com uma análise, conseguimos observar o comportamento do modelo antes de permitir alterações.

Essa abordagem também ajuda a reduzir o risco de alterações desnecessárias.

Segundo teste: peça uma alteração pequena

Se o primeiro teste funcionar bem, passe para uma tarefa controlada.

Por exemplo:

Quero fazer uma pequena melhoria neste projeto.

Primeiro explique quais arquivos precisam ser alterados.
Depois faça somente essa alteração.
Não modifique outros arquivos sem necessidade.
Ao terminar, explique exatamente o que foi alterado.

Você pode substituir “pequena melhoria” por uma tarefa específica do seu projeto.

O objetivo não é criar algo sofisticado.

O objetivo é verificar se o modelo consegue:

entender a solicitação;
localizar os arquivos;
planejar;
modificar o código;
explicar o que fez.

Terceiro teste: peça uma revisão

Depois da alteração, peça ao próprio modelo:

Revise a alteração que você acabou de fazer.

Procure erros, inconsistências ou problemas que possam impedir o funcionamento do projeto.

Não faça novas alterações ainda.
Primeiro explique os problemas encontrados, se houver.

Essa etapa é muito útil.

Ela cria um ciclo:

pedido → implementação → revisão

E mostra uma das características mais importantes ao trabalhar com agentes de programação:

A IA pode produzir código útil, mas não deve ser tratada como infalível.

Como saber se o modelo gratuito está funcionando bem?

Não existe um único teste que determine se um modelo é bom ou ruim para todos os projetos.

O ideal é observar seu comportamento em tarefas diferentes.

Um modelo está mostrando sinais positivos quando consegue:

entender a estrutura do projeto;
localizar arquivos relevantes;
explicar código existente;
seguir instruções específicas;
modificar apenas o necessário;
utilizar corretamente as ferramentas disponíveis;
identificar problemas;
corrigir erros;
manter contexto suficiente durante a tarefa.

O próprio OpenCode destaca que alguns modelos podem ser bons tanto na geração de código quanto na utilização de ferramentas. Por isso, para um agente de programação, não basta avaliar apenas a qualidade da conversa.

Modelo gratuito que conversa bem não é necessariamente modelo gratuito que programa bem

Essa distinção merece atenção.

Imagine dois modelos.

O primeiro responde muito bem a perguntas como:

“Explique o que esta função faz.”

O segundo consegue:

localizar o arquivo correto;
alterar o código;
executar um teste;
interpretar o resultado;
corrigir o problema.

Para utilizar o OpenCode como agente de programação, a segunda capacidade pode ser muito mais importante.

Por isso, nosso teste deve envolver o trabalho real que queremos realizar.

E se o modelo gratuito não conseguir fazer a tarefa?

Não significa necessariamente que o OpenCode esteja com problema.

O problema pode estar no próprio modelo, no provedor, na tarefa ou nas limitações disponíveis.

Uma estratégia simples é separar as possibilidades.

O modelo não entende o projeto

Tente uma tarefa menor.

O modelo responde, mas não consegue trabalhar com arquivos

Verifique se o modelo/provedor suporta adequadamente as ferramentas necessárias.

O modelo atinge um limite

Verifique as condições atuais do provedor e procure outra opção disponível.

O modelo apresenta muitos erros

Teste outro modelo antes de concluir que o OpenCode é o problema.

O modelo funciona para tarefas simples, mas não para tarefas grandes

Isso pode indicar limitações de contexto, capacidade ou ferramentas.

Um modelo gratuito pode ser suficiente para começar?

Sim.

Para aprender a usar o OpenCode, você não precisa necessariamente começar com o modelo mais sofisticado disponível.

Um modelo gratuito pode ser suficiente para aprender:

como o agente funciona;
como estruturar prompts;
como analisar um projeto;
como pedir alterações;
como revisar código;
como trabalhar com ferramentas.

Esse é justamente um dos objetivos deste artigo.

Aprender o fluxo primeiro.

Depois, você pode decidir se precisa de outro modelo.

Como evitar gastar dinheiro por engano

Essa é uma seção que recomendamos não ignorar.

Se você está procurando uma experiência gratuita, tenha cuidado com uma situação bastante comum:

confundir “modelo disponível” com “modelo gratuito”.

O fato de um modelo aparecer no /models não significa automaticamente que ele seja gratuito.

Antes de utilizar um provedor pago, confira:

a página de preços;
as condições do plano;
limites gratuitos;
necessidade de adicionar forma de pagamento;
cobrança por uso;
eventuais créditos promocionais.

O OpenCode suporta muitos provedores diferentes, e cada um pode ter suas próprias regras comerciais.

Regra simples

Se você não sabe como aquele provedor cobra, não presuma que é gratuito.

E os modelos locais?

Existe outra maneira de usar IA com o OpenCode:

executar o modelo no próprio computador.

Nesse cenário, o fluxo muda:

OpenCode → servidor/modelo local → seu computador

O OpenCode possui suporte a modelos locais, e sua documentação inclui essa possibilidade entre as formas de utilização.

A grande diferença é que agora seu computador passa a ser muito mais importante.

Você deverá considerar:

memória RAM;
GPU;
armazenamento;
velocidade do processador;
tamanho do modelo;
velocidade de geração.

Para quem quer experimentar esse caminho, o próximo passo natural é conhecer o Ollama.

Modelos gratuitos na nuvem x modelos locais

Característica	Modelo gratuito na nuvem	Modelo local
Onde é processado	Servidor do provedor	Seu computador
Internet	Normalmente necessária	Pode funcionar localmente
Hardware local	Menos importante	Muito importante
Limites	Definidos pelo provedor	Dependem da configuração
Configuração	Geralmente mais simples	Pode exigir mais conhecimento
Privacidade	Depende do provedor	Dados podem permanecer localmente, conforme a configuração
Custo	Pode haver opção gratuita	Não há cobrança por chamada de API local, mas há custo de hardware/energia

Nenhuma das duas abordagens é universalmente adequada para todas as pessoas.

A escolha depende do projeto, do computador e do tipo de utilização.

Quanto o computador importa?

Se você estiver usando um modelo remoto, seu computador precisa principalmente executar o OpenCode e o ambiente do projeto.

Já no caso de um modelo local, a situação muda bastante.

Um modelo maior pode exigir muito mais memória e processamento.

Por isso, um computador que funciona perfeitamente com um modelo remoto pode não ter recursos suficientes para executar confortavelmente um modelo local.

Esse é um dos motivos pelos quais nosso próximo conteúdo sobre Ollama será importante para quem quer explorar IA local.

Segurança: uma regra importante antes de deixar a IA alterar seu projeto

O OpenCode possui um sistema de permissões que permite definir se determinadas ações devem ser permitidas automaticamente, solicitar aprovação ou ser bloqueadas.

As opções incluem:

allow — permitir;
ask — pedir aprovação;
deny — bloquear.

Para quem está começando, vale adotar uma postura conservadora.

Antes de tarefas importantes:

faça backup;
use Git quando possível;
não coloque senhas ou chaves secretas no código;
revise alterações importantes;
tenha cuidado com comandos executados pelo agente.

O OpenCode oferece ferramentas capazes de interagir com o ambiente do projeto, incluindo leitura, edição e execução de comandos. Por isso, é importante entender o que está sendo autorizado.

Um exercício completo: seu primeiro trabalho com um modelo gratuito

Agora vamos juntar tudo.

Escolha um projeto pequeno.

Pode ser:

uma página HTML;
um pequeno projeto JavaScript;
uma aplicação Python;
um projeto de estudo;
ou qualquer código que você possa modificar sem grandes riscos.

Etapa 1 — Analisar

Peça:

Analise este projeto e explique sua estrutura.
Não altere nenhum arquivo.

Leia a resposta.

Etapa 2 — Planejar

Depois:

Sugira uma pequena melhoria que possa ser implementada
sem alterar a arquitetura do projeto.

Explique quais arquivos precisariam ser modificados
e como você faria a alteração.
Não altere os arquivos ainda.

Agora avalie o plano.

Etapa 3 — Implementar

Se o plano fizer sentido:

Implemente a melhoria que você acabou de propor.

Altere somente os arquivos necessários.
Ao terminar, explique exatamente o que foi modificado.

Etapa 4 — Revisar

Depois:

Revise a implementação.

Procure erros, inconsistências, problemas de segurança
ou comportamentos inesperados.

Não faça novas alterações ainda.
Primeiro apresente os problemas encontrados.

Etapa 5 — Testar

Finalmente:

Explique como posso testar a alteração que foi feita
e quais resultados devo esperar.

Você acabou de realizar um ciclo básico de desenvolvimento assistido por IA:

Analisar → Planejar → Implementar → Revisar → Testar

Esse fluxo é muito mais importante do que decorar o nome de um determinado modelo gratuito.

O que você acabou de aprender

Ao terminar este tutorial, você deve saber:

que OpenCode e modelo de IA são coisas diferentes;
que existem modelos gratuitos e pagos;
que a disponibilidade dos modelos pode mudar;
como conectar um provedor usando /connect;
como visualizar modelos usando /models;
por que um modelo precisa ser avaliado também pela capacidade de utilizar ferramentas;
como testar um modelo sem modificar o projeto;
como fazer uma alteração controlada;
como pedir uma revisão;
como evitar assumir que um modelo é gratuito;
qual é a diferença básica entre modelos remotos e locais.

Mais importante:

você aprendeu um método para experimentar modelos diferentes.

Modelos gratuitos mudam. O método permanece.

Essa talvez seja a ideia mais importante deste artigo.

Não queremos que você memorize:

“Use o modelo X porque ele é gratuito.”

Esse tipo de recomendação pode envelhecer rapidamente.

Queremos que você saiba fazer isto:

1. Encontrar uma opção disponível.

2. Conferir suas condições.

3. Conectar o provedor.

4. Selecionar o modelo.

5. Testá-lo em uma tarefa pequena.

6. Avaliar o resultado.

7. Trocar de modelo quando necessário.

Dessa maneira, mesmo que os modelos disponíveis mudem, o conhecimento deste artigo continuará útil.

Perguntas frequentes

É possível usar o OpenCode sem pagar?

Sim, é possível utilizar o OpenCode com opções gratuitas, dependendo do provedor, modelo e condições disponíveis. O software e o acesso aos modelos são questões diferentes.

Todo modelo mostrado no `/models` é gratuito?

Não. O /models mostra modelos disponíveis para os provedores configurados. A condição de uso depende do provedor e do modelo.

O que faz o `/connect`?

O /connect permite configurar as credenciais de um provedor para utilização no OpenCode.

Para que serve o `/models`?

O comando /models permite visualizar e selecionar os modelos disponíveis depois que um provedor foi configurado.

Modelo gratuito significa ilimitado?

Não. Um modelo pode ser disponibilizado gratuitamente e ainda possuir limites de utilização, velocidade, contexto ou disponibilidade.

Preciso de um modelo pago para aprender OpenCode?

Não necessariamente. Um modelo gratuito pode ser suficiente para aprender o funcionamento básico do OpenCode e experimentar tarefas de programação.

Um modelo gratuito consegue programar?

Alguns conseguem realizar tarefas de programação, mas a capacidade varia entre modelos. Além de gerar código, é importante verificar como o modelo trabalha com as ferramentas utilizadas pelo OpenCode.

Posso usar um modelo local?

Sim. O OpenCode oferece suporte a modelos locais.

Qual modelo gratuito é o melhor?

Não existe uma resposta universal. A disponibilidade muda, e o modelo mais adequado depende da tarefa. O melhor procedimento é testar uma opção disponível com tarefas pequenas e avaliar os resultados.

O que fazer se o modelo gratuito atingir um limite?

Verifique as condições atuais do provedor, procure outra opção gratuita disponível ou considere utilizar um modelo local ou um serviço pago, dependendo da sua necessidade.

Conclusão

Usar modelos gratuitos de IA no OpenCode não significa simplesmente encontrar um modelo com a palavra “Free” e começar a programar.

O processo envolve entender a diferença entre OpenCode, provedor e modelo, verificar as condições de utilização, conectar o provedor, selecionar o modelo e testar sua capacidade em tarefas reais.

O mais importante é não depender de uma lista fixa de modelos.

Os modelos mudam. Os provedores mudam. As condições de uso mudam.

O conhecimento que permanece é o método:

encontrar → configurar → testar → avaliar → escolher.

Com esse processo, você pode experimentar diferentes modelos sem transformar cada mudança do mercado de IA em um novo obstáculo.

E, quando quiser dar o próximo passo, existe outro caminho interessante: executar a IA localmente no próprio computador.

O que ler depois

Quer entender melhor os modelos por trás do OpenCode?

O que é um LLM? Entenda os modelos de linguagem

Você vai entender o que são modelos de linguagem, como funcionam e por que diferentes modelos apresentam capacidades diferentes.

Quer rodar IA no próprio computador?

Como rodar uma IA localmente no seu PC com Ollama

Um guia para começar a executar modelos localmente.

Ainda não instalou o Ollama?

Como instalar o Ollama no Windows

Passo a passo para configurar o ambiente.

Quer combinar as duas tecnologias?

OpenCode + Ollama: como usar IA local para programar

O próximo passo para quem quer utilizar modelos locais diretamente no fluxo de programação.

Fontes oficiais

As informações técnicas sobre provedores, modelos, /connect, /models, ferramentas e permissões foram conferidas na documentação oficial do OpenCode.

Documentação oficial — Modelos do OpenCode

Documentação oficial — Provedores do OpenCode

Documentação oficial — Ferramentas do OpenCode

Documentação oficial — Permissões do OpenCode

Última revisão editorial: setembro de 2026.