OpenCode Go + CodeGraph: modelos baratos dão conta do trabalho?

Autoria: The Gray Cat · Assistir no YouTube

Vídeo de autoria do canal indicado, não da IANIA; todos os direitos pertencem ao criador. Transcrição, resumo e tradução gerados automaticamente; o conteúdo no idioma original é preservado na versão em idioma original.

Idioma original: inglês

Vídeo original: OpenCode Go + CodeGraph: Can Cheap Models Do the Job? · Canal: The Gray Cat · 09:09 · Assistir no YouTube

Tópicos: Agentes de IA, Automação de tarefas e workflows, Avaliação e benchmarks de IA, Ferramentas de desenvolvimento com IA, Modelos de IA

Resumo

O vídeo compara modelos mais baratos no OpenCode, com e sem CodeGraph, em uma tarefa de adicionar ao The Gray Cut um enquadramento automático do rosto para vídeos editados no Premiere. O efeito do CodeGraph variou bastante: reduziu o uso de tokens em algumas tentativas, mas quase dobrou o de Muse Spark. Embora todas as seis tentativas concluídas tenham passado nos testes automatizados, verificações separadas encontraram problemas em todas as versões. No fim, o criador conclui que os modelos testados ainda precisam de correções e que modelos mais baratos talvez sejam adequados apenas para tarefas simples e com supervisão.

Pontos-chave

O teste usou OpenCode Go, uma assinatura mensal de dez dólares para acesso aos modelos, enquanto Claude Opus 5.5 supervisionou e revisou as tentativas pelo Claude Code.
A tarefa era adicionar ao The Gray Cut uma janela com o rosto do apresentador, sincronizada com a filmagem editada e preparada para continuar a edição no Premiere.
CodeGraph reduziu o uso de tokens em algumas tentativas, mas Muse Spark usou quase o dobro de tokens com a ferramenta.
DeepSeek V4.1 Flash usou cerca de dez por cento menos tokens com CodeGraph, mas o custo calculado dessa tentativa foi maior por causa do uso de mais tokens de entrada não armazenados em cache.
MiniMax M3.1 Flash Free teve a maior economia de tokens entre os modelos que concluíram as duas tentativas: cerca de 39 por cento.
Limites de uso interromperam ou atrasaram algumas tentativas, incluindo as de Kimi K3, GLM 5.3 e Argon.
As seis tentativas concluídas passaram nos testes automatizados, mas verificações separadas encontraram pelo menos um problema em cada versão.
O criador decidiu remover os cantos arredondados da versão final porque eles exigiam etapas manuais demais no Premiere.

Capítulos

Início	Capítulo	Resumo
00:00	A tarefa e o desenho do teste	O criador apresenta a comparação de CodeGraph com modelos mais baratos e explica a funcionalidade de enquadramento automático que queria adicionar ao The Gray Cut.
02:37	Limites de uso e resultados de Muse Spark	Algumas tentativas são limitadas por cotas, e Muse Spark apresenta quase o dobro de tokens com CodeGraph, além de problemas que os testes não detectaram.
05:20	DeepSeek: menos tokens, mas custo calculado maior	DeepSeek usa menos tokens no total com CodeGraph, mas o custo estimado aumenta, e uma revisão recomenda essa versão como ponto de partida apesar de outro bug.
07:02	MiniMax, falhas encontradas e conclusão	MiniMax economiza tokens, mas ainda tem problemas na janela do rosto; o criador resume as falhas, decide remover os cantos arredondados e ressalta a necessidade de revisar o trabalho dos modelos.

Citações

Muse Spark usou quase o dobro de tokens com CodeGraph do que sem ele no meu teste com OpenCode. — 00:00

Menos tokens também não significaram um custo calculado menor. — 05:57

Uma execução de testes aprovada não garantia que a funcionalidade estivesse pronta. — 08:05

Eu ainda verificaria o trabalho deles. — 09:09

Conceitos e entidades

