Headroom: A ferramenta da Netflix que torna agentes de IA 10x mais baratos

PortuguêsالعربيةDeutschEnglishEspañolFrançaisहिन्दीBahasa Indonesia日本語한국어Русский中文
BBetter Stack
Computing/SoftwareSmall Business/StartupsInternet Technology

Transcript

00:00:00Este é o Headroom, uma ferramenta de código aberto que comprime tudo o que seu agente de IA lê,
00:00:04ou seja, chamadas de ferramentas, arquivos de código e RAG, antes que cheguem ao LLM, permitindo reduzir tokens
00:00:09em 60 ou até 95% e obter exatamente a mesma resposta. E a parte inteligente é que é reversível, então o
00:00:14modelo pode pedir as informações completas de volta sempre que realmente precisar.
00:00:18Mas compressão geralmente significa perder algo, então como remover a maior parte do contexto
00:00:23e ainda obter a resposta certa? Essa é uma pergunta genuinamente interessante, então inscreva-se e vamos descobrir.
00:00:31Se você já usou um harness como o ClaudeCode, sabe que ele consome muitos tokens. Cada chamada de ferramenta
00:00:35pode despejar enormes logs JSON, que são basicamente ruído, distraindo das informações importantes,
00:00:40e tudo isso é inserido na janela de contexto, que é o que você paga.
00:00:45Especialmente se você usa algo como o Opus no modo UltraCode, que executa fluxos de trabalho dinâmicos,
00:00:50iniciando subagentes paralelos sem limite de tokens. É por isso que Tejas Chopra, desenvolvedor sênior na Netflix,
00:00:57criou o Headroom, que funciona detectando o tipo de conteúdo e mantendo as informações relevantes.
00:01:01Então, para arrays JSON, ele mantém anomalias e casos extremos; possui um compressor de código que lê
00:01:06a árvore sintática real e, ao ler logs de compilação, mantém as falhas e descarta os testes que passaram.
00:01:11Mas aqui está a parte interessante. Para texto simples, o Headroom usa seu próprio modelo chamado CompressBase,
00:01:17que o próprio Tejas treinou apenas para compressão, e este modelo roda localmente na sua máquina.
00:01:22O Headroom afirma que já economizou cerca de US$ 700.000 em tokens para os usuários,
00:01:26e o que é realmente inteligente é que ele deixa um rastro no texto comprimido,
00:01:30contendo um hash que o modelo pode usar para recuperar os dados não comprimidos se realmente precisar.
00:01:35Agora, se você assistiu ao vídeo de James sobre o Caveman, ele também reduz o contexto,
00:01:39mas a partir da direção oposta, e explicarei mais sobre isso mais adiante no vídeo.
00:01:43Mas por agora, vamos ver um exemplo básico do Headroom para entender como funciona.
00:01:46O Headroom funciona usando um servidor Python que fica entre seu aplicativo,
00:01:50então pode ser código rastreado, e, por exemplo, os servidores da Anthropic.
00:01:54Então, quando o resultado de uma chamada de ferramenta retorna, o proxy comprime usando Rust,
00:01:59e apenas envia a versão comprimida para a API.
00:02:01Você pode instalar o servidor com pip, mas vou usar o uv e garantir que a versão do Python
00:02:06seja 3.12, porque não funcionará em versões mais recentes que essa.
00:02:09Em seguida, execute o comando headroom proxy desta biblioteca, que dispara o proxy nesta porta.
00:02:14O Headroom também possui um SDK para TypeScript ou Python,
00:02:17e para a demonstração, usaremos o Python para criar um app usando o SDK do Claude.
00:02:22Podemos instalar ambos assim, e estamos prontos para começar a usar o app.
00:02:25O plano é mostrar como usar o Headroom com o Claude Code mais tarde,
00:02:29mas primeiro eu queria mostrar como funciona nos bastidores.
00:02:32Para este app, temos um prompt de usuário para ler todos os arquivos de log e descobrir o erro,
00:02:36bem como a causa raiz. E a partir daqui, vamos simular a chamada da ferramenta.
00:02:40Então, vamos fazer o Claude realizar uma chamada de ferramenta bash para ler o arquivo de log do servidor,
00:02:44que contém vários logs falsos e está importado aqui.
00:02:47E então vamos retornar os resultados da chamada da ferramenta.
00:02:49O motivo de não darmos o arquivo de texto diretamente ao Headroom
00:02:52é porque ele só comprime a saída de chamadas de ferramentas.
00:02:54Aqui especificamos o modelo e, abaixo, usamos a função headroom compress
00:02:59para pegar a mensagem com o modelo para contagem precisa de tokens.
00:03:02O Headroom não usa o Haiku.
00:03:04E então fornecemos a URL base do proxy.
00:03:06Temos vários logs de controle para fins de teste,
00:03:08mostrando a mensagem antes e depois do Headroom,
00:03:11e mais alguns logs de controle mostrando a economia percentual.
00:03:13Depois disso, passamos a mensagem comprimida do Headroom para o Claude Code,
00:03:17que também contém o prompt do usuário.
00:03:18Agora, se executarmos esse arquivo, podemos ver que o Headroom economizou 98% dos tokens.
00:03:23Aqui estão os tokens antes e aqui estão os tokens depois.
00:03:26Então, economizou mais de 17.000 tokens.
00:03:28E é óbvio ver ao observar o antes e o depois.
00:03:31Se subirmos a tela, este é o antes, o que normalmente é enviado ao Claude Code.
00:03:35Recebemos o prompt do usuário, a chamada da ferramenta e a resposta, que é o arquivo de log inteiro.
00:03:39E se olharmos aqui para o que o Headroom envia, vemos que recebemos a mesma mensagem e chamada,
00:03:43mas a resposta da ferramenta é muito menor.
00:03:45E o que ele fez aqui foi usar compressão estatística para descartar tokens redundantes.
00:03:50Ele removeu 419 logs de informações semelhantes e os comprimiu em um resumo.
00:03:54Aqui abaixo podemos ver que o Headroom diz ao Claude que esta é a saída comprimida.
00:03:58Ele pode recuperá-la usando este hash.
00:04:00Aqui vemos uma das desvantagens imediatas do Headroom: o Claude acha que não tem
00:04:05informações suficientes para completar a tarefa, mas definitivamente tem.
00:04:08Então, vamos executar nosso arquivo novamente.
00:04:10E podemos ver que desta vez ainda temos 98% de economia, mas temos muito mais informações do Claude.
00:04:16Vamos tentar outra demo.
00:04:17Como de costume, precisamos executar o proxy do Headroom, mas desta vez dou mais parâmetros.
00:04:21Aqui podemos ver que adiciono o valor ML, que usa o modelo de compressão localmente para texto simples.
00:04:26E adicionei código para disponibilizar o compressor ciente de código.
00:04:30E então adicionei a flag code aware para ativá-lo.
00:04:32Então agora podemos ver que está habilitado aqui.
00:04:34Vou executar o Claude Code, mas primeiro vou definir a URL base para o proxy.
00:04:39Com isso no lugar, vou dar ao Claude um prompt para ler todos os arquivos TS deste projeto
00:04:44e me dar uma visão detalhada do que este projeto está fazendo, com citações do código relevante.
00:04:49E depois de um tempo, ele me dá uma resposta dizendo que leu todos os arquivos TypeScript
00:04:53nos cinco pacotes e me deu uma visão geral padrão.
00:04:56Mas se executarmos o comando /context, o que fiz antes, vemos que ele usou 89,1 mil tokens.
00:05:02Agora, eu fui em frente e executei um prompt semelhante no Claude sem usar o Headroom.
00:05:06E se rolarmos até o final e virmos onde causamos o comando /context,
00:05:10isso usou um pouco mais de tokens.
00:05:11Agora, não tenho certeza de por que ele escolheu usar a janela de contexto de 1 milhão do Opus aqui.
00:05:16Mas podemos usar curl neste endpoint com jq para ver exatamente de onde veio a compressão do proxy.
00:05:21Isso contém muitas informações, então levei um tempo para encontrar.
00:05:23Mas se subirmos, podemos ver quantos tokens foram economizados pela compressão do Headroom
00:05:26e até ver quanto dinheiro a compressão nos economizou.
00:05:30Claro, tudo isso foi apenas a partir de um único prompt.
00:05:32Mas imagine se eu tivesse várias sessões do Claude Code rodando e o Headroom comprimindo todas as chamadas
00:05:35de ferramentas. Imagine quantos tokens a mais eu economizaria.
00:05:39Também quero ressaltar que quando executei o prompt exato com esforço baixo no Opus,
00:05:42o Headroom não fez nenhuma economia de tokens.
00:05:46Foi apenas quando mudei de baixo para médio que a economia de tokens foi visível.
00:05:49Talvez se eu estivesse no alto, extra-alto ou até máximo, economizaria ainda mais.
00:05:53Mas, de qualquer forma, essa foi uma visão geral rápida do Headroom.
00:05:57E, claro, existem muito mais recursos que eu poderia ter abordado,
00:06:00como a memória entre agentes, que permite ao Claude, Codex e outros harnesses
00:06:03compartilharem o mesmo contexto comprimido.
00:06:07Headroom Learn, que mina suas sessões falhas para entender o que comprimiu
00:06:09demais e aprende para não cometer o mesmo erro no futuro,
00:06:12além de integrações com SDKs populares.
00:06:15Mas há uma coisa importante a considerar sobre o Headroom.
00:06:18Cada vez que o modelo não obtém as informações necessárias
00:06:21e pede ao Headroom para fornecer os dados completos, ele faz uma segunda viagem de ida e volta,
00:06:24o que significa que você acaba usando mais tokens com o Headroom em alguns casos do que sem ele.
00:06:28Mas acho que essa é a vantagem de usar o recurso Headroom Learn,
00:06:33que tenta evitar que isso aconteça cada vez mais no futuro.
00:06:36Mas lembra quando falei sobre o Caveman no início do vídeo?
00:06:39Bem, o Caveman reduz tokens instruindo o modelo a responder em fragmentos curtos,
00:06:42descartando palavras de preenchimento e assim por diante.
00:06:46Mas, como você acabou de ver na demonstração, o Headroom encolhe o que o modelo lê
00:06:48antes mesmo de chegar ao modelo.
00:06:51Então, um corta a saída enquanto o outro corta a entrada,
00:06:52o que significa que tecnicamente você pode usá-los juntos para máxima economia de tokens,
00:06:56se você realmente se importa tanto assim em economizar tokens.
00:07:00...

