A codificação agentiva moderna vai muito além do preenchimento automático: é um fluxo de trabalho de IA que pode planejar alterações, editar vários arquivos, executar comandos/testes e iterar até que a compilação seja bem-sucedida. Essa é exatamente a experiência para a qual o OpenCode foi criado: um agente de codificação com IA de código aberto que você pode usar no terminal (CLI/TUI), como aplicativo desktop ou como extensão de IDE.
Neste guia, você aprenderá a executar o GLM-4.7 dentro do OpenCode usando a API compatível com OpenAI da Novita AI. O GLM-4.7 é posicionado como um modelo principal com atualizações para codificação avançada e raciocínio/execução confiável de múltiplas etapas — uma combinação perfeita para o ciclo planejar → construir → verificar do OpenCode.
💡Ao final, você terá:
- OpenCode instalado e pronto para usar na sua interface preferida (terminal/desktop/IDE).
- GLM-4.7 conectado no OpenCode por meio do provedor Novita integrado (compatível com OpenAI). Você selecionará o GLM-4.7 e começará a codificar imediatamente.
- Um primeiro projeto completo construído com um fluxo de trabalho agentivo (implementação + testes + documentação).
O que é o OpenCode?
O OpenCode é um agente de codificação com IA de código aberto que você pode executar em vários ambientes de desenvolvimento — mais comumente como uma interface baseada em terminal (CLI + TUI), mas também como um aplicativo desktop ou uma extensão de IDE.
Para que você o usa
O OpenCode foi criado para ajudar você a passar da “ideia → código funcional” mais rápido, agindo como um colega de codificação leve que pode:
- Entender um repositório e seguir instruções em vários arquivos
- Gerar novo código, refatorar código existente e ajudar a depurar problemas
- Trabalhar em um loop semelhante a um chat dentro do seu terminal (TUI) ou por meio de comandos (CLI)
Qual a diferença entre OpenCode e Claude Code
OpenCode e Claude Code são ambos agentes de codificação com IA baseados em terminal, mas seguem caminhos diferentes.
- OpenCode é um agente de código aberto e agnóstico a provedores: destaca o suporte a “mais de 75 provedores de LLM por meio do Models.dev (incluindo modelos locais)” e se posiciona como uma ferramenta flexível que você pode conectar a diferentes backends de modelo.
- Claude Code, por sua vez, é a CLI oficial focada no Claude da Anthropic — uma ferramenta de linha de comando para acessar modelos Claude no terminal — além de um ecossistema oficial de extensões (plugins) e conexões de ferramentas/dados por meio do MCP (Protocolo de Contexto de Modelo).
Tabela de comparação rápida
| Aspecto | OpenCode | Claude Code |
| Posicionamento | Agente de codificação terminal de código aberto e multimodelo | Agente de codificação terminal oficial da Anthropic focado no Claude |
| Escolha de modelo/provedor | Mais de 75 provedores de LLM por meio do Models.dev, incluindo modelos locais | Construído em torno do Claude; se expande por meio de MCP + plugins |
| Automação no GitHub | Gatilhos de comentário /opencode ou /oc; executa no runner do GitHub Actions | Extensões focadas em plugins/MCP (ecossistema oficial) |
| Ponto de entrada de preço | Ferramenta é de código aberto; o custo depende do backend de modelo escolhido | Planos Claude (Pro/Max/Team/Enterprise) na página de preços oficial |
Por que o GLM-4.7?
O GLM-4.7 é posicionado como um modelo principal otimizado para codificação agentiva, ou seja, foi projetado para ter um desempenho melhor em fluxos de trabalho onde um agente de codificação deve planejar, usar ferramentas e concluir tarefas de múltiplas etapas de forma confiável.
Criado para desenvolvimento no estilo “agente” (planejamento + ferramentas + entrega)
De acordo com a documentação oficial do modelo, o GLM-4.7 enfatiza:
- Maior capacidade de codificação, incluindo melhor desempenho em cenários de agente de terminal e um fluxo de trabalho “pensar depois agir” mais consistente em frameworks de codificação
- Planejamento de tarefas de longo prazo aprimorado e coordenação de ferramentas (fundamental para refatorações em nível de repositório, loops de correção de bugs e alterações em vários arquivos)
- Seguimento de instruções mais forte durante o uso de ferramentas e melhor eficiência na conclusão de tarefas de ponta a ponta em fluxos de trabalho agentivos
Isso se alinha extremamente bem com a forma como o OpenCode é usado: geralmente você pede para ele implementar uma alteração, executar comandos/testes, iterar sobre falhas e finalizar entregas.
Contexto grande + saída grande: melhor para repositórios reais
Para agentes de codificação, a janela de contexto e os limites de saída importam, pois você geralmente precisa carregar:
- estrutura do projeto + arquivos principais + configurações
- logs/falhas de testes
- várias iterações de patches
O GLM-4.7 tem documentada uma janela de contexto de 200K e até 128K tokens máximos de saída, o que é especialmente útil quando você lida com repositórios grandes ou precisa que o modelo gere código e documentação substanciais em uma única passagem.
Prontidão para ferramentas (Chamada de Função + MCP)
A codificação agentiva não é apenas geração de texto — geralmente requer chamadas de ferramentas estruturadas e integrações. A documentação do GLM-4.7 destaca o suporte a Chamada de Função, saídas estruturadas (ex.: JSON) e conectividade MCP para acesso a ferramentas/dados, o que pode melhorar a confiabilidade quando um agente precisa “fazer” coisas, não apenas “dizer” coisas.
Bônus: geração de frontend de qualidade superior
Se seus fluxos de trabalho no OpenCode incluem scaffolding de UI ou iteração de frontend, a documentação do GLM-4.7 destaca explicitamente melhorias na qualidade estética do frontend (útil para gerar código de UI mais limpo e resultados mais apresentáveis).
Como instalar o OpenCode
O OpenCode oferece algumas opções de instalação. A mais rápida é o script de instalação de uma linha, e a mais portável é instalar o pacote npm (opencode-ai).
macOS / Linux
Recomendado
curl -fsSL https://opencode.ai/install | bash
Ou (multiplataforma)
npm install -g opencode-ai
# or
bun add -g opencode-ai
Iniciar:
opencode
Windows
Recomendado
npm install -g opencode-ai
# or
bun add -g opencode-ai
curl | bashrequer um ambiente bash (WSL ou Git Bash). No PowerShell/CMD, use npm/bun.
Iniciar:
opencode
Como usar o GLM 4.7 no OpenCode
Como obter sua chave de API na Novita AI
-
Etapa 1: Crie ou faça login na sua conta Acesse
[https://novita.ai](https://novita.ai)e cadastre-se ou faça login na sua conta existente -
Etapa 2: Acesse o gerenciamento de chaves Depois de fazer login, encontre “Chaves de API”
-
Etapa 3: Crie uma nova chave Clique no botão “Adicionar nova chave”.
-
Etapa 4: Salve sua chave imediatamente Copie e armazene a chave assim que ela for gerada; geralmente ela é exibida apenas uma vez e não pode ser recuperada posteriormente. Guarde a chave em um local seguro, como um gerenciador de senhas ou notas criptografadas
Adicione sua chave de API Novita ao OpenCode
- Inicie o OpenCode:
opencode
- No prompt do OpenCode, execute:
/connect
- Pesquise e selecione Novita AI, depois cole sua chave de API Novita.
- Selecione o GLM-4.7
Construa seu primeiro projeto: Hit the Key!
Para uma demonstração ao vivo, um pequeno jogo de terminal é geralmente mais interessante do que uma API web — você pode ver o loop acontecer em tempo real: especificação → gerar → executar → iterar → lançar. Nesta seção, construiremos um minijogo de tempo de reação mínimo chamado “Hit the Key”.
A ideia é simples: o jogo mostra uma letra aleatória de A a Z por 10 rodadas. Você digita a letra e pressiona Enter. Medimos o tempo de reação; qualquer valor superior a 1,2s conta como erro. No final, o jogo exibe uma tabela de pontuação e persiste o melhor resultado em highscore.json.
Alterne para o modo Build e execute
Pressione Tab para alternar para o modo Build (ferramentas ativadas). Depois cole o prompt de execução abaixo.
Prompt
Construa um minijogo de terminal pequeno chamado “Hit the Key”. Requisitos:
- Mantenha como um único arquivo Python (game.py). Use a biblioteca
richpara a interface: exibição de letra grande, contagem regressiva, barra de progresso e uma tabela de pontuação final.- O jogo dura 10 rodadas. Cada rodada mostra uma letra aleatória de A a Z. O jogador deve digitar essa letra e pressionar Enter.
- Temporização: meça o tempo de reação desde o momento em que a letra aparece até o jogador pressionar Enter. Se exceder 1,2 segundos, a rodada é considerada um erro.
- Estatísticas: calcule a precisão, o tempo de reação médio e a maior sequência de acertos. Persista a melhor pontuação em
highscore.json.- Forneça as instruções de execução exatas e execute-o localmente uma vez para verificar se funciona. Mantenha o código curto e bem comentado.
Execute localmente e verifique a experiência
Assim que o agente terminar de gerar o game.py, execute-o localmente:
py -m pip install rich
py game.py
Jogue as 10 rodadas, depois confira se a saída inclui:
- Feedback instantâneo por rodada (acerto/erro + tempo de reação)
- Uma tabela de pontuação final (precisão, tempo de reação médio, maior sequência de acertos)
- Uma mensagem de “novo recorde” quando aplicável
- Um arquivo
highscore.jsonsalvo/atualizado no diretório do projeto
O que você demonstrou com esta demonstração
Com apenas um script curto, você demonstrou o loop “agentivo” completo para o qual o OpenCode foi criado:
- Construir a partir de uma especificação: um minijogo completo gerado a partir de um prompt estruturado
- Executar e verificar: o projeto é executado localmente, não apenas “escrito”
- Entregar um artefato real: os resultados persistem por meio do
highscore.json, tornando a demonstração repetível e comparável entre execuções
Esse é o tipo de ciclo de feedback rápido que faz o OpenCode parecer um parceiro de engenharia real — especialmente em demonstrações ao vivo, onde “ver funcionando” importa mais do que ler código.
💡 Mais coisas que você pode fazer com o OpenCode
A demonstração “Hit the Key” é pequena de propósito, mas o mesmo loop escala para trabalhos reais: planejar → construir → executar → corrigir → lançar. Na prática, o OpenCode é mais útil para:
- Planejamento seguro de arquitetura e alterações (Planejar): gere uma árvore de arquivos, um plano de implementação passo a passo e critérios de aceitação antes de tocar no repositório.
- Implementação prática (Construir): crie/edite arquivos, execute comandos e itere até que os testes passem — mantendo as alterações pequenas e passíveis de revisão.
- Automação controlada com permissões: configure o que o agente pode executar automaticamente versus o que deve ser aprovado (ou bloqueado), para que você possa delegar tarefas repetitivas com segurança.
- Execuções não interativas e reproduzíveis (CLI): script de tarefas como “executar testes e resumir falhas” ou anexe uma TUI a uma sessão de backend remoto para fluxos de trabalho consistentes entre máquinas.
- Colaboração nativa do GitHub: acione o OpenCode a partir de comentários de issues/PRs (ex: triagem, implementação de correções/funcionalidades e envio de um PR a partir de um runner).
- Agentes especializados: crie agentes personalizados com prompts sob medida e configurações de ferramentas/permissões para funções como “apenas revisão”, “documentação” ou "depura
OpenCode além do terminal: Aplicativo desktop + integrações com IDE
O OpenCode é geralmente usado no terminal, mas você também pode executá-lo como um aplicativo desktop (Beta) ou dentro da sua IDE — e em ambos os casos, você pode continuar usando a API compatível com OpenAI da Novita AI. A interface muda, mas a configuração de modelo/provedor permanece a mesma: aponte o provedor OpenAI e selecione zai-org/glm-4.7.
Aplicativo desktop
A versão desktop do OpenCode está disponível para macOS, Windows e Linux. Se você prefere uma interface independente para sessões de agente mais longas, o aplicativo desktop é uma ótima opção — e ele pode usar a mesma configuração de provedor que você já criou para a Novita AI.
Integrações com IDE
O OpenCode oferece fluxos de integração oficiais para:
- VS Code
- Cursor
- Zed
- Windsurf
- VSCodium
Conclusão
O OpenCode traz a codificação agentiva para o seu fluxo de trabalho diário — seja no terminal, no aplicativo desktop ou na IDE. Com o GLM-4.7 conectado por meio da API compatível com OpenAI da Novita AI, você pode lidar de forma confiável com tarefas de múltiplas etapas, como planejar alterações, editar vários arquivos, executar testes e iterar até que o projeto seja lançado.
Novita AI é uma plataforma de nuvem de IA que oferece aos desenvolvedores uma maneira fácil de implantar modelos de IA usando nossa API simples, além de fornecer nuvem de GPU acessível e confiável para construir e escalar.
Perguntas frequentes
O que é o OpenCode? O OpenCode é um editor de código baseado em navegador que traz modelos de IA diretamente para o seu espaço de trabalho. Você pode editar código, executar scripts e colaborar com um assistente de IA em tempo real. Ao configurar um provedor como o NaviGator Toolkit, você pode personalizar o OpenCode para ser seu próprio copiloto de codificação com IA pessoal.
O OpenCode é seguro? Sim, o OpenCode não armazena nenhum dos seus códigos ou dados de contexto, para que possa operar em ambientes sensíveis à privacidade.
O OpenCode é gratuito? O OpenCode é uma daquelas ferramentas de código aberto raras que fazem você parar para pensar. Atualmente está no topo do GitHub com ~72k estrelas — e depois de experimentá-lo, o momentum faz sentido. Pense nele como um agente de codificação com IA da mesma linha do Claude Code, mas totalmente gratuito e de código aberto.
