Principais destaques

• 1. Não é apenas mais um agente de código. O DeepSeek Harness aposta em uma arquitetura modular na qual ferramentas, modelos, habilidades e outros agentes podem ser combinados conforme a tarefa.
• 2. A grande ideia é a orquestração. Em vez de obrigar o desenvolvedor a escolher entre DeepSeek, Codex ou Claude Code, a proposta permite colocar diferentes agentes dentro do mesmo fluxo.
• 3. O potencial vem acompanhado de um custo. Em um teste relatado pela MindStudio, uma aplicação de rastreamento da Estação Espacial Internacional consumiu cerca de 20 milhões de tokens em aproximadamente 35 minutos.

---

O mercado de programação com inteligência artificial está passando por uma mudança importante. Durante muito tempo, a pergunta era simples: qual modelo escreve o melhor código?

Agora, uma pergunta mais interessante começa a ganhar espaço:

qual sistema consegue coordenar melhor vários modelos, ferramentas e agentes?

É nesse ponto que entra o DeepSeek Harness.

Descrito pela MindStudio como o sistema de programação agêntica da DeepSeek, o Harness foi apresentado como uma prévia para desenvolvedores associada à família V4. A proposta foge do modelo tradicional de um agente fechado e transforma diferentes partes da experiência em componentes que podem ser conectados, trocados ou desativados.

Isso muda bastante a forma de pensar sobre um agente de programação.

Em vez de imaginar uma IA sentada diante do terminal fazendo tudo sozinha, pense em uma central de operações. Ela recebe uma tarefa, decide quais ferramentas precisa, escolhe um modelo, pode delegar uma etapa para outro agente e acompanha o resultado.

É menos “um chatbot que programa” e mais uma infraestrutura para organizar agentes de programação.

---

O que é um “harness” e por que isso importa?

Antes de entender o DeepSeek Harness, vale resolver uma confusão comum.

Um modelo de linguagem é o cérebro. Ele interpreta instruções e produz respostas.

Um agente adiciona ferramentas e capacidade de executar ações.

Um harness é a camada que organiza tudo isso.

Ele pode controlar:

Componente	O que faz
🧠 Modelo	Raciocina e gera respostas
🛠️ Ferramentas	Lê arquivos, executa comandos, pesquisa na web
📋 Skills	Ensina procedimentos específicos
🔁 Sessão	Mantém contexto e histórico
🤖 Subagentes	Delegam tarefas para outros agentes
🔐 Permissões	Determinam o que a IA pode fazer
📊 Observabilidade	Mostra tokens, tempo, cache e outras métricas

Essa distinção é fundamental para entender a proposta.

Claude Code e Codex, por exemplo, podem ser usados como experiências completas de programação agêntica. O desenvolvedor entra, descreve o que precisa e deixa o sistema cuidar de boa parte do fluxo.

O Harness tenta colocar uma camada acima dessa lógica.

A própria descrição publicada pela MindStudio afirma que ferramentas, skills, sessões e até outros agentes de programação podem funcionar como plug-ins. Claude Code e Codex aparecem como exemplos de sistemas que poderiam ser acionados como subagentes.

Pense assim:

Agente tradicional

Você
 ↓
Agente
 ↓
Modelo
 ↓
Código

Arquitetura com Harness

                    ┌── Claude Code
                    │
Você → Harness ─────┼── Codex
                    │
                    ├── DeepSeek V4
                    │
                    ├── Ferramentas
                    │
                    └── Subagentes

A diferença parece pequena no desenho, mas é enorme na prática.

No segundo modelo, a inteligência deixa de estar concentrada em um único agente.

---

O verdadeiro diferencial está na composição

A palavra mais importante para entender o DeepSeek Harness talvez seja composição.

Imagine que você esteja construindo um aplicativo web.

Uma única solicitação poderia envolver:

1. entender o código existente;
2. criar uma arquitetura;
3. modificar arquivos;
4. executar testes;
5. pesquisar uma documentação;
6. corrigir erros;
7. revisar segurança;
8. preparar o deploy.

Não necessariamente existe um único modelo que seja a melhor opção para todas essas etapas.

Um modelo pode ser excelente em planejamento.

Outro pode ser melhor para escrever código.

Outro pode ser especialmente útil para revisar uma implementação.

Outro pode ser mais barato e rápido para tarefas repetitivas.

O Harness parte justamente dessa realidade.

