DeepSeek Harness vs OpenCode: A Lacuna no Uso de Tokens que a Maioria dos Desenvolvedores Ignora

Você escolheu um modelo barato. Fez as contas no cartão do modelo. Depois chegou a fatura e não parecia nada com o que você calculou.

Essa diferença quase nunca é culpa do modelo. É do harness. O harness decide quantas vezes seu modelo é chamado, quanto da conversa é repetida a cada chamada, o tamanho dos schemas das ferramentas e se uma execução de teste com falha é repetida três vezes ou doze. Mesmo modelo, mesma tarefa, dois harnesses, contagens de tokens muito diferentes.

Em 13 de agosto de 2026, a DeepSeek abriu o código do seu próprio harness de agente e o debate esquentou rápido. De um lado, um repositório de duas semanas do laboratório que constrói o modelo. Do outro, o OpenCode, o agente de código mais estrelado do GitHub. Ambos são MIT. Ambos rodam qualquer modelo que você apontar.

Então esta é a versão honesta da comparação. Não é sobre vibes ou estrelas. O que cada um realmente faz com seu uso de tokens e como medir isso no seu próprio repositório em cerca de quinze minutos.

Principais conclusões

• DeepSeek Harness é um runtime de agente baseado em plugins da DeepSeek AI, licenciado MIT, escrito em TypeScript, ainda rotulado como prévia para desenvolvedores. Modelos, ferramentas, sessões, armazenamento, sandboxes, loops e até o próprio loop do agente são plugins intercambiáveis.
• OpenCode é um agente de código nativo do terminal em Go, com aproximadamente 198 mil estrelas no GitHub, uma TUI madura, suporte a LSP e um grande catálogo de provedores. É o padrão seguro hoje.
• A escolha do harness mexe no uso de tokens mais do que a maioria espera. Em um benchmark de 30 workflows no DeepSeek V4 Flash, os harnesses testados variaram de cerca de 192.000 a 1.400.000 tokens médios por tarefa.
• DeepSeek Harness não estava nesse benchmark. Ele foi lançado dois dias depois da publicação, então qualquer um que cite números de benchmark do Harness agora está adivinhando.
• Ambos são agnósticos em relação ao modelo, então você pode apontar ambos para um mesmo endpoint compatível com OpenAI e fazer um teste genuíno de igual para igual. Esse é o único número que importa para sua base de código.

Dois laptops lado a lado em uma mesa ensolarada executando a mesma tarefa de codificação através de dois harnesses de agente diferentes

Única maneira justa de comparar DeepSeek Harness vs OpenCode: um modelo, uma tarefa, dois terminais.

Por que DeepSeek Harness vs OpenCode se tornou o debate do mês

O argumento da DeepSeek é um slogan: Agente = Modelo + Harness. O modelo pensa, o harness lê arquivos, executa o terminal e chama ferramentas. Por dois anos todos otimizaram a primeira metade e trataram a segunda como encanamento.

O encanamento acabou sendo caro.

A Composio rodou 30 workflows complexos multi-app através de 8 harnesses de agente diferentes, todos usando o mesmo modelo DeepSeek V4 Flash, com um limite de 900 segundos por tarefa e avaliação binária programática em 240 execuções (Composio, agosto de 2026). Mesmo modelo em todos os lugares. Os resultados não foram próximos.

Leia a coluna de tokens novamente. O harness mais econômico usou cerca de um sétimo dos tokens do mais desperdiçador, rodando o modelo idêntico nas tarefas idênticas. A conclusão do próprio benchmark foi que os harnesses "podem importar tanto quanto os modelos que executam."

Agora a parte que a maioria dos artigos pula. DeepSeek Harness não está nessa tabela. O benchmark foi publicado em 11 de agosto e o Harness foi lançado em 13 de agosto. Não há um número confiável de comparação direta de tokens para o DeepSeek Harness ainda, e qualquer um que mostre um número este mês ou rodou sozinho em uma tarefa restrita ou inventou. O que a tabela fornece é uma linha de base sólida e referenciada para o OpenCode: 692.000 tokens por tarefa, 46,7% de taxa de aprovação, mediana de 129,7 segundos.