Key Takeaway

O Headroom reduz o custo de tokens em até 95% ao comprimir dinamicamente a entrada de agentes de IA, mantendo a reversibilidade dos dados por meio de um sistema de hash e aprendizado contínuo.

Highlights

  • O Headroom reduz o consumo de tokens em chamadas de agentes de IA entre 60% e 95%.

  • A ferramenta utiliza compressão estatística e um modelo de compressão local (CompressBase) para manter informações relevantes, como anomalias e falhas de compilação.

  • O proxy do Headroom atua entre o aplicativo e a API de LLMs como a da Anthropic, comprimindo o conteúdo antes da entrada no modelo.

  • Cada dado comprimido contém um hash que permite ao modelo solicitar a recuperação dos dados originais caso necessário.

  • Usuários já economizaram cerca de US$ 700.000 em custos de tokens utilizando esta ferramenta de código aberto.

  • Recursos como o 'Headroom Learn' permitem que a ferramenta identifique falhas de compressão passadas para evitar perdas de contexto em futuras execuções.

Timeline

O funcionamento do Headroom e economia de tokens

  • A compressão reduz o volume de tokens enviados a LLMs em até 95%.
  • A reversibilidade permite que o modelo recupere informações completas quando a versão comprimida é insuficiente.
  • A detecção de contexto mantém casos extremos, anomalias JSON e falhas de compilação.