A configuração descrita pela MindStudio permite alternar modelos, ferramentas e níveis de raciocínio, além de conectar provedores diferentes. A configuração também pode ser mantida em YAML, tornando o comportamento mais visível e modificável para quem trabalha diretamente com a infraestrutura.

Isso aproxima o desenvolvimento de software de uma lógica de pipeline inteligente.

Um exemplo

Imagine um projeto com 50 mil linhas de código.

Você poderia estruturar o fluxo assim:

Tarefa
  ↓
Agente planejador
  ↓
Analisa o repositório
  ↓
Divide o problema
  ↓
┌───────────────┬────────────────┐
↓               ↓                ↓
Código          Testes           Pesquisa
↓               ↓                ↓
Agente A        Agente B         Agente C
└───────────────┴────────────────┘
                ↓
          Agente revisor
                ↓
        Resultado final

Esse modelo é especialmente interessante para projetos grandes porque permite separar planejamento, execução e validação.

E existe uma consequência importante: o desenvolvedor deixa de pensar apenas em prompts e começa a pensar em arquitetura de agentes.

---

DeepSeek Harness, Claude Code e Codex não precisam ocupar o mesmo lugar

A comparação mais fácil é perguntar qual deles é melhor.

Mas talvez essa seja a pergunta errada.

A proposta do Harness é justamente tornar possível uma situação em que os sistemas não precisem competir diretamente.

Em um cenário hipotético, você poderia usar o DeepSeek para coordenar o fluxo, enviar uma tarefa específica para Codex, utilizar Claude Code para uma segunda etapa e retornar o resultado para o agente principal.

Isso transforma o problema de:

“Qual agente devo usar?”

em:

“Qual agente deve executar cada parte desta tarefa?”

Essa diferença é muito importante para quem está aprendendo sobre agentes de IA.

Modelo tradicional

Um agente → várias tarefas

Modelo orquestrado

Vários agentes → tarefas especializadas

Esse conceito já aparece em diferentes ferramentas e projetos da comunidade. O ecossistema em torno dos modelos V4, por exemplo, já inclui integrações com diferentes harnesses e agentes, incluindo Pi, além de projetos que adaptam o protocolo do DeepSeek para bibliotecas Python, CLI, MCP e Skills.

Isso também mostra que “harness” está deixando de ser um termo exclusivo de uma ferramenta.

É uma camada cada vez mais importante da arquitetura de sistemas agênticos.

---

O que você pode conectar?

A arquitetura descrita para o DeepSeek Harness divide o sistema em várias categorias.

🛠️ Ferramentas

Shell, edição de arquivos e pesquisa na web podem ser tratados como capacidades separadas.

Isso é importante porque uma IA não deveria necessariamente receber acesso irrestrito ao computador para realizar todas as tarefas.

Você pode imaginar permissões como:

Leitura
   ↓
Leitura + pesquisa
   ↓
Edição de arquivos
   ↓
Execução de comandos
   ↓
Acesso amplo

Quanto maior a autonomia, maior também a necessidade de controle.

🧠 Modelos

A descrição do sistema apresenta opções como V4 Flash e V4 Pro, permitindo escolher o modelo de acordo com a tarefa.

Essa possibilidade combina com uma tendência importante no desenvolvimento de agentes: usar modelos caros apenas quando eles realmente são necessários.

Uma tarefa simples não precisa consumir o mesmo poder computacional de uma tarefa complexa.

🤖 Subagentes

Aqui está uma das partes mais interessantes.

Um agente pode chamar outro agente.

Isso permite criar sistemas nos quais uma IA funciona como coordenadora e outras atuam como especialistas.

🔐 Permissões

Outro ponto importante é o controle sobre o que o agente pode fazer.

Uma IA que só pode ler arquivos representa um risco muito diferente de uma IA autorizada a executar comandos, modificar código e acessar serviços externos.

Para ambientes profissionais, essa diferença é fundamental.

---

Uma observação importante antes de instalar

Existe uma questão que merece atenção de quem está chegando agora.

O artigo da MindStudio, publicado em 14 de agosto de 2026, descreve o DeepSeek Harness como um projeto da própria DeepSeek e informa que ele estaria em prévia para desenvolvedores.