Esse é o número que você está tentando superar, e o resto deste artigo é sobre como testá-lo honestamente.

DeepSeek Harness vs OpenCode: mesmo modelo, um endpoint, dois runtimes

Aqui está a forma prática de cada ferramenta antes de executarmos qualquer coisa.

A linha importante é a da arquitetura. OpenCode oferece um agente bem construído e permite estender as bordas. DeepSeek Harness fornece um esqueleto e permite substituir a espinha dorsal, incluindo o loop do agente, que é ele próprio um plugin. Isso é genuinamente incomum, e também é por que ainda é uma prévia.

Ambos são agnósticos em relação ao modelo, e essa é a razão pela qual um teste justo é possível. Aponte ambos para um endpoint compatível com OpenAI servindo um modelo, e toda diferença que você medir pertence ao harness.

Para este passo a passo, estou servindo DeepSeek V4 Flash do Atlas Cloud, porque ele expõe um endpoint OpenAI compatível simples que ambos os harnesses aceitam sem qualquer código adaptador, e a mesma chave funciona para ambas as execuções. A listagem deepseek-v4-flash-0731 lá custa $0,14 por milhão de tokens de entrada e $0,28 por milhão de tokens de saída, com uma janela de contexto de 1.048.576 tokens e máximo de saída de 393.216, em agosto de 2026. Qualquer provedor compatível com OpenAI funciona para este teste. O ponto é que ambos os harnesses devem atingir o mesmo.

Vale saber antes de escolher um modelo: o OpenCode publica seus próprios dados agregados de uso, e os modelos DeepSeek já moveram 233 trilhões de tokens através dele, com o V4 Flash respondendo por 85,5% disso e o V4 Pro pelos 14,5% restantes (OpenCode, agosto de 2026). O Flash é o que o ecossistema realmente usa.

Passo 1: Aponte DeepSeek Harness vs OpenCode para o mesmo modelo

Obtenha uma chave de API e uma URL base, e alimente ambas as ferramentas exatamente com o mesmo par. Crie a chave no console do Atlas Cloud e exporte-a uma vez:

bashCopy
1export ATLAS_API_KEY="sua-chave-api"
2

Antes de conectar qualquer harness, verifique o endpoint e o ID exato do modelo com uma chamada. Se isso não retornar texto, nada downstream funcionará:

bashCopy
1curl https://api.atlascloud.ai/v1/chat/completions \
2  -H "Authorization: Bearer $ATLAS_API_KEY" \
3  -H "Content-Type: application/json" \
4  -d '{
5    "model": "deepseek-ai/deepseek-v4-flash-0731",
6    "messages": [{"role": "user", "content": "Responda com a única palavra: pronto"}]
7  }'
8

Ajuda ver o modelo responder à tarefa real uma vez, diretamente pelo endpoint, antes de entregá-lo a um agente. Assim você sabe que uma execução falha é culpa do harness e não da rota:

O prompt da tarefa do artigo postado em api.atlascloud.ai, ao lado da resposta real que o DeepSeek V4 Flash 0731 retornou e o uso de tokens que a chamada reportou

Uma chamada real para deepseek-ai/deepseek-v4-flash-0731, o mesmo ID de modelo que ambos os harnesses usarão: 148 tokens de prompt de entrada, 6.879 tokens de saída, 5.731 deles de raciocínio. Esse é o seu piso antes que um harness adicione um único schema de ferramenta.

Agora configure cada lado. DeepSeek Harness lê $DSH_HOME/settings.yaml, e provedores personalizados compatíveis com OpenAI vão sob o plugin llm-pi-ai (docs do DeepSeek Harness, agosto de 2026):

yamlCopy
1llm-pi-ai:
2  providers:
3    atlas:
4      apiKeyEnv: ATLAS_API_KEY
5      api: openai-completions
6      baseURL: https://api.atlascloud.ai/v1
7      models:
8        - id: deepseek-ai/deepseek-v4-flash-0731
9

O campo api aceita openai-completions, openai-responses ou anthropic-messages. Use openai-completions aqui. Se preferir não editar YAML manualmente, a interface web tem Configurações > Modelos > Adicionar provedor personalizado, que escreve o mesmo bloco e armazena a chave em $DSH_HOME/.credentials.yaml.