O Headroom atua como um compressor de código aberto para chamadas de ferramentas e arquivos que alimentam agentes de IA. Ele utiliza lógica específica para cada tipo de dado, mantendo elementos críticos como falhas em logs e descartando redundâncias. O sistema garante que a precisão da resposta final permaneça inalterada, mesmo com uma drástica redução de tokens.

Implementação técnica e demonstrações práticas

  • O proxy é instalado via Python e requer a versão 3.12 para operação correta.
  • A compressão atua sobre o resultado de chamadas de ferramentas, não diretamente no texto bruto.
  • O uso de flags como --code-aware e modelos locais melhora a eficiência em projetos complexos.

A configuração envolve a execução de um servidor proxy que processa as saídas das ferramentas antes de encaminhá-las para a API do modelo, como o Claude Code. Testes demonstraram economias superiores a 17.000 tokens em uma única execução de logs. A eficácia da compressão escala conforme os parâmetros do modelo, apresentando ganhos visíveis ao utilizar níveis de esforço mais altos.

Recursos avançados e limitações

  • O recurso Headroom Learn analisa sessões falhas para otimizar compressões futuras.
  • A memória compartilhada permite o uso do mesmo contexto comprimido entre diferentes agentes.
  • Recuperar dados originais não comprimidos causa uma segunda viagem de ida e volta, aumentando o custo em casos específicos.

Além da compressão base, o sistema integra memória entre agentes para manter a coesão do contexto. A principal desvantagem ocorre quando a compressão é excessiva, forçando o modelo a pedir os dados originais e gerando latência e uso extra de tokens. O uso conjunto com estratégias como o Caveman, que otimiza a saída do modelo, permite uma economia ainda maior.

Community Posts

No posts yet. Be the first to write about this video!

Write about this video