Ao mesmo tempo, existem atualmente vários projetos independentes usando o nome “deepseek-harness” no GitHub, incluindo ferramentas que funcionam como adaptadores ou wrappers para os modelos V4 Pro e V4 Flash. Um deles, por exemplo, documenta uma camada de compatibilidade para o protocolo da API, enquanto outro projeto oferece uma interface própria de programação no terminal.

Por isso, não é uma boa ideia simplesmente copiar um comando encontrado em uma postagem e executá-lo no computador.

Sempre confirme o repositório oficial e a documentação associada à versão que você pretende utilizar.

Essa é uma das primeiras lições importantes para quem está aprendendo a trabalhar com agentes.

Regra de ouro do Learning: agente com acesso ao terminal não deve ser tratado como chatbot. Ele pode executar ações reais.

---

Como aprender a usar um Harness de verdade

A melhor maneira de aprender não é começar pedindo para a IA construir uma aplicação inteira.

Comece pequeno.

A primeira experiência pode ser um projeto simples, como:

app/
├── src/
├── tests/
├── README.md
└── package.json

Depois peça ao agente para entender o projeto antes de modificar qualquer coisa.

Isso ajuda a perceber uma diferença fundamental entre programação assistida e programação agêntica.

No primeiro caso, você normalmente pede:

“Crie uma função que faça X.”

No segundo, você pode pedir:

“Analise o projeto, entenda a arquitetura, identifique onde essa funcionalidade deveria entrar, proponha um plano e só depois implemente.”

O segundo pedido exige muito mais do sistema.

Ele precisa explorar o ambiente, manter contexto, planejar, agir e verificar.

É aí que um harness começa a fazer diferença.

---

Prompt para aprender a trabalhar com um agente

Copie e cole:

Você é o agente principal de um projeto de software.

Antes de alterar qualquer arquivo:

1. Explore a estrutura do projeto.
2. Identifique a linguagem, framework e principais dependências.
3. Encontre os arquivos mais relevantes para a tarefa.
4. Explique brevemente como o projeto está organizado.
5. Crie um plano de implementação em etapas.
6. Liste os riscos ou pontos que precisam de confirmação.
7. Não altere nenhum arquivo ainda.

Depois que eu aprovar o plano, você poderá implementar a solução.

Tarefa:
[DESCREVA AQUI O QUE VOCÊ QUER CONSTRUIR]

Esse prompt ensina uma habilidade que vale mais do que simplesmente “pedir código”: separar descoberta de execução.

---

O segredo está em não deixar a IA improvisar tudo

Um dos problemas dos agentes de programação é a tendência de transformar uma solicitação ampla em uma sequência de decisões tomadas automaticamente.

Isso pode funcionar muito bem.

Também pode terminar em um projeto difícil de manter.

A melhor utilização de um sistema como o Harness é estabelecer contratos claros.

Por exemplo:

Objetivo
↓
Restrições
↓
Arquivos permitidos
↓
Critérios de sucesso
↓
Testes
↓
Revisão
↓
Implementação

Quanto mais importante for o projeto, menos você deve depender de frases vagas como “faça funcionar”.

---

Prompt para transformar uma tarefa grande em pequenas tarefas

Analise a tarefa abaixo como um arquiteto de software.

Não escreva código ainda.

Divida o trabalho em tarefas independentes e ordenadas.

Para cada tarefa, informe:

• objetivo
• arquivos que provavelmente serão afetados
• dependências
• risco
• como validar o resultado
• se a tarefa pode ser delegada a outro agente

Depois apresente uma ordem recomendada de execução.

Tarefa:
[COLE AQUI SUA TAREFA]

Esse tipo de instrução é particularmente útil em ambientes multiagente.

Você pode fazer com que um agente planeje, outro implemente e um terceiro revise.

---

E se eu quiser usar vários agentes?

É aqui que o conceito fica realmente interessante.

Imagine um sistema com quatro funções:

🧭 Agente 1: planejador

Responsável por entender o problema e criar o plano.

👨‍💻 Agente 2: implementador

Recebe uma tarefa específica e modifica o código.

🧪 Agente 3: testador

Executa testes e tenta encontrar problemas.

🔎 Agente 4: revisor

Analisa a implementação final procurando bugs, inconsistências e riscos.

O fluxo poderia ser:

              ┌──────────────┐
              │  PLANEJADOR  │
              └──────┬───────┘
                     ↓
             ┌──────────────┐
             │ IMPLEMENTADOR│
             └──────┬───────┘
                    ↓
             ┌──────────────┐
             │   TESTADOR   │
             └──────┬───────┘
                    ↓
             ┌──────────────┐
             │   REVISOR    │
             └──────┬───────┘
                    ↓
                 ENTREGA

