Cem petabytes de SSD. É quanto espaço em disco a DeepSeek reserva, num único cluster, para guardar aquilo que o modelo já leu — o cache KV, a memória de trabalho que impede o sistema de reprocessar duas vezes o mesmo texto [3]. Cem petabytes não é um número de produto. É um número de política industrial, e existe apenas para encurtar a distância entre o que o modelo sabe e o que ele precisa recalcular.
Em 20 de outubro de 2026, a DeepSeek colocou no GitHub, sob licença Apache 2.0, o motor de inferência que sustenta essa operação: o DeepInfer [2]. O repositório diz que o código "foi originalmente construído sobretudo sobre o vLLM", com inspiração adicional no SGLang e no TensorRT-LLM [2]. O que não veio junto está documentado com a mesma franqueza: o sistema de cache KV, o balanceamento de carga entre réplicas e a desagregação entre prefill e decode ficaram de fora do release [2]; segundo a própria DeepSeek, os componentes de gerenciamento do cache e de balanceamento são "fortemente acoplados à nossa infraestrutura interna" [3].
A tentação é ler o release como uma doação ao ecossistema aberto. A leitura mais produtiva é outra: o DeepInfer é um documento contábil disfarçado de repositório. Ele revela onde o custo da inferência de fronteira realmente mora — não nos FLOPs, não nos kernels, mas na memória e na fronteira entre as duas fases de uma requisição. E revela, pelo avesso, que a parte mais consequente da tese da DeepSeek é exatamente a que não foi liberada. A tese deste artigo é que o valor do DeepInfer é epistêmico antes de ser operacional: ele transforma as afirmações de custo da DeepSeek em hipóteses testáveis, mas sonega o instrumental necessário para testar a mais importante delas.
O recuo de 2025 e a virada de 2026
Em abril de 2025, a DeepSeek escreveu uma nota explicando por que não abriria seu motor. Três razões, todas administrativas: o código era um fork antigo do vLLM, que já havia divergido muito do original; dependia fortemente da infraestrutura interna; e a empresa "não tinha banda para manter um projeto de código aberto grande" [4]. Semanas antes, durante a sua Open Source Week, já havia liberado bibliotecas menores [4] — peças que funcionam sem o corpo a que se acoplam.
Dezoito meses depois, o corpo apareceu. O que mudou entre uma coisa e outra não foi a qualidade do código, foi a sua generalidade. A DeepSeek não resolveu o problema de manter um projeto aberto; ela reduziu o projeto até que mantê-lo ficasse barato. Um modelo apenas, o V4.1-Flash. Duas famílias de chip apenas, NVIDIA SM100 (Blackwell) e Huawei Ascend 950. Inferência offline, alimentada por scripts [2]. E o desempenho de ponta a ponta da versão pública fica, por declaração própria, no máximo 5% distante do da versão interna [3] — ou seja, a distância entre a versão pública e a secreta foi comprimida a um resíduo mensurável.
Essa cronologia importa porque desloca a natureza do artefato. O DeepInfer não é um projeto de ecossistema, do tipo que recebe pull requests de estranhos e ganha suporte a cada nova GPU. É material suplementar de um paper: o artigo do V4.1-Flash saiu em setembro de 2026, no arXiv, e o motor veio um mês depois [5]. A comparação com o vLLM, portanto, é descabida na origem. O vLLM nasceu de uma técnica genérica — o PagedAttention, que tratou o cache KV como memória paginada e atacou a fragmentação que fazia os sistemas da geração anterior usarem apenas 20,4% a 38,2% da memória do cache KV para guardar estados de tokens de fato [6]. O DeepInfer nasceu de uma pergunta específica: qual é a forma mais barata de servir um modelo com 552 bilhões de parâmetros, 384 experts e contexto de até um milhão de tokens [5]. Um é infraestrutura; o outro é gabarito.
O recuo de 2025, relido com essa lente, parece menos uma hesitação e mais uma avaliação correta de custo-benefício que foi revista quando o custo caiu. A explicação oficial — falta de banda — era verdadeira e continua sendo: o que mudou foi o denominador.
O que foi aberto e o que continuou atrás da porta
A lista do que veio no pacote é generosa: o executor do modelo, kernels otimizados, o decodificador especulativo DSpark com verificação escalonada por confiança, o mecanismo de SWA bounded replay, o paralelismo de experts com balanceamento de carga (EPLB) e a saída estruturada [2]. Um segundo repositório, o deepseek-recipe, converte requisições de API em conversas e as codifica em tokens [1], com lógica de processamento "totalmente alinhada" à da API oficial da DeepSeek [3]. Há até uma sutileza de segurança: se o usuário digitar tokens de controle especiais dentro da mensagem, eles são tratados como texto comum, fechando a porta para injeção de instruções [1][3].
A lista do que ficou de fora é curta e decisiva: o sistema de cache KV, o balanceamento de carga entre réplicas e a desagregação entre as fases [2]. A fronteira não é arbitrária. Ela separa o que é sem estado do que é com estado. Kernels são funções puras que rodam em qualquer GPU da mesma geração; escalonadores locais operam sobre uma fila que existe dentro de um processo. Já o cache, o roteamento e o transporte entre fases dependem da topologia física do data center, do número de nós, da latência entre racks, da política de expulsão. Nada disso é portátil, e é por isso que a DeepSeek pôde publicar os primeiros e não os segundos.
O problema é que a fronteira sem estado / com estado coincide, quase perfeitamente, com a fronteira entre o que é copiável e o que é vantagem competitiva. Quem copiar o código público leva praticamente o desempenho interno: a diferença declarada de ponta a ponta é de no máximo 5% [3]. Quem copiar o cache e o roteamento ganharia a diferença entre servir um chatbot e servir 155 trilhões de tokens por dia [3]. A DeepSeek documentou essa parte com detalhe incomum — o documento de perguntas e respostas de implantação descreve erasure coding, TTL, taxa de falha de nós, intervalo de rebalanceamento de experts [3] —, mas documentação não é implementação. É o equivalente arquitetônico de publicar a planta de um porto sem abrir o cais.
Há ainda uma restrição que costuma passar batida: as únicas plataformas suportadas são SM100 e Ascend 950 [2], o que deixa de fora a geração Hopper (H100 e H200), ainda amplamente instalada. O público endereçável do código é, portanto, minúsculo; o público endereçável das ideias é universal. Essa assimetria é o traço mais característico do release — e a razão pela qual ele deve ser lido como literatura técnica, não como dependência de software.
Anatomia de uma requisição em duas metades
A jornada de um pedido através do sistema da DeepSeek está descrita no documento de implantação, e vale segui-la porque cada etapa revela uma decisão de projeto. O recipe tokeniza a entrada. O entrypoint compara uma cadeia de hashes do prefixo com os metadados do cache para descobrir quanto do prompt já foi visto antes. As máquinas de prefill puxam novas requisições conforme o tempo que sobra no passo corrente; se houver imagem anexada, um encoder visual a converte em tokens. O prefill carrega do 3FS, um sistema de arquivos distribuído, a parte já conhecida da conversa e calcula apenas o trecho novo. O cache resultante é transferido para o decode, que escreve a resposta token a token. Ao fim, o cache produzido no decode também é gravado em disco, de modo que a próxima mensagem do mesmo usuário comece quase pronta [3].
As proporções revelam o desenho: o prefill opera com paralelismo de 2 a 8 GPUs; o decode, com 64 a 128 (o chamado Wide-EP) [3]. A unidade mínima que faz sentido econômico é de 64 GPUs de prefill mais 64 de decode [3] — 128 aceleradores, o que deveria encerrar qualquer conversa sobre "hospedar em casa".
O que torna essa separação mais radical do que a literatura previa é a assimetria do próprio modelo. O V4.1-Flash tem 552 bilhões de parâmetros, mas ativa 8 bilhões no prefill e 16 bilhões no decode [5]. Não se trata de fases com o mesmo modelo e lotes diferentes: são duas cargas computacionais distintas, com metade dos parâmetros ativos em uma delas. O DistServe já havia demonstrado que separar as fases permite atender até 7,4 vezes mais requisições (ou cumprir SLOs 12,6 vezes mais apertados) [8], justamente porque o prefill é limitado por computação e o decode por banda de memória. O Splitwise formalizou a mesma intuição, separando as duas fases em máquinas distintas [9]. A DeepSeek levou a ideia para dentro dos pesos: quando a arquitetura do modelo já é assimétrica, a desagregação deixa de ser uma otimização de escalonador e passa a ser uma exigência da arquitetura.
O preço dessa escolha é um hop de rede no caminho crítico de toda requisição. O cache precisa sair do prefill e chegar ao decode, e depois voltar ao disco. Isso só se paga com taxa de acerto alta. E aqui aparece o dado mais eloquente do documento: nós de computação falham mais de uma ordem de grandeza mais que nós de armazenamento [3]. É a justificativa empírica para manter o estado fora das máquinas que calculam — e, como veremos, o argumento mais forte contra a escola oposta.
As quatro técnicas e a literatura que as antecede
Nenhuma das quatro inovações centrais do DeepInfer é órfã. Todas têm antepassados publicados, e o interessante é justamente o que a DeepSeek fez com a herança: em cada caso, transformou uma técnica de ganho fixo em uma técnica de ganho condicional, dependente da carga.
Wide-EP: espalhar os experts até o limite
O V4.1-Flash tem 384 experts roteados [5]. Divididos por igual, seriam 48 por GPU num EP8 e 6 num EP64; a documentação fala em 7 por GPU no EP64, sem contar o expert compartilhado, porque a DeepSeek acrescenta experts redundantes para equilibrar a carga [3]. A lógica é de banda de memória: no decode, a GPU passa a maior parte do tempo lendo pesos, não calculando. Numa estimativa grosseira deste artigo, com 16 bilhões de parâmetros ativos por passo [5] e pesos lidos a 4 ou 8 bits, isso significa algo entre 8 e 16 GB de leitura por passo do modelo inteiro; divididos por 64 GPUs, entre 125 e 250 MB por GPU por passo, amortizados pelo tamanho do lote. Menos peso por GPU, passo mais curto.
A DeepSeek apresenta o Wide-EP como uma forma de elevar a velocidade de geração por usuário [3], e não apenas o throughput agregado. Lido assim, o Wide-EP é antes uma técnica de latência: compensa sobretudo quando alguém está disposto a pagar por resposta rápida — agentes de código, chat interativo, sistemas que operam dentro de um SLO apertado.
O detalhe que denuncia o custo real está no balanceamento: alguns experts ficam muito mais ocupados que outros, e a DeepSeek remaneja especialistas a cada 10.000 passos no decode (e a cada 1.000 no prefill), chegando a um desbalanceamento medido de 1,09 no decode e de cerca de 1,07 no prefill [3]. Traduzido: a GPU mais carregada do grupo trabalha cerca de 9% acima da média, e o passo inteiro espera por ela. É um imposto que nenhum kernel resolve.
DSpark: verificar só o palpite que vale a pena
A decodificação especulativa clássica faz um modelo pequeno propor γ tokens e o grande verificar todos de uma vez. Leviathan, Kalman e Matias mostraram em 2022 que o ganho depende de duas variáveis — a taxa de aceitação e a razão de custo entre rascunho e verificação — e que verificar um palpite ruim custa o mesmo que verificar um bom [11]. O EAGLE atacou o problema pelo outro lado, rascunhando no espaço de features e lidando com a incerteza desse rascunho [12].
O DSpark ataca a terceira variável, a que ninguém havia transformado em decisão de escalonador: a profundidade da verificação. O modelo de rascunho gera 5 tokens de cada vez, e uma Confidence Head prevê a probabilidade de aceitação de cada um, para que o cômputo de verificação vá para os tokens de maior retorno marginal [3]. É um professor ocupado que corrige com cuidado as respostas em que o aluno se diz seguro e deixa de lado aquelas em que ele próprio admite estar chutando.
A DeepSeek publicou também o número que perde. Em estimativas de throughput feitas a partir de benchmarks, o DSpark fica 1,5% mais lento com baixa concorrência (16 sequências por rank), 5,4% mais rápido com 60 sequências por rank — perto do ponto de operação de produção — e 11% mais rápido com 96 [3]. Publicar um resultado negativo é raro o bastante para merecer registro. Mas o sinal trocado é contraintuitivo e a mecânica não está totalmente explicitada: com a GPU pouco ocupada, a verificação extra deveria ser quase gratuita, e ainda assim o sistema fica mais lento — provavelmente porque há custos fixos (amostragem, escrita de cache para tokens rejeitados, sincronização entre rascunho e verificação) que não aparecem no gráfico de FLOPs. A consequência prática é que o DSpark não é um ganho, é uma função da sua curva de carga. Se a sua, como a de quase todo mundo, tem vales profundos, a média pode ser negativa.
SWA bounded replay: reconstruir a última página, não o capítulo
O V4.1-Flash mantém dois tipos de memória. O cache principal, grande, mora no 3FS. O estado de atenção de janela deslizante (SWA) é pequeno — cerca de 1,4 MB por sequência — e fica na memória da máquina que o produziu, em cópia única [3]. Quando o cache principal é encontrado mas o estado SWA se perdeu, a reconstrução exata exigiria reprocessar os últimos 2.560 tokens através de 20 camadas do decodificador. A DeepSeek reprocessa apenas os últimos 128 tokens [3]. O custo vira pequeno e constante, independentemente de a conversa ter mil ou um milhão de tokens.
Aqui vale fazer uma conta que o release não faz e que muda a interpretação do sistema. A documentação diz que essa redução — de 2.560 para 128 tokens, vinte vezes menos — quase reduz pela metade a computação total de prefill [3]. Então o replay respondia por aproximadamente metade do prefill. Isso é uma afirmação sobre o regime de operação da DeepSeek, não sobre o modelo: significa que, no tráfego que ela serve, metade do trabalho de prefill é reconstituição de estado, não processamento de tokens novos. É a assinatura de uma carga agêntica, feita de sessões longas e repetidas, não de perguntas avulsas. E explica por que o custo marginal de contextos longos desaba a ponto de tornar o contexto de um milhão de tokens [5] uma decisão de produto, não de infraestrutura.
O preço é honestamente declarado: o resultado é um cache SWA aproximado, não uma cópia exata [3]. O erro tende a se concentrar onde a dependência de longo alcance importa — recuperação de informação a distâncias próximas da borda da janela, raciocínio encadeado sobre documentos longos. O repositório inclui scripts de avaliação em AIME, GPQA e HLE [2], que permitem medir a qualidade final. Nenhum gráfico de throughput mostra essa perda.
Escalonamento por orçamento de tempo
O vLLM limita o passo por contagem de tokens, via o parâmetro max_num_batched_tokens, o número máximo de tokens processados por iteração [17]. A DeepSeek passou a limitar o prefill por tempo previsto de computação, com teto de 32.768 tokens por passo [3]. A razão é aritmética: o custo de atenção cresce com o comprimento acumulado, de modo que, por exemplo, 4.000 tokens novos depois de 200.000 tokens de histórico custam muito mais do que 4.000 tokens frescos. Orçar por tokens é orçar a variável errada — o mesmo número de tokens pode custar muitas vezes mais.
A elegância da solução é também a sua barreira de adoção: para orçar por tempo é preciso um modelo de latência calibrado para o hardware específico. Isso não viaja bem entre gerações de GPU, e é mais uma razão pela qual o DeepInfer só faz sentido nas duas plataformas para as quais foi feito [2].
Onde o cache KV deve morar
O documento de implantação entrega o número que decide a arquitetura, e não é 155 trilhões nem 38 dólares: são 100 PiB de SSD no 3FS para o cache KV, ou cerca de 14,4 TB lógicos por GPU [3]. Com codificação de apagamento 10+2, cada leitura vai a 11 nós e bastam 10 respostas [3]. O TTL é de três dias para agentes e sete para chatbot [3]. E o V4.1-Flash guarda o cache principal em FP4 [5], o que reduz em cerca de quatro vezes os bytes por token em relação a FP16.
Uma conta simples, que a DeepSeek não publica, dá escala ao número: 100 PiB divididos por 14,4 TB por GPU sugerem um cluster da ordem de sete a oito mil aceleradores — uma estimativa grosseira, já que a própria documentação avisa que os 14,4 TB são tamanho lógico e que a capacidade física necessária é maior [3]. O dado mais revelador, porém, é outro: empiricamente, reduzir o TTL do tráfego de chatbot para cerca de três dias custa apenas 0,5% a 1% da taxa de acerto do cache [3]. Ou seja, quase todo o reuso acontece nos primeiros dias de uma sessão, e o que governa o sistema não é a capacidade bruta, é a política de retenção — por isso o TTL, e não o petabyte, é o parâmetro que a DeepSeek escolheu diferenciar entre agentes e chatbots [3].
Contra essa arquitetura existe uma escola coerente. O llm-d, pilha nativa de Kubernetes para inferência distribuída, aposta no roteamento ciente de prefixo e de cache KV: em vez de mover o cache até a requisição, move a requisição até onde o cache já está [14]. É a geografia oposta. E, no meio, o Mooncake, a arquitetura centrada em cache KV que sustenta o Kimi, da Moonshot AI: um cache desagregado que aproveita CPU, DRAM e SSD ociosos do cluster, tratando o cache como cidadão de primeira classe em vez de subproduto do motor [10].
A questão técnica que separa os campos é uma razão: quantos bytes cada token custa, multiplicado por quantas vezes ele será reutilizado, contra o custo de movê-lo. Se o cache de um token custa poucos kilobytes e é reutilizado cem vezes, transportá-lo uma vez é trivialmente vantajoso. Se é reutilizado duas vezes, não é. A compressão em FP4 desloca essa fronteira nos dois sentidos ao mesmo tempo: menos bytes por token significam mais tokens cabendo na HBM — o que favorece a escola do llm-d — e menos bytes para transportar — o que favorece o pool. A compressão não resolve o debate; ela o transfere para a variável que resta, que é a estrutura da sessão.
Aqui assumo uma posição. A obsessão com paridade de kernels está mal direcionada. A diferença de no máximo 5% entre o desempenho público e o interno [3] é ruído estatístico diante da decisão de 14,4 TB por GPU. Duas equipes com os mesmos kernels e políticas de cache opostas terão custos por token que diferem por múltiplos, não por porcentagens. O número que a DeepSeek enterrou no meio de um FAQ — aquele que diz que nós de computação falham mais de uma ordem de grandeza mais que nós de armazenamento [3] — é mais importante que todos os gráficos de throughput do release, porque é a única evidência empírica apresentada sobre por que o estado deve viver longe do cálculo. E, curiosamente, ele não refuta o llm-d: o llm-d trata a localidade como dica de roteamento, não como garantia de durabilidade, e aceita recomputar quando a máquina cai. As duas escolas não discutem onde o cache deve estar. Discutem por quanto tempo ele deve sobreviver. A DeepSeek respondeu três e sete dias [3]; o llm-d responde o tempo de vida de um pod.
Avaliações: o que os números provam e o que eles apenas sugerem
Todos os números citados até aqui são autodeclarados. Não há artefato de terceiros, traço público de tráfego ou reprodução independente. Isso não os torna falsos; torna-os não falsificáveis no estado atual. E algumas das cifras mais repetidas na imprensa técnica não foram ditas pela DeepSeek.
A primeira confusão é entre receita e lucro. Os 38 dólares por GPU-hora são receita calculada ao preço fora de pico [3], não uma margem. Multiplique: 38 × 24 × 81 dá cerca de 73,9 mil dólares por GPU ao longo dos 81 dias de payback divulgados. Para saber se isso é retorno ou fantasia, seria preciso conhecer o custo do acelerador, da energia, do 3FS, da rede e a taxa de utilização — nenhum desses números foi publicado pela DeepSeek. As margens de cerca de 80% e o payback de 81 dias são estimativas da newsletter Latent Space, que as apresenta como cálculos de cenário, não como dados auditados da empresa [15]. A distinção não é cosmética: são as estimativas que circularam como se fossem dados da DeepSeek.
A segunda confusão é de denominador. Cento e cinquenta e cinco trilhões de tokens por dia, num único cluster [3], dão cerca de 1,8 bilhão de tokens por segundo. É tentador dividir esse total pelo número de GPUs e compará-lo com o throughput de qualquer motor — mas a comparação não se sustenta, porque, numa carga dominada por sessões longas e reaproveitamento de prefixo, a maior parte desses tokens é servida a partir do cache e não é recalculada. O número mede tokens entregues, não tokens computados. Para transformá-lo em eficiência seria preciso conhecer a taxa de acerto do cache, a proporção entre entrada e saída e o mix entre agentes e chatbot — e nenhum desses dados foi publicado. O mesmo vale para os 38 dólares: é receita em preço de vale, e cruzá-la com o volume de tokens sem saber o mix de preços (cache, entrada, saída) produz qualquer margem que se queira.
A terceira é a restrição de reprodutibilidade. Reproduzir qualquer coisa exige 128 GPUs Blackwell ou Ascend 950, mais 100 PiB de um sistema de arquivos distribuído que a própria DeepSeek desenvolveu e descreveu em outro artigo [3][13]. Academias não têm isso; a maioria das empresas também não. A exigência não é um detalhe logístico: sem o 3FS, o comportamento do cache — que é metade do sistema — não se manifesta. Você pode rodar o DeepInfer num cluster pequeno e obter números que não dizem nada sobre o sistema que gerou as cifras.
A quarta é o contra-argumento mais direto. Segundo a Latent Space, o projeto vLLM relatou no X ter obtido, em GB200 e com configuração equivalente, throughput de decode a até 6% dos números publicados do DeepInfer — paridade no decode, e apenas no decode, não no serviço inteiro [15]. A postagem original não pôde ser verificada de forma independente para este artigo. Ainda assim, a implicação é desconfortável para a narrativa do release: se o decode, que é a parte que o código público cobre, está essencialmente empatado, então o diferencial da DeepSeek não está no código que ela abriu. Está no que ficou fechado.
Diante disso, como uma equipe deveria avaliar a adoção? Com uma sequência de testes que começa antes de qualquer benchmark. Primeiro, medir a distribuição de reuso de prefixo do próprio tráfego: se ela não existir, toda a arquitetura de cache compartilhado é passivo, não ativo. Segundo, submeter o SWA bounded replay a um harness de qualidade estratificado por comprimento de contexto e família de tarefa — matemática, código, recuperação de longo alcance — porque é a única técnica do pacote que troca exatidão por velocidade [3]. Terceiro, testar o DSpark na própria curva de carga, incluindo os vales, onde ele perde 1,5% [3]. Quarto, medir o desbalanceamento de experts no próprio mix, porque o 1,09 da DeepSeek é propriedade do tráfego dela [3]. Quinto, e mais importante, comparar custo por milhão de tokens sob SLO, nunca throughput de pico — e usar referências abertas e continuamente atualizadas, como o InferenceMAX, da SemiAnalysis, em vez de gráficos de fornecedor [16].
O que sobra para quem usa vLLM, SGLang ou llm-d
Para quem opera vLLM, o valor não está nos kernels — está no escalonador. A substituição de um teto de tokens por um orçamento de tempo é uma ideia portátil e subestimada, e a Confidence Head do DSpark é um padrão de projeto reutilizável em qualquer esquema especulativo, porque trata um problema que o EAGLE não endereça diretamente: quanto verificar, e não apenas o que propor [12]. O bem mais valioso do release, porém, é o hábito de publicar o número que perde. Um ecossistema em que todos reportam apenas o melhor caso é um ecossistema que aprende devagar.
Para quem usa SGLang, a lição é de camada. O RadixAttention já entrega reuso de cache KV dentro da GPU, com uma árvore de prefixos compartilhada entre requisições [7]. O que o DeepInfer acrescenta é o argumento de que o horizonte do acerto importa mais que a latência do acerto: um cache que vive segundos é um cache que vive dentro de um lote; um cache que vive dias é um cache que atravessa sessões. A arquitetura de duas camadas — GPU mais armazenamento remoto — deixa de ser exotismo e passa a ser o desenho natural para cargas agênticas.
Para quem usa llm-d, a relação é de complementaridade, não de substituição. Roteamento ciente de prefixo é política de tráfego; pool de cache é política de armazenamento. Nada impede rotear para onde o cache está e, ao mesmo tempo, persistir o cache para que o roteamento o encontre amanhã. Os TTLs da DeepSeek — três e sete dias [3] — são o melhor dado público disponível sobre quanto tempo a localidade sobrevive em cargas reais, e servem como referência inicial para calibrar expiração em qualquer sistema.
O denominador comum é uma conta que quase ninguém faz: quantos bytes o cache KV do seu modelo custa por token. Esse número, e não a marca do motor, decide se a sua arquitetura deve apostar em localidade ou em pooling. O V4.1-Flash respondeu com FP4 e cerca de 890 bytes por token no cache global [5], o que é uma escolha de produto tão relevante quanto qualquer kernel.
Conclusão
O DeepInfer não é um presente nem uma isca. É um balanço patrimonial em forma de código: mostra que o custo da inferência de fronteira se concentra na memória, que a fronteira entre prefill e decode virou parte da arquitetura do modelo, e que a distância de desempenho entre o que é público e o que é interno é de no máximo 5% [3] — o diferencial está em outro lugar. O que a DeepSeek abriu é a parte que ela pode perder sem perder nada; o que fechou é onde o dinheiro mora. Isso não diminui o release — aumenta o que se pode aprender com ele, desde que se resista à tentação de tratá-lo como produto.
Duas direções merecem atenção. A primeira é a reprodutibilidade: enquanto não houver uma reprodução independente em 128 GPUs com traço de tráfego publicado, as cifras de 155 trilhões de tokens e 38 dólares seguirão sendo literatura, não evidência. A segunda é a métrica: enquanto o campo medir throughput de pico, continuará premiando arquiteturas que brilham em gráficos e falham em faturas. Custo por milhão de tokens sob SLO — e a taxa de acerto de cache que o torna possível — é a única régua que separa engenharia de marketing. O resto são os cem petabytes que ninguém vê.
Referências
- [1] DeepSeek-AI. Repositório deepseek-ai/deepseek-recipe. GitHub. https://github.com/deepseek-ai/deepseek-recipe
- [2] DeepSeek-AI. Repositório deepseek-ai/DeepInfer (licença Apache 2.0). GitHub. https://github.com/deepseek-ai/DeepInfer
- [3] DeepSeek-AI. Documento de perguntas e respostas de implantação do DeepInfer (inference_deployment_qa.md). GitHub. https://github.com/deepseek-ai/DeepInfer/blob/main/doc/inference_deployment_qa.md
- [4] DeepSeek-AI (2025). The Path to Open-Sourcing the DeepSeek Inference Engine. GitHub/open-infra-index. https://github.com/deepseek-ai/open-infra-index/blob/main/OpenSourcing_DeepSeek_Inference_Engine/README.md
- [5] DeepSeek-AI (2026). DeepSeek-V4.1-Flash: Pushing the Limits of KV Cache Compression. arXiv:2609.19969. https://arxiv.org/abs/2609.19969
- [6] Kwon, W. et al. (2023). Efficient Memory Management for Large Language Model Serving with PagedAttention. arXiv:2309.06180. https://arxiv.org/abs/2309.06180
- [7] Zheng, L. et al. (2023). SGLang: Efficient Execution of Structured Language Model Programs. arXiv:2312.07104. https://arxiv.org/abs/2312.07104
- [8] Zhong, Y. et al. (2024). DistServe: Disaggregating Prefill and Decoding for Goodput-optimized Large Language Model Serving. OSDI 2024. arXiv:2401.09670. https://arxiv.org/abs/2401.09670
- [9] Patel, P. et al. (2023). Splitwise: Efficient generative LLM inference using phase splitting. arXiv:2311.18677. https://arxiv.org/abs/2311.18677
- [10] Qin, R. et al. (2024). Mooncake: A KVCache-centric Disaggregated Architecture for LLM Serving. arXiv:2407.00079. https://arxiv.org/abs/2407.00079
- [11] Leviathan, Y., Kalman, M., Matias, Y. (2022). Fast Inference from Transformers via Speculative Decoding. arXiv:2211.17192. https://arxiv.org/abs/2211.17192
- [12] Li, Y. et al. (2024). EAGLE: Speculative Sampling Requires Rethinking Feature Uncertainty. arXiv:2401.15077. https://arxiv.org/abs/2401.15077
- [13] An, W. et al. (2024). Fire-Flyer AI-HPC: A Cost-Effective Software-Hardware Co-Design for Deep Learning. arXiv:2408.14158. https://arxiv.org/abs/2408.14158
- [14] llm-d. Announcing the llm-d community! (llm-d: a Kubernetes-native distributed inference stack). https://llm-d.ai/blog/llm-d-announce
- [15] Latent Space. AINews: DeepSeek DeepInfer: Open Source SOTA Inference running 155T toks/day/cluster. https://www.latent.space/p/ainews-deepseek-deepinfer-open-source
- [16] SemiAnalysis (2025). InferenceMAX: Open Source Inference Benchmarking. https://newsletter.semianalysis.com/p/inferencemax-open-source-inference
- [17] vLLM. Engine Arguments (documentação oficial). https://docs.vllm.ai/en/v0.4.1/models/engine_args.html