OpenCode Go (ferramenta): Assinatura mensal de dez dólares usada para acessar modelos no OpenCode, sujeita a limites de uso.
OpenCode (ferramenta): Ferramenta que executa os agentes de codificação usados para implementar a funcionalidade.
CodeGraph (ferramenta): Ferramenta que ajuda a localizar código relacionado, como funções que chamam a função que está sendo modificada.
The Gray Cut (conceito): Aplicativo de edição de vídeo do criador, usado como base para a tarefa de implementação.
Claude Opus 5.5 (modelo): Modelo usado para supervisionar os planos, revisar o código concluído e permitir uma rodada de correções.
Claude Code (ferramenta): Ferramenta pela qual Claude Opus 5.5 supervisionou e revisou as tentativas.
Muse Spark 1.3 Contributor (modelo): Modelo que quase dobrou o uso de tokens com CodeGraph em comparação com a tentativa sem a ferramenta.
DeepSeek V4.1 Flash (modelo): Modelo que usou cerca de dez por cento menos tokens com CodeGraph, embora a tentativa tivesse custo calculado maior.
MiniMax M3.1 Flash Free (modelo): Modelo que apresentou a maior economia de tokens entre as tentativas concluídas em ambas as configurações.
Astra (modelo): Sistema que recomendou a versão com CodeGraph como melhor ponto de partida após revisar o código e verificações separadas.
Kimi K3 (modelo): Modelo cuja tentativa foi interrompida por um limite de uso durante a implementação.
Premiere (ferramenta): Aplicativo no qual o criador queria continuar editando o resultado com o mínimo possível de configuração manual.
Codex (ferramenta): Ferramenta citada pelo criador ao comparar sua experiência com modelos de fronteira.

Tradução completa (pt-BR)

00:00 No meu teste com OpenCode, o Muse Spark usou quase o dobro de tokens com CodeGraph do que sem ele. DeepSeek e MiniMax usaram menos tokens com CodeGraph do que sem ele. Então, o modelo fez uma grande diferença nessas execuções. Na minha comparação anterior de ferramentas de grafo, perguntei se vocês gostariam de um teste com modelos mais baratos. Vocês sugeriram Muse e DeepSeek. Eu escolhi CodeGraph, então experimentei com vários modelos mais baratos no OpenCode.

00:30 O orçamento da nova assinatura era de dez dólares. Não consegui concluir todas as comparações antes de atingir os limites. Vou mostrar quais modelos usaram menos tokens e se o código valeu a pena manter. A tarefa era outra funcionalidade para The Gray Cut, meu aplicativo de edição de vídeo. Ele já escolhe screencasts para combinar com o que estou dizendo. Ainda adiciono manualmente no Premiere a janelinha que mostra meu rosto.

01:01 Eu queria que o aplicativo posicionasse essa janela automaticamente, com uma borda branca arredondada. A parte difícil era enquadrar o rosto. Minha posição às vezes muda um pouco entre as gravações, então o aplicativo precisava centralizar meu rosto. O aplicativo precisava encontrar meu rosto e escolher o quanto aproximar a imagem. Depois, esse enquadramento deveria permanecer estável durante toda a gravação. A janelinha também precisava acompanhar a filmagem editada da minha imagem falando. Acelerar um screencast deveria manter meu rosto sincronizado com a minha voz.

01:34 Eu também precisava continuar editando o resultado no Premiere, com o mínimo possível de configuração manual. Certo, o OpenCode Go é a assinatura mensal de dez dólares que usei para ter acesso aos modelos. O próprio OpenCode executa os agentes de programação. O Go é uma forma opcional de pagar pelos modelos que eles usam. O plano era testar cada modelo com e sem CodeGraph. Cada tentativa começou com sua própria cópia do mesmo código e da mesma tarefa. Claude Opus 5.5 supervisionou o processo pelo Claude Code.

02:06 Ele verificou os planos e analisou o código concluído, depois deu a cada tentativa finalizada uma chance de corrigir os problemas. Os modelos no OpenCode escreveram o código por conta própria. Eles não delegaram o trabalho a outros agentes. Os dez dólares cobriam apenas o OpenCode Go. Claude não estava incluído nisso. Mas o Go tem limites de uso para períodos de cinco horas. Também há limites semanais e mensais. Kimi K3 atingiu um limite durante a implementação.

02:37 GLM 5.3 não conseguiu começar a programar, e Argon atingiu depois um limite semanal. Deixar Argon rodando durante a noite significou, em grande parte, esperar os limites serem redefinidos. Acabei interrompendo a execução com a funcionalidade inacabada. Algumas tentativas também foram executadas ao mesmo tempo. Por isso, os tempos decorridos não permitiriam uma comparação justa de velocidade. Os termos de privacidade dependem da opção de modelo. Muse e Argon Contributor permitem o treinamento com seus prompts e respostas. Também experimentei as opções gratuitas disponíveis durante este teste.