Essa estrutura reduz a dependência de uma única resposta perfeita.

O agente implementador não precisa ser responsável por descobrir todos os problemas que ele mesmo criou.

---

Prompt para um agente revisor

Você é um revisor independente de código.

Não tente defender a implementação existente.

Analise o código como se tivesse sido escrito por outra equipe.

Procure especificamente por:

1. bugs funcionais
2. problemas de segurança
3. tratamento incorreto de erros
4. problemas de concorrência
5. código duplicado
6. dependências desnecessárias
7. problemas de performance
8. testes ausentes
9. mudanças que podem quebrar funcionalidades existentes

Para cada problema encontrado, informe:

• gravidade: baixa, média ou alta
• arquivo
• localização aproximada
• problema
• por que isso importa
• correção recomendada

Não altere nenhum arquivo.

No final, diga se a implementação está pronta para produção e justifique a resposta.

Esse é um bom exemplo de como usar IA para criticar IA.

---

O problema que quase ninguém mostra: tokens

Toda essa autonomia tem um preço.

No teste publicado pela MindStudio, o DeepSeek Harness criou um rastreador da Estação Espacial Internacional utilizando dados em tempo real, visualização da Terra, posição do Sol e verificações automatizadas. O resultado foi considerado forte, mas o processo consumiu aproximadamente 20 milhões de tokens em duas interações, durante cerca de 35 minutos.

É um número enorme para uma aplicação relativamente específica.

A situação fica ainda mais interessante quando olhamos para o cache.

Segundo o relato, as taxas de cache ficaram entre 95% e 100% em diferentes execuções. No final do teste citado, o índice chegou a 100%.

Isso revela uma característica importante dos sistemas agênticos:

o custo não está apenas na resposta final.

Um agente pode:

ler arquivos
   ↓
raciocinar
   ↓
executar comando
   ↓
ler resultado
   ↓
raciocinar novamente
   ↓
editar arquivo
   ↓
executar teste
   ↓
corrigir erro
   ↓
executar novamente

Cada ciclo pode gerar mais consumo.

Por isso, avaliar um agente apenas pela qualidade do código final é insuficiente.

Você também deveria perguntar:

quanto ele gastou para chegar lá?

---

Flash ou Pro?

Os testes relatados pela MindStudio apontam o V4 Flash como uma opção mais interessante para tarefas cotidianas de programação, principalmente pela relação entre velocidade, custo e qualidade. O Pro aparece como alternativa para problemas que realmente exigem maior capacidade de raciocínio.

Uma forma simples de pensar é:

Tipo de tarefa	Estratégia
Pequena correção	⚡ Flash
Refatoração simples	⚡ Flash
Testes repetitivos	⚡ Flash
Documentação	⚡ Flash
Planejamento complexo	🧠 Pro
Arquitetura difícil	🧠 Pro
Debugging muito complexo	🧠 Pro
Problema que exige várias etapas	🧠 Pro

Isso não deve ser tratado como uma regra absoluta.

O melhor modelo depende da tarefa, do contexto e do custo que você aceita pagar.

Em avaliações independentes da API V4, por exemplo, pesquisadores também encontraram diferenças relevantes entre Pro e Flash em latência e custo, além de documentarem particularidades do protocolo que podem afetar aplicações agênticas.

---

O detalhe técnico que ensina uma grande lição

Uma pesquisa independente sobre V4 Pro e V4 Flash encontrou um problema especialmente interessante para quem está construindo agentes.

Em fluxos com ferramentas, o histórico da conversa pode precisar preservar determinados dados de raciocínio do modelo entre turnos. Se essa informação for descartada de maneira incorreta, a próxima chamada pode falhar.

O harness analisado pelos pesquisadores existe justamente para encapsular essas particularidades do protocolo e evitar que o desenvolvedor tenha de lidar manualmente com todos esses detalhes.

Esse é um ótimo exemplo de por que um harness existe.

O modelo pode ser excelente.

A API pode funcionar.

As ferramentas podem estar corretas.

E, ainda assim, a aplicação pode quebrar por causa da maneira como todas essas peças conversam entre si.

Um harness resolve parte desse problema criando uma camada intermediária responsável por manter o fluxo funcionando.