OpenCode lê opencode.json na raiz do seu projeto ou no diretório de configuração global (docs do OpenCode, agosto de 2026):

jsonCopy
1{
2  "$schema": "https://opencode.ai/config.json",
3  "provider": {
4    "atlas": {
5      "npm": "@ai-sdk/openai-compatible",
6      "name": "Atlas Cloud",
7      "options": {
8        "baseURL": "https://api.atlascloud.ai/v1",
9        "apiKey": "{env:ATLAS_API_KEY}"
10      },
11      "models": {
12        "deepseek-ai/deepseek-v4-flash-0731": {
13          "name": "DeepSeek V4 Flash 0731",
14          "limit": { "context": 1048576, "output": 393216 }
15        }
16      }
17    }
18  },
19  "model": "atlas/deepseek-ai/deepseek-v4-flash-0731"
20}
21

Use @ai-sdk/openai-compatible, não @ai-sdk/openai, já que este endpoint serve /v1/chat/completions. Defina os valores de limit para os números reais de contexto e saída, porque o OpenCode os usa para decidir quando resumir, e um limite errado distorcerá bastante sua comparação de tokens.

Passo 2: Execute a tarefa de benchmark no DeepSeek Harness

Escolha uma tarefa que seja grande o suficiente para precisar de várias chamadas de ferramenta e pequena o suficiente para ser avaliada objetivamente. Vários arquivos, mais uma suíte de testes que precisa realmente passar. Use o mesmo estado do repositório para ambas as execuções, então faça commit ou stash primeiro.

Este é o prompt exato da tarefa. Cole-o literalmente em ambos os harnesses:

textCopy
1Neste repositório, adicione um middleware de limitador de taxa token-bucket para o aplicativo Express em src/server.js. Limite cada IP a 60 requisições por minuto. Na rejeição, retorne HTTP 429 com o corpo JSON {"error":"rate_limited","retryAfter":<segundos>}. Conecte o middleware em todas as rotas /api/*. Adicione testes unitários em test/rate-limit.test.js cobrindo três casos: uma requisição abaixo do limite é permitida, uma requisição acima do limite é bloqueada com 429, e o contador é reiniciado após a janela expirar. Execute a suíte de testes e corrija falhas até passar. Não modifique nenhum arquivo fora de src/ e test/.
2

Inicie o Harness a partir do diretório do seu projeto:

bashCopy
1cd /caminho/para/seu/repositorio
2npx @deepseek-ai/dsh web
3

Isso serve a interface web em http://127.0.0.1:3080. Selecione o provedor atlas e o modelo deepseek-ai/deepseek-v4-flash-0731, cole a tarefa e deixe rodar até a conclusão. Não intervenha, não responda perguntas de esclarecimento com dicas. Qualquer ajuda que você der a um harness e não ao outro invalida a comparação.

Quando terminar, abra a visualização Trajectory (Trajetória). Esse é o registro da sessão, e é onde os números de tokens estão.

Passo 3: Repita a execução no OpenCode para um teste justo DeepSeek Harness vs OpenCode

Redefina o repositório para o mesmo estado inicial exato. Esta etapa é onde a maioria das comparações informais quebra silenciosamente, porque o segundo harness começa em um repositório que o primeiro já consertou parcialmente.

bashCopy
1git checkout -- . && git clean -fd
2

Depois execute o OpenCode contra o mesmo modelo:

bashCopy
1opencode --model atlas/deepseek-ai/deepseek-v4-flash-0731
2

Cole o prompt de tarefa idêntico do Passo 2. Use o agente build padrão, pois é o que tem acesso total a arquivos e shell. Novamente, sem dicas, sem correções de curso, mesmo tratamento sem intervenção.

Deixe terminar, depois verifique ambas as execuções da mesma forma que avaliaria qualquer PR:

bashCopy
1npm test
2

Uma execução que deixar a suíte vermelha não passou, não importa quão confiante o resumo pareceu. Avalie de forma binária, exatamente como a metodologia Composio faz. Um limitador de taxa meio funcionando é uma falha.

Passo 4: Leia o uso de tokens do DeepSeek Harness vs OpenCode

Agora colete os números. Ambos os harnesses rastreiam o uso, mas o exibem de maneiras muito diferentes, e essa é a maior diferença do dia a dia entre eles.

DeepSeek Harness vem com um medidor de tokens montado por padrão. Ele expõe três projeções de sessão que você pode ler diretamente: tokenUsage para o total em execução, contextPressure para o quão perto você está da janela, e contextBreakdown para onde os tokens realmente foram. Esse último é o útil, porque diz se sua conta é de prompt de sistema, schemas de ferramenta, leituras de arquivo ou repetição de conversa. O medidor usa uma heurística fixa de aproximadamente um token para cada quatro caracteres, em vez de um tokenizador real, então trate-o como uma estimativa forte, não uma fatura.

O Harness também lida com um contexto cheio de forma diferente. Em vez de truncar, seu mecanismo de compactação faz folding: substitui a superfície visível ao modelo por um resumo enquanto o log completo permanece na camada de persistência. Você perde tokens do prompt, não o histórico do registro.

OpenCode rastreia tokens e custo por sessão e os imprime na linha de status enquanto você trabalha. O detalhamento na TUI é deliberadamente mínimo, e é por isso que existe um pequeno ecossistema de analisadores externos que lêem o banco de dados de sessão do OpenCode diretamente para dividir o uso por ferramenta e por taxa de acerto de cache. Se você quiser uma atribuição por ferramenta, vai precisar instalar algo.

Para a comparação em si, não confie no contador de cada ferramenta como palavra final. Use o número do lado do provedor, porque é isso que você está realmente pagando:

O método mais limpo é criar duas chaves de API separadas, uma chamada harness-test e outra opencode-test, e usar cada uma para exatamente uma execução. Então a página de uso do próprio provedor fornece uma comparação lado a lado inquestionável com zero erro de estimativa. Esse truque leva dois minutos e remove toda fonte de desacordo sobre qual contador está certo.

Uso de tokens do DeepSeek Harness: o que realmente mexe na conta

Depois de ter números reais, estas são as alavancas que valem a pena mexer. Elas se aplicam a ambos os harnesses, e importam muito mais do qual você escolheu.

A repetição de conversa geralmente é a maior linha. Agentes reenviam a conversa crescente a cada passo. Uma tarefa de 40 passos não custa 40 prompts, custa algo mais próximo da soma de 40 prompts cada vez mais longos. É por isso que a variação do benchmark foi de 192.000 a 1.400.000 tokens em trabalhos idênticos. Harnesses que resumem agressivamente ficam no fundo dessa faixa.

Acertos de cache são a otimização mais barata disponível. Acertos de cache do DeepSeek V4 Flash custam cerca de $0,0028 por milhão de tokens contra $0,14 por milhão em falha, aproximadamente 98% mais baratos. O cache só funciona quando o prefixo da requisição é byte por byte idêntico, que é exatamente por que o DeepSeek Harness impõe interpolação estrita de {{variável}} com semântica de falha ruidosa e mantém um cabeçalho de requisição estável. Um harness que embaralha seu prompt de sistema entre chamadas silenciosamente transforma todo acerto em falha.

Schemas de ferramenta viajam junto em cada chamada. Vinte servidores MCP conectados significam vinte conjuntos de schemas no prompt, para sempre, quer a tarefa os toque ou não. Desconecte o que esta tarefa não precisa antes de fazer benchmark, ou você estará medindo sua configuração MCP em vez do seu harness.

Resultados de ferramenta superdimensionados envenenam o contexto. Um cat de um arquivo de 3.000 linhas, ou um executor de teste verboso despejando stack traces completos, fica na conversa pelo resto da execução. O Harness tem um componente opcional de poda de resultados que reescreve resultados de ferramenta muito grandes antes de resumir. Vale a pena ativar.

Repetições são invisíveis até você contar as chamadas. Um harness que repete um teste falho três vezes gasta o triplo. Compare a coluna de contagem de chamadas, não apenas tokens totais, ou você diagnosticará erroneamente um loop de repetição como um modelo caro.

Em custo, a aritmética é simples depois que você tem uma contagem de tokens. Na taxa do Atlas Cloud para DeepSeek V4 Flash, uma tarefa de 692.000 tokens com peso para entrada fica na faixa de alguns centavos. Essa é a boa notícia sobre toda esta categoria: o modelo é barato o suficiente para que o desperdício do harness seja um problema de eficiência, não uma emergência orçamentária. Só se torna um número real quando você multiplica por uma equipe, rodando o dia todo, todos os dias. Navegue pelo catálogo completo de modelos se quiser executar o mesmo teste com um segundo modelo e separar efeitos de modelo de efeitos de harness.

Uma ressalva que deve moldar sua decisão mais do que qualquer número de tokens: o DeepSeek Harning está explicitamente em prévia para desenvolvedores e seu próprio README avisa em maiúsculas que haverá mudanças de quebra de compatibilidade. Isso é algo bom para fazer benchmark e arriscado para padronizar uma equipe este mês. O OpenCode é a escolha entediante, e entediante é uma característica quando está rodando contra seu repositório de produção.

Perguntas Frequentes

DeepSeek Harness é melhor que o OpenCode?

Ainda não, para a maioria das pessoas. OpenCode é maduro, nativo do terminal, tem aproximadamente 198 mil estrelas e um grande catálogo de provedores, e funciona hoje. DeepSeek Harness tem duas semanas, está em prévia para desenvolvedores e avisa sobre mudanças de quebra. O Harness é mais interessante arquiteturalmente, porque cada componente, incluindo o loop do agente, é um plugin substituível. Se você quer reescrever as entranhas do agente, o Harness foi feito para isso. Se você quer enviar código esta semana, OpenCode.

O DeepSeek Harness só funciona com modelos DeepSeek?

Não. É agnóstico em relação ao modelo. Ele vem com provedores de catálogo para DeepSeek, Anthropic, OpenAI, Bedrock, Vertex, Azure e Codex, e você pode adicionar qualquer provedor personalizado que fale openai-completions, openai-responses ou anthropic-messages adicionando um bloco ao $DSH_HOME/settings.yaml. A configuração no Passo 1 o aponta para um endpoint compatível com OpenAI de terceiros sem código adaptador.

Como verifico o uso de tokens do DeepSeek Harness?

Use o medidor de tokens embutido, que é montado por padrão e expõe projeções de tokenUsage, contextPressure e contextBreakdown, visíveis na visualização Trajectory. Observe que ele estima com uma heurística fixa de cerca de um token a cada quatro caracteres, em vez de rodar um tokenizador real. Para precisão de faturamento, leia o painel de uso do seu provedor, idealmente com uma chave de API dedicada por execução. Plugins da comunidade, como painéis de uso de tokens, adicionam registros persistentes por sessão.

Qual harness usa menos tokens, DeepSeek Harness ou OpenCode?

Ainda não há comparação direta publicada. O benchmark de 8 harnesses no DeepSeek V4 Flash mediu o OpenCode em 692.000 tokens médios por tarefa, mas rodou dois dias antes do lançamento do DeepSeek Harness, então o Harness não foi incluído. Qualquer um que cite um número do Harness desse benchmark está citando algo que não existe. Execute o teste do Passo 2 ao Passo 4 no seu próprio repositório, já que o uso de tokens depende muito do tamanho da sua base de código, da sua configuração MCP e da forma da tarefa.

Posso executar DeepSeek Harness e OpenCode com a mesma chave de API?

Sim, e para um teste casual isso é ok. Para uma medição limpa, use duas chaves separadas, uma por harness. Então o painel de uso do seu provedor atribui cada token à execução correta automaticamente e você nunca precisa reconciliar dois estimadores internos diferentes contra uma fatura.

Qual é a diferença entre um agente e um harness?

O próprio argumento da DeepSeek é Agente = Modelo + Harness. O modelo faz o raciocínio. O harness é tudo que o conecta à realidade: ler e escrever arquivos, executar comandos de shell, chamar ferramentas, gerenciar sessões, lidar com aprovações e conduzir o loop que decide o que acontece depois. Mesmo modelo mais um harness diferente dá a você um agente mensuravelmente diferente, que é o ponto central desta comparação.