03:08 DeepSeek e MiniMax concluíram tentativas com e sem CodeGraph. GLM Flash não concluiu as duas. A seguir, vou comparar os modelos que concluíram ambas as tentativas. Atingir um limite de assinatura não me diz se um modelo consegue criar a funcionalidade. Muse Spark 1.3 Contributor, da Meta, teve o maior aumento. Sem CodeGraph, usou cerca de 35,5 milhões de tokens. Com CodeGraph, usou cerca de 69 milhões. Isso representa cerca de 95% a mais.

03:41 A maior parte desses tokens correspondia a texto que o modelo já tinha visto. Ele podia ler esse texto novamente a partir de um cache, por um preço menor. Contei esse texto reutilizado todas as vezes, assim como nas minhas comparações anteriores. Os cálculos de custo usam o preço mais baixo do cache. CodeGraph ajuda um modelo a encontrar código relacionado. Por exemplo, pode mostrar quais funções chamam a função que está sendo alterada. Muse usou CodeGraph 14 vezes, todas enquanto trabalhava no plano. E esse planejamento, na verdade, usou um pouco menos de tokens do que o planejamento sem CodeGraph.

04:16 O uso adicional veio quase todo durante a escrita do código. O script de relatório contou as respostas do modelo nessa etapa. Sem CodeGraph, foram cem. Com CodeGraph, foram 24. Cada resposta também tinha, em média, mais texto para processar. Portanto, houve mais respostas, com entradas maiores. Os registros mostram Muse tentando repetidamente corrigir a prévia da imagem. Ele ajustou o recorte e investigou por que o interlocutor não estava visível.

04:49 A maior parte do uso adicional ocorreu durante a implementação, incluindo essas correções. Os registros não provam que CodeGraph tenha causado esses problemas. E a verificação separada da prévia ainda mostrou uma imagem de cabeça para baixo. A janela estava no canto superior direito, embora devesse ficar no canto inferior direito. Mesmo assim, os testes de orientação do próprio Muse foram aprovados. Então, mesmo depois de todo esse trabalho, os testes não detectaram um problema visível. Se essas comparações ajudam você a escolher o que experimentar, inscreva-se para acompanhar a próxima.

05:20 Entre no meu Discord se quiser sugerir outro modelo ou discutir os resultados. O link está na descrição. DeepSeek V4.1 Flash teve um resultado diferente. Com CodeGraph, usou cerca de 24 milhões de tokens. Sem ele, quase 27 milhões. Isso representa cerca de 10% a menos. O planejamento usou mais tokens com CodeGraph. A maior parte da economia total veio quando DeepSeek corrigiu os problemas depois da revisão. Essa etapa de correção teve 38 respostas registradas do modelo com CodeGraph, contra 76 sem ele.

05:57 CodeGraph não reduziu o uso em todas as etapas. Menos tokens também não significaram um custo calculado menor. Usando as tarifas do Go registradas para este teste, a tentativa com CodeGraph chega a cerca de 51 centavos. A tentativa sem ele chega a cerca de 47 centavos. A tentativa com CodeGraph usou mais entrada que não estava em cache. Isso custa mais do que ler texto em cache. DeepSeek foi gratuito nessas execuções. Esses valores mostram quanto custaria o uso registrado com aquelas tarifas; não foram cobranças extras da assinatura.

06:30 Astra recomendou a versão com CodeGraph como o melhor ponto de partida, com base na revisão do código e em verificações separadas. Ela tinha controles para preparar o enquadramento do rosto e tentar novamente quando a preparação falhasse. Também enquadrou corretamente as gravações de amostra durante essas verificações. A detecção do rosto é feita localmente no computador. Escolher o recorte não exige enviar uma solicitação a um provedor de IA. Uma simulação de substituição de arquivo revelou outro bug. O aplicativo ainda aceitou o recorte antigo do rosto.

07:02 MiniMax M3.1 Flash Free teve a maior economia de tokens entre os modelos que concluíram as duas tentativas. Com CodeGraph, MiniMax usou 39% menos tokens. Foram cerca de 64 milhões, em comparação com 105 milhões sem ele. A maior parte dessa economia veio durante a escrita do código. A tentativa com CodeGraph precisou de menos respostas do modelo e processou menos texto por resposta. Mas uma verificação separada encontrou um problema com a janela arredondada.