---

Prompt para diagnosticar um agente que está “entrando em loop”

Você é um engenheiro responsável por diagnosticar um agente de programação que está consumindo muitos tokens e repetindo ações.

Analise o comportamento descrito abaixo.

Procure por:

1. repetição de chamadas
2. falta de critérios de parada
3. contexto excessivamente grande
4. tarefas mal divididas
5. testes sendo executados repetidamente
6. ausência de cache
7. ferramentas sendo chamadas sem necessidade
8. instruções conflitantes
9. falta de validação intermediária
10. delegação inadequada para subagentes

Depois proponha uma arquitetura mais eficiente.

Priorize redução de custo sem sacrificar confiabilidade.

Comportamento observado:
[DESCREVA O PROBLEMA]

Esse prompt pode ser usado mesmo fora do DeepSeek Harness.

É uma habilidade geral para qualquer sistema agêntico.

---

A interface também importa

Outro aspecto interessante relatado pela MindStudio é que o Harness expõe métricas durante a execução, incluindo tokens por segundo, taxa de cache, número de turnos e tempo de execução.

Isso pode parecer um detalhe visual.

Não é.

Imagine dois agentes que entregam exatamente o mesmo aplicativo.

O primeiro:

35 minutos · 20 milhões de tokens

O segundo:

12 minutos · 2 milhões de tokens

Qual deles você escolheria para trabalhar todos os dias?

A resposta parece óbvia.

Mas muitos produtos de IA escondem justamente essas informações.

Para quem está aprendendo, observar esses números é uma excelente forma de desenvolver uma intuição sobre agentes.

Acompanhe quatro métricas

1. Tempo

Quanto demorou para concluir?

2. Tokens

Quanto contexto e raciocínio foram consumidos?

3. Cache

Quanto do contexto pôde ser reutilizado?

4. Taxa de sucesso

O resultado realmente funcionou?

Não adianta reduzir o custo em 80% se o agente começa a errar 50% das tarefas.

---

Um laboratório simples para você testar

Se você quer aprender a lógica de um harness sem começar por uma aplicação gigantesca, crie um projeto pequeno.

Pode ser uma lista de tarefas.

Depois peça ao agente para:

Etapa 1

Entender o projeto.

Etapa 2

Planejar uma nova funcionalidade.

Etapa 3

Implementar.

Etapa 4

Escrever testes.

Etapa 5

Executar os testes.

Etapa 6

Revisar o próprio código.

Etapa 7

Produzir um relatório.

Agora repita a experiência usando diferentes modelos ou agentes.

Compare:

              Qualidade
                 ▲
                 │
                 │       ●
                 │   ●
                 │
                 │ ●
                 └────────────────► Custo

Você começa a perceber que escolher um agente não é apenas escolher “a IA mais inteligente”.

É escolher uma combinação de:

modelo + ferramentas + contexto + processo + supervisão + custo.

Essa é uma das ideias mais importantes para entender a próxima geração de sistemas de IA.

---

Prompt de laboratório completo

Atue como um agente de desenvolvimento responsável por executar uma tarefa de software de ponta a ponta.

Siga este processo obrigatoriamente:

FASE 1 — DESCOBERTA
Explore o projeto sem modificar arquivos.

FASE 2 — PLANEJAMENTO
Crie um plano detalhado e identifique os arquivos envolvidos.

FASE 3 — IMPLEMENTAÇÃO
Implemente somente o que for necessário.

FASE 4 — TESTES
Execute os testes existentes e crie novos testes quando necessário.

FASE 5 — VERIFICAÇÃO
Procure regressões e problemas causados pela implementação.

FASE 6 — REVISÃO
Faça uma revisão independente do código produzido.

FASE 7 — RELATÓRIO
Informe:
• arquivos modificados
• funcionalidades adicionadas
• testes executados
• problemas encontrados
• problemas corrigidos
• problemas ainda conhecidos
• próximos passos

Regras:

• Não altere arquivos desnecessariamente.
• Não instale dependências sem justificar.
• Não remova testes para fazer a suíte passar.
• Não considere a tarefa concluída apenas porque o código compila.
• Se encontrar uma ambiguidade importante, pare e peça confirmação.

Tarefa:
[DESCREVA AQUI]

---

O que muda para quem está aprendendo IA

A grande novidade do DeepSeek Harness não está simplesmente em ter mais uma ferramenta para escrever código.