07:33 O aplicativo usa uma forma chamada máscara para ocultar a imagem fora das bordas arredondadas. MiniMax posicionou essa forma completamente fora da imagem, então ela não conseguiu recortá-la corretamente. A borda também continuou visível quando a janela do interlocutor deveria desaparecer. Portanto, a contagem melhor de tokens ainda deixou problemas na funcionalidade. As duas versões do MiniMax pedem a um provedor de IA que escolha o enquadramento do rosto. As verificações separadas não testaram essa parte com um provedor ativo.

08:05 As seis tentativas concluídas passaram em suas suítes de testes automatizados. Ainda assim, as verificações separadas encontraram um bug em cada versão concluída. Portanto, passar nos testes não garantia que a funcionalidade estivesse pronta. Aqui está a comparação final. Pause aqui se quiser dar uma olhada nos números. Experimentei a versão do DeepSeek com imagens do meu vídeo Codex Framework Arena. Os resultados não são aceitáveis. Vou trabalhar nela com um modelo mais inteligente e garantir que tudo funcione corretamente antes de incorporá-la.

08:37 Para a versão final, decidi remover os cantos arredondados. Eles acrescentavam etapas manuais demais no Premiere, e eu queria avançar rápido. No caso do CodeGraph, adicionar a mesma ferramenta trouxe resultados diferentes com modelos diferentes. Ela economizou tokens em algumas tentativas e quase dobrou o uso no Muse. Fiz cada comparação apenas uma vez, então gostaria de executar mais testes antes de confiar na dimensão dessas economias. Mas, para essa funcionalidade, os modelos mais baratos me decepcionaram. Até a versão recomendada por Astra ainda precisa de correções.

09:09 Depois de um ano usando modelos de ponta no Claude Code e no Codex, isso parece um retrocesso. Testei Kimi K3 quando foi lançado. Os resultados foram razoáveis, mas era muito, muito lento. Desta vez, a cota o interrompeu antes que pudesse terminar. Modelos mais baratos podem ajudar em tarefas simples, se o plano for detalhado o bastante. Mesmo assim, eu verificaria o trabalho deles. Para ver minha comparação anterior entre Graphify e CodeGraph, assista a este vídeo.

Transcrição original

[00:00] Muse Spark used almost twice the tokens with CodeGraph as it did without it in my OpenCode test. DeepSeek and MiniMax used fewer tokens with CodeGraph than without it. So the model made a big difference in these runs. In my earlier graph comparison, I asked if you’d like a test with cheaper models. You suggested Muse and DeepSeek. CodeGraph was my pick, so I tried it in OpenCode with several cheaper models.

[00:30] The new subscription budget was ten dollars. I couldn’t finish every comparison before hitting the limits. I’ll show you which models used fewer tokens, and whether the code was worth keeping. The task was another feature for The Gray Cut, my video editing app. It already picks screencasts to match what I’m saying. I still add the small window showing my face by hand in Premiere.

[01:01] I wanted the app to place that window automatically, with a rounded white border. The difficult part was framing the face My position sometimes shifts slightly between recordings, so the app needed to center my face. The app needed to find my face and choose how much to zoom in. Then that framing should stay steady throughout each recording. The small window also needed to follow the edited talking head footage. Speeding up a screencast should leave my face synchronized with my voice.

[01:34] I also needed to keep editing the result in Premiere, with as little manual setup as possible. Okay, so OpenCode Go is the ten dollar monthly subscription I used for model access. OpenCode itself runs the coding agents. Go is an optional way to pay for the models they use. The plan was to test each model with CodeGraph and without it. Each attempt started with its own copy of the same code and the same task. Claude Opus 5.5 supervised from Claude Code.

[02:06] It checked the plans and reviewed the completed code, then gave each finished attempt one chance to fix problems. The models in OpenCode wrote the code themselves. They didn’t delegate work to other agents. The ten dollars only covered OpenCode Go. Claude wasn’t included in that. But Go has usage limits for five hour periods. There are weekly and monthly caps too. Kimi K3 hit a limit during implementation.

[02:37] GLM 5.3 couldn’t start coding, and Argon later hit a weekly cap. Leaving Argon overnight mostly meant waiting for resets. I eventually stopped it with the feature unfinished. Some attempts also ran at the same time. So the elapsed times wouldn’t give a fair speed comparison. The privacy terms depend on the model option. Muse and Argon Contributor allow training on your prompts and responses. I also tried the free options available during this test.

[03:08] DeepSeek and MiniMax both finished attempts with and without CodeGraph. GLM Flash didn’t finish both. Next, I’ll compare the models that finished both attempts. Hitting a subscription limit doesn’t tell me whether a model can build the feature. Meta’s Muse Spark 1.3 Contributor had the biggest increase. Without CodeGraph, it used about thirty-five and a half million tokens. With CodeGraph, it used about sixty-nine million. That’s about ninety-five percent more

[03:41] Most of those tokens were text the model had already seen. It could read that text again from a cache at a lower price. I counted that reused text each time, just as in my earlier comparisons. The cost calculations use the cheaper cache price. CodeGraph helps a model find related code. For example, it can show which functions call the function being changed. Muse used CodeGraph fourteen times, all while working on its plan. And that planning actually used slightly fewer tokens than planning without CodeGraph.

[04:16] The extra usage came almost entirely while writing the code The reporting script counted the model responses during that phase. Without CodeGraph, there were a hundred. With CodeGraph, there were twenty-four. Each response also had more text to process on average. So there were more responses, with larger inputs. The logs show Muse repeatedly trying to fix the picture preview. It adjusted the crop and investigated why the speaker wasn’t visible.

[04:49] Most of the extra usage came during implementation, including these fixes. The logs don’t prove that CodeGraph caused those problems. And the separate preview check still showed an upside down picture. The window was at the top right, although it belonged at the bottom right. Muse’s own orientation tests passed anyway. So even after all that work, its tests missed a visible problem. If these comparisons help you choose what to try, subscribe for the next one.

[05:20] Join my Discord if you want to suggest another model or discuss the results. The link is in the description. DeepSeek V4.1 Flash had a different result. With CodeGraph, it used about twenty-four million tokens. Without it, almost twenty-seven million. That’s about ten percent less Planning used more tokens with CodeGraph. Most of the overall saving came when DeepSeek fixed problems after the review. That repair stage took thirty-eight recorded model responses with CodeGraph, against seventy-six without it.

[05:57] CodeGraph didn’t reduce usage at every stage. Fewer tokens also didn’t mean a lower calculated cost. Using the Go rates recorded for this test, the CodeGraph attempt comes to about fifty-one cents. The attempt without it comes to about forty-seven cents. The CodeGraph attempt used more input that wasn’t cached. That costs more than reading cached text. DeepSeek was free in these runs. Those amounts show what the recorded usage would cost at those rates; they weren’t extra subscription charges.

[06:30] Astra recommended the CodeGraph version as the best starting point based on the code review and separate checks. It had controls to prepare the face framing and retry when preparation failed. It also framed the sample recordings correctly during those checks. The face detection runs locally on the computer. Choosing the crop doesn’t require sending a request to an AI provider. A simulated file replacement exposed another bug. The app still accepted the old face crop.

[07:02] MiniMax M3.1 Flash Free had the biggest token saving among the models that finished both attempts. With CodeGraph, MiniMax used thirty-nine percent fewer tokens That’s about sixty-four million, compared with a hundred and five million without it. Most of that saving came while writing the code. The CodeGraph attempt needed fewer model responses and processed less text per response. But a separate check found a problem with the rounded window.

[07:33] The app uses a shape called a mask to hide the picture outside the rounded edges. MiniMax placed that shape completely outside the picture, so it couldn’t clip the picture correctly. The border also stayed visible when the speaker window should have disappeared. So the better token count still left problems with the feature. Both MiniMax versions ask an AI provider to choose the face framing. The separate checks didn’t test that part with a live provider.

[08:05] All six completed attempts passed their automated test suites. Separate checks still found a bug in every completed version. So a passing test run was no guarantee that the feature was ready. Here’s the final comparison. Pause here if you’d like to look at the numbers. I tried the DeepSeek version with footage from my Codex Framework Arena video. The results aren’t acceptable I’ll work on it with a smarter model and make sure everything works correctly before merging it in.

[08:37] For the final version, I decided to drop the rounded corners. They added too many manual steps in Premiere, and I wanted to move fast. For CodeGraph, adding the same tool gave different results with different models. It saved tokens in some attempts and nearly doubled them in Muse’s. I only ran each comparison once, so I’d want more runs before trusting the size of those savings. But for this feature, the cheaper models disappointed me. Even the version Astra recommended still needs fixing.

[09:09] After a year using frontier models in Claude Code and Codex, this feels like a step backwards. I tested Kimi K3 back when it came out. The results were decent, but it was very, very slow. This time, the quota stopped it before it could finish. Cheaper models might help with simple tasks if the plan is detailed enough. I’d still check their work. For my earlier Graphify and CodeGraph comparison, watch this video