O que ele representa é uma mudança de mentalidade.

Durante a primeira fase da IA generativa, aprendemos a conversar com modelos.

Depois aprendemos a criar prompts melhores.

Agora estamos entrando em uma fase na qual precisamos aprender a projetar sistemas compostos por agentes.

Nesse cenário, o prompt continua importante.

Mas ele é apenas uma peça.

Você também precisa saber:

quando usar um modelo menor;

quando escalar para um modelo mais poderoso;

quando chamar um subagente;

quando bloquear uma ferramenta;

quando pedir aprovação humana;

quando interromper uma execução;

e quando o agente simplesmente está gastando tokens sem avançar.

Essa é a diferença entre usar IA e construir sistemas com IA.

---

O futuro pode ser menos “um agente” e mais “uma equipe”

O conceito de harness ajuda a explicar uma tendência que já aparece em diferentes projetos.

Em vez de procurar uma inteligência artificial que faça absolutamente tudo, podemos ter sistemas nos quais diferentes agentes desempenham funções específicas.

Um agente planeja.

Outro programa.

Outro testa.

Outro pesquisa.

Outro audita.

E uma camada de orquestração decide como tudo isso conversa.

O próprio ecossistema ao redor do DeepSeek V4 já mostra esse movimento. Há ferramentas independentes oferecendo integração com Pi, MCP, Skills, bibliotecas e diferentes formatos de agentes, enquanto outros projetos experimentam subagentes e workflows específicos para programação.

Isso também ajuda a explicar por que o conceito de harness está se tornando tão relevante.

O modelo é apenas uma parte do sistema.

O que realmente determina o comportamento de um agente é a combinação entre modelo, ferramentas, memória, contexto, permissões, regras, loops de execução e mecanismos de verificação.

---

Vale a pena aprender DeepSeek Harness agora?

Para quem gosta de inteligência artificial e quer entender a próxima geração de programação agêntica, sim.

Mas não porque o Harness necessariamente seja “o melhor agente”.

A razão é outra.

Ele ajuda a visualizar uma mudança que será cada vez mais importante: a IA não precisa trabalhar sozinha.

A capacidade de combinar diferentes modelos e agentes pode ser mais valiosa do que tentar encontrar um único modelo perfeito.

Ao mesmo tempo, a tecnologia ainda exige cuidado. O próprio material da MindStudio descreve o sistema como uma prévia para desenvolvedores e menciona arestas de maturidade.

E os testes de protocolo disponíveis publicamente mostram que construir sistemas agênticos sobre modelos de raciocínio envolve detalhes técnicos que podem causar falhas, especialmente em loops com ferramentas, streaming e gerenciamento de contexto.

Por isso, o melhor jeito de começar não é entregar seu projeto inteiro para um agente.

É construir um pequeno laboratório.

Faça uma tarefa.

Meça.

Observe.

Corrija.

Repita.

Depois adicione um segundo agente.

Quando você perceber que o problema já não é mais “qual prompt devo escrever?”, mas sim “qual agente deveria fazer esta parte do trabalho?”, você começou a entender de verdade o que um harness representa.

---

💡 LIÇÃO DO EURISKO

Um modelo gera respostas. Um agente executa tarefas. Um harness organiza agentes.

Essa diferença parece apenas semântica, mas muda completamente a maneira de construir aplicações com IA.

---

Para guardar

Modelo: pensa e gera.

Agente: pensa, usa ferramentas e executa.

Harness: organiza modelos, ferramentas, agentes, permissões e fluxos.

Sistema multiagente: distribui o trabalho entre diferentes agentes.

Boa arquitetura agêntica: sabe quando executar, quando delegar e quando parar.

---

Fontes consultadas

A matéria original da MindStudio, publicada em 14 de agosto de 2026, foi usada como ponto de partida para a descrição do DeepSeek Harness, seus modos, arquitetura, experiência de uso e teste com o rastreador da Estação Espacial Internacional.

Também foram consultados projetos e documentação técnica da comunidade sobre o protocolo DeepSeek V4, incluindo testes com V4 Pro e V4 Flash, integração com ferramentas, gerenciamento de contexto, chamadas de ferramentas e comportamento em loops agênticos.

A documentação da comunidade do ecossistema DeepSeek também foi usada para contextualizar integrações com harnesses como Pi e diferentes formas de conectar V4 Pro e V4 Flash a agentes de programação.