Holo4: um modelo que clica, programa e chama ferramentas

Ver no idioma original →

Autoria: Sam Witteveen · 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: Holo4: A Model That Clicks, Codes and Calls Tools · Canal: Sam Witteveen · 18:00 · Assistir no YouTube

Tópicos: Agentes de IA, Modelos de IA, Modelos locais e open source

Resumo

O vídeo apresenta o Holo4, um modelo open weight treinado para escolher entre interagir com interfaces gráficas, escrever código e chamar ferramentas, como MCPs e APIs. O apresentador explica como o modelo foi treinado para selecionar a abordagem adequada e compara o desempenho de suas versões densa e MoE em benchmarks. Demonstra tarefas que combinam navegação por interface, processamento de arquivos com código e uso de ferramentas. A principal ressalva é a licença não comercial, embora os pesos e as trajetórias dos benchmarks estejam disponíveis.

Pontos-chave

• O Holo4 foi treinado para combinar tarefas visuais em interfaces gráficas, execução de código e chamadas de ferramentas.
• O modelo escolhe entre essas abordagens conforme a tarefa e os recursos disponíveis, em vez de depender de um único tipo de interação.
• O harness executa as ações escolhidas pelo modelo e devolve os resultados para que ele continue o loop do agente.
• O treinamento combina fine-tuning supervisionado, ambientes interativos e reinforcement learning para ensinar o modelo a escolher a abordagem mais eficaz.
• Nos benchmarks apresentados, a versão densa de 27B supera com folga a versão MoE de 35B com 3B parâmetros ativos em tarefas visuais.
• Capturas de tela podem ocupar rapidamente o KV cache, o que deve ser considerado ao executar o modelo.
• A licença do Holo4 é não comercial; para lançar um produto, é necessário usar a API da H Company ou contatá-la diretamente.
• As trajetórias usadas nos benchmarks estão disponíveis publicamente e podem ajudar no desenvolvimento de modelos semelhantes.

Capítulos

Início	Capítulo	Resumo
00:00	Por que agentes precisam combinar diferentes formas de interação	O vídeo apresenta o problema de agentes limitados a interfaces visuais ou a ferramentas e APIs e introduz o Holo4 como uma tentativa de unir essas capacidades.
03:10	As três formas de agir e o papel do Holo4	O apresentador descreve interfaces gráficas, código e ferramentas como as três vias de ação e explica como o modelo pode escolher entre elas.
06:19	Modelos, benchmarks e custos	São apresentados os modelos lançados, os requisitos para executá-los e as comparações de desempenho entre as versões densa e MoE.
09:27	Treinamento e seleção de ações	O vídeo explica os ambientes interativos, o reinforcement learning, o fine-tuning supervisionado e os ajustes feitos no harness.
12:11	Demonstrações com interface, código e MCP	Demonstrações mostram o Holo4 navegando por uma interface, processando arquivos com código e usando ferramentas MCP.
15:51	Licença, trajetórias e conclusões	O apresentador comenta a licença não comercial, a disponibilidade das trajetórias e o potencial de agentes que alternam entre diferentes formas de ação.

Citações

O modelo em si nunca toca em nada. Ele só decide. O harness é que faz tudo. — 02:40

Eles treinaram este modelo para fazer as três coisas em conjunto. — 05:17

É assim que o modelo aprende que clicar em cinco menus talvez seja o caminho mais lento quando há uma API disponível. — 10:36

Você pode experimentar, prototipar e fazer pesquisa com ele. — 16:22

Conceitos e entidades

• Holo4 (modelo): Família de modelos da H Company treinada para alternar entre interfaces gráficas, código e ferramentas.
• H Company (empresa): Empresa de Paris que desenvolve os modelos Holo e lançou o Holo4.
• Holo4 27B (modelo): Versão densa de 27B do Holo4, que obteve resultados superiores à versão MoE em alguns benchmarks apresentados.
• Holo4 35Ba3b (modelo): Versão MoE do Holo4 com 35B de parâmetros totais e 3B ativos, conforme descrito no vídeo.
• Holotron Nano (modelo): Modelo que aplica a mesma receita de treinamento do Holo4 ao Nemotron 3 Nano Omni.
• Qwen (modelo): Família de modelos usada como base para as versões densa e MoE do Holo4.
• Nemotron 3 Nano Omni (modelo): Modelo da NVIDIA usado como base para o Holotron Nano.
• High Agents (ferramenta): Harness e SDK da H Company para executar agentes hospedados e integrar-se a ferramentas como Claude Code por MCP.
• MCP (conceito): Protocolo usado no vídeo como uma das formas de conectar o modelo a ferramentas e servidores.
• Harness (conceito): Código que executa as ações escolhidas pelo modelo e retorna a ele os resultados da interação.
• Agentic task factory (conceito): Conjunto de pipelines da H Company que cria tarefas e ambientes interativos verificáveis automaticamente para o treinamento.
• reinforcement learning (conceito): Método de treinamento usado para recompensar o modelo pelas abordagens que resolvem melhor cada tarefa.
• OSWorld (benchmark): Benchmark citado na comparação do desempenho dos modelos em tarefas de interação com computadores.
• Hugging Face (empresa): Plataforma onde, segundo o vídeo, estão disponíveis os pesos dos modelos.

Tradução completa (pt-BR)

00:00 Certo, imagine que você criou um agent que consegue usar um computador. Ele olha para uma tela, consegue clicar, consegue digitar, mas aí você o coloca em um servidor sem tela. Ele simplesmente vai ficar travado. Não tem nada para olhar. Ele foi criado para tarefas visuais. Se invertermos a situação: se você tem um agent que é ótimo em chamar ferramentas e APIs, mas depois pede para ele extrair um relatório de algum aplicativo antigo ou algo assim, que não tem API, ele também fica travado, certo? Ele não consegue olhar para a interface. Não consegue realmente agir sobre ela, e até agora…

00:32 Até agora, as pessoas geralmente tendiam a criar modelos para trabalhar em um lado ou no outro dessa linha. Ou seja, ou capazes de fazer coisas visuais e agir sobre elas, clicar nelas, esse tipo de coisa, ou capazes de lidar com as coisas relacionadas a API, as tarefas não visuais. Infelizmente, porém, o problema é que o trabalho real não fica em apenas um lado ou no outro dessa linha. Cada vez mais, à medida que as pessoas usam agents para realizar uma grande variedade de tarefas diferentes, muitas vezes é preciso clicar em uma interface legada.

01:03 Depois, é preciso limpar um arquivo CSV. Em seguida, publicá-lo no Slack ou em alguma outra API. E, no momento, a maneira como as pessoas têm lidado com isso é usando vários modelos diferentes. Elas encadeiam modelos. Então, há um modelo visual ao qual você fornece tudo como capturas de tela. Há outro modelo que faz a orquestração e lida com MCPs, etc. Neste vídeo, quero falar sobre um modelo de uma empresa de Paris chamada H Company, o laboratório por trás dos Holo Models. Eles acabaram de lançar o Holo4, e é disso que quero falar aqui.

01:34 Basicamente, este é um modelo de pesos abertos treinado para clicar, escrever, executar código, chamar MCPs, usar ferramentas de API, etc. E, o mais importante, para orquestrar e escolher entre essas ações à medida que avança. Acho que há duas partes realmente interessantes aqui. Há o próprio modelo, que vamos analisar, mas a outra parte é como treinar um modelo para fazer essa escolha. E vale apontar que eles têm, na verdade, uma família de modelos Holo. Então, vamos dar uma olhada neles, ver como se encaixam em um agent, como são criados e…

02:06 …também, talvez, onde deixam a desejar, etc. Certo, vamos recapitular o que é um loop de agent na prática. Basicamente, você dá uma tarefa ao agent. O modelo analisa o que está acontecendo e decide uma ação, certo? Então, o harness, que é simplesmente o código ao redor dele, executa essa ação. Ele clica, executa código, chama a ferramenta. E então, obviamente, captura o que aconteceu, seja uma nova captura de tela ou apenas algum retorno de uma API, e envia isso de volta ao modelo, junto com a memória das etapas anteriores ao redor dela.

02:40 E esse loop continua se repetindo, certo? Basicamente, é isso que está acontecendo aqui. Acho que o principal é que o próprio modelo nunca toca em nada de fato. Ele apenas decide. O harness é que realmente faz tudo. E isso importa cada vez mais hoje em dia. Quando analisamos benchmarks, vemos que os modelos podem ter pontuações muito diferentes dependendo do harness com que estão sendo executados. No caso do Holo 4, eles otimizaram o modelo para funcionar com três categorias principais de ações. A primeira são as GUIs, certo?

03:10 Interfaces gráficas do usuário. O modelo olha para uma captura de tela e diz: “Clique aqui, digite isto”. Dá para pensar nisso como o agent usando um computador, um dispositivo web, um navegador, do jeito que você usa. Funciona com qualquer coisa que uma pessoa possa usar, mas é lento e pode falhar quando alguém move um botão, muda a interface, etc. A segunda categoria é código. O modelo escreve um script, executa-o em um sandbox ou shell e recebe um resultado. É rápido e preciso, mas só funciona quando é possível escrever algum…

03:42 …software para realizar a tarefa específica, certo? Ele não consegue simplesmente escrever código em Python para saber qual botão deve apertar com base em uma saída visual. A terceira categoria é um pouco parecida com a segunda, mas aqui entram as ferramentas. Servidores MCP, APIs, esse tipo de coisa. O modelo chama uma função e recebe dados estruturados. E, em muitos aspectos, esta é a mais confiável das três. Mas, obviamente, o desafio é que só funciona se houver um MCP, uma API ou algum tipo de ferramenta que realmente faça o que você quer. Agora…

04:14 …o desafio para muitas pessoas que executam agents, especialmente agents locais, é que essas três categorias muitas vezes exigem modelos diferentes ou configurações diferentes no agent harness. Se você tem algo que processa capturas de tela, isso vai consumir uma enorme quantidade de context, em comparação com simplesmente arquivos JSON ou algumas linhas da saída do terminal, etc. E, exatamente por esse motivo, a maioria das pessoas tende a ignorar a execução de algo que consiga lidar com tarefas visuais, simplesmente porque muitas vezes não é prático fazer isso localmente. Voltando ao exemplo que mencionei na introdução…

04:47 …algo como exportar um relatório de algum aplicativo legado por meio de uma GUI. Você quer que ele navegue por um site de comércio eletrônico e encontre coisas diferentes que não estão disponíveis pela API. Depois, quer que ele pegue esses dados, organize-os em um arquivo CSV usando um script em Python e os publique em uma API como a do Slack, etc. Esse é exatamente o tipo de objetivo que o Holo-4 está tentando alcançar. Eles descrevem isso como trabalhar entre interfaces. Não é apenas o suporte a MCP como um recurso: o modelo é treinado para escolher a categoria certa…

05:17 …entre imagens, código ou ferramentas. E, em muitos aspectos, é isso que o diferencia. Os modelos Holo anteriores que eles treinaram usavam function calling. A grande diferença aqui, porém, é que treinaram este modelo para fazer as três coisas em conjunto. As interfaces gráficas do usuário são uma opção de primeira classe, o código é uma opção de primeira classe e as ferramentas são uma opção de primeira classe. Agora, elas não são apenas complementos. A grande pergunta para mim era: você usaria este como seu único modelo ou junto com outro? E a resposta talvez seja: os dois.

05:48 A H executa todos os benchmarks usando o Holo como único modelo, tanto para planejar quanto para agir. Mas você também poderia colocá-lo por baixo de um modelo maior para fazer a orquestração, ou usar um modelo diferente, se quisesse. A H tem seu próprio harness e SDK, chamados High Agents, que executam os agents hospedados da empresa e podem se integrar a coisas como o Claude Code por meio de MCP. Assim, seu modelo principal planeja o trabalho e delega ao Holo as tarefas que exigem muita interação com a tela. E acho que isso pode fazer sentido para certos casos de uso em que você só quer…

06:19 …usá-lo para tarefas com GUI, para todo esse tipo de uso de agents com computador. Certo, vamos ver o que a empresa lançou de fato. Eles têm dois modelos principais: o Holo4 27B, um modelo denso baseado no Qwen 3.8 27B, e também o Holo4 35Ba3b, certo? Esse é basicamente um modelo de mistura de especialistas com 3B ativos. Esse ainda é baseado no modelo Qwen 3.6. Junto com esses dois modelos, eles também lançaram o Holotron Nano, que usa a mesma receita usada para…

06:51 …criar os dois primeiros, mas aplicada ao Nemotron 3 Nano Omni, da NVIDIA. Fiz um vídeo sobre o Nemotron 3 Nano Omni — que nome comprido! Mas você pode conferir se quiser saber mais sobre alguns dos motivos pelos quais as pessoas estão usando esse modelo menor. Certo, os pesos de todos eles estão no Hugging Face. Há várias quantizações diferentes, etc. Eles também têm sua própria API, se você quiser executá-los por ela. A versão completa de 16 bits em bfloat tem 54 GB. Então vou executar isso na minha máquina Dell Pro Max.

07:22 com uma RTX Pro 6000 aqui. Então, um grande agradecimento à Dell por patrocinar o poder computacional para este vídeo. Um dos desafios que você precisa considerar, seja qual for o lugar escolhido para executar isso, é que as capturas de tela preenchem muito rápido o cache KV. Então, você precisa garantir que está deixando bastante espaço livre especificamente para isso. Certo, se olharmos os benchmarks aqui, veremos que eles estão comparando tanto a versão densa de 27B quanto a versão de mistura de especialistas, além do Qwen 3.8 27B original, junto com vários

07:53 modelos que talvez estivessem na fronteira há uma ou duas semanas. E preciso dizer que me solidarizo com muitas dessas empresas quando elas fazem o benchmark do que estão prestes a lançar e, então, os laboratórios de fronteira lançam algo completamente novo. Mas, sinceramente, acho que os modelos de fronteira servem mais como referência do estado da arte para esse tipo de coisa. Obviamente, não podemos executar nenhum deles localmente e, claro, se você pagar pelo uso da API com imagens nesses modelos, isso pode ficar muito caro muito rápido. Então, se olharmos para coisas como OS World, veremos que eles não estão tão atrás dos modelos de fronteira.

08:25 Na verdade, dá para ver que o 27B aqui está um pouco à frente do que agora é o antigo modelo GPT-5.5. Agora, quanto ao OS World, sim, eles estão bem atrás. Mas, de novo, não olhe apenas para as pontuações de precisão aqui. Preste bastante atenção aos custos, certo? Porque, embora Opus 5.5 e Astra estejam no topo, dá para ver que o custo de executá-los é cerca de sete vezes maior que o do 27B. Outro grande ponto que eu destacaria nos benchmarks aqui é que é

08:55 realmente fascinante ver o quanto o modelo de mistura de especialistas fica para trás. Por exemplo, quando olhamos para OS World, vemos que o 35B MoE tem uma pontuação inferior à metade da do modelo denso de 27B. E, embora a diferença não seja tão dramática nos outros benchmarks aqui, há uma vantagem clara em usar o modelo denso para esse tipo de tarefa. E acho que faz mais sentido quando comparamos os parâmetros ativos: estamos comparando 27 bilhões com 3 bilhões, e parece mesmo que, para imagens,

09:27 e para obter representações de imagens, o modelo denso de 27 bilhões simplesmente faz isso muito melhor. Certo, então, só para explicar rapidamente como eles treinaram o modelo para escolher uma latente como esta, porque essa é uma das partes que acho realmente interessante. A H Company criou o que chama de fábrica de tarefas agentivas. É um conjunto de pipelines que cria ambientes interativos e tarefas que podem ser verificadas automaticamente. Isso inclui coisas como capturas de tela de sites reais, uso de software open source por meio de aplicativos web específicos, servidores MCP específicos e até ambientes de desktop.

10:02 E o interessante é que alguns desses ambientes são meio híbridos. Isso significa que você pode pegar o estado de algo, como um site, por exemplo, e realizar a tarefa de duas maneiras: pela interface gráfica, olhando para o site por meio de capturas de tela, ou talvez usando MCP ou algum código para procurar algo no site. Assim, em muitas dessas tarefas diferentes, o modelo pode resolver a tarefa clicando ou chamando uma ferramenta. E o aprendizado por reforço atua sobre tudo isso e recompensa o modelo pelo que funcionar melhor naquela situação.

10:36 É assim que o modelo aprende que clicar em cinco menus talvez seja a maneira mais lenta, quando há uma API disponível. E também o contrário: talvez usar uma captura de tela para obter várias informações detalhadas, quando não há uma API detalhada disponível, seja a melhor maneira. O RL reforça isso e torna o modelo melhor em coisas desse tipo. O treinamento em si é fine-tuning supervisionado com cerca de 127 bilhões de tokens. Depois, são criados dois especialistas distintos de RL, que são reunidos novamente em um único modelo. Além disso, outra coisa que fizeram foi reconstruir o próprio

11:09 harness para que ele se adequasse a isso. Assim, eles puderam identificar o que falhou e pedir aos engenheiros que analisassem esses casos e considerassem como poderiam melhorar o harness para lidar com esse tipo de saída do modelo. É interessante que alguns dos maiores ganhos tenham vindo de uma memória confiável, capaz de acompanhar centenas de etapas e relacioná-las de uma maneira talvez melhor, porque o modelo foi treinado nessas três vias diferentes. Certo. Essa mesma receita foi usada para o modelo denso Qwen 3.8, o 3.6 MOE

11:40 e o Nemotron. Acho que está bem claro que o foco deles aqui é um pipeline de pós-treinamento realmente forte, em vez de muitas personalizações para qualquer modelo específico. Eles estão se preparando para o lançamento dos modelos Qwen4, e a Alibaba confirmou recentemente que haverá um Qwen 4 27B. Então, acho que todo mundo vai estar de olho nisso. E dá para imaginar um Holo 4.5 ou 5 que aprimore ainda mais tudo isso. Certo, então vamos dar uma olhada rápida e ver uma demonstração de como isso funciona.

12:11 Certo, dá para ver aqui que isso vai usar o componente de interface gráfica. Basicamente, ele está acessando a página do Hugging Face. Demos a tarefa de abrir a coleção Holo-4 e listar as precisões dos modelos. E dá para ver que, de fato, ele acessou diferentes elementos. Está encontrando as coleções, a coleção Holo-4, e vai continuar fazendo isso por um bom tempo. Mas você vai notar, na parte inferior, que tudo o que está acontecendo aqui é uma tarefa de interface gráfica.

12:42 Então, vou parar esta execução e vamos ver algumas das outras. Criei uma interface que usa um harness pequeno no backend. Nesse harness, podemos fornecer um MCP, se o ativarmos. Podemos dar acesso a ferramentas, acesso a código e assim por diante. Vou tentar executar a primeira tarefa. Aqui, basicamente, há um painel de administração fictício, que está sendo executado localmente. Dá para ver que há uma lista de pedidos. E, neste caso, ele está usando a interface gráfica.

13:13 Desativamos o MCP, então ele não tem como usar nenhum MCP aqui. Portanto, precisa literalmente navegar pela página e buscar as informações. Agora, ele está obtendo essas informações e, depois, usando código para organizar tudo. Certo? Dá para ver que, por fim, ele retorna a resposta. Neste caso, vemos que ele basicamente baixou o arquivo CSV. Depois, executou Python no arquivo CSV e nos deu a resposta. Ele começou pela interface gráfica.

13:44 Se olharmos na parte inferior, veremos que ele executou uma, duas, três etapas de interface gráfica, depois passou para o código e, então, retornou a resposta final. Agora, vamos fazer exatamente a mesma coisa, mas ativando o MCP. O MCP está ativado, então ele não precisa acessar todos aqueles elementos da interface, certo? Ele pode simplesmente dizer: “Temos uma ferramenta, exportar pedidos”, e prosseguir. Basicamente, vai obter o mesmo tipo de resultado, e as respostas também aparecem no final, aqui, conforme ele avança.

14:18 E dá para ver que, obviamente, foram bem menos etapas e nenhuma delas envolveu a interface gráfica neste caso. Basicamente, foi a ferramenta, depois o código e, em seguida, a saída. Se quiséssemos fazer tudo usando vários cliques ao longo do processo, dá para ver que ele clicou em pedidos vencidos e clicou para exportar o arquivo CSV. Mais uma vez, tivemos várias etapas de interface gráfica e, depois, ele executou o código antes de voltar ao modelo e nos dar a resposta final. Aqui está um exemplo que preparei em que ele está usando apenas código.

14:50 Então, ele consegue percorrer um arquivo, extrair diferentes informações, reconciliar as duas exportações de pedidos diferentes aqui e listar quaisquer divergências que encontrar. E o principal a notar aqui é que, desta vez, ele está apenas usando código. Basicamente, está juntando tudo isso e, em algum momento, vai nos apresentar o resultado final. E dá para ver que, na verdade, estamos enfrentando alguns problemas no ambiente, e ele acabou encontrando alguns problemas por causa disso. Dá para ver que, por fim, ele começa a usar Pandas, e então

15:20 finalmente obtemos a resposta. Isso levou bastante tempo, não é? Foram 1 minuto e 37 segundos. Obviamente, cortei algumas partes para a gravação. Mas dá para ver que ele executou cada uma dessas etapas, e essa é a ideia toda deste modelo: ele pode optar por simplesmente usar a interface gráfica, usando apenas a interface gráfica do usuário, e então processar essas capturas de tela e descobrir onde clicar na interface. Ele pode usar código, como vimos neste exemplo, e pode usar ferramentas como

15:51 o MCP, se estiverem disponíveis e ele as encontrar no repositório de ferramentas que é disponibilizado ao modelo, etc. Certo, para terminar, outra coisa legal que eles publicaram são as trajetórias do que está acontecendo aqui. Então, você pode acessar e ver como essas trajetórias realmente se desenrolaram. Agora, a grande pergunta para encerrar é: você deveria usar isso? Bem, certamente acho que vale a pena conferir. Infelizmente, eu diria que o maior problema é a licença. Embora tenha pesos abertos e você possa conferir, a licença é, na verdade, não comercial, certo?

16:22 Embora o modelo-base Qwen por baixo dele esteja sob a licença Apache 2.0, e embora os modelos Holo 3.1 deles estivessem sob a licença Apache 2.0, infelizmente este não se enquadra nessa categoria. Então, você pode experimentar, criar protótipos e fazer pesquisas com ele. Mas, se quiser lançar um produto, vai ter que usar a API da H ou entrar em contato diretamente com eles. Uma coisa pela qual acho que eles merecem algum crédito é que todas as trajetórias por trás das pontuações de benchmark que publicaram estão abertas. Então, você pode analisá-las e aprender bastante com elas se estiver

16:56 tentando criar seu próprio modelo para fazer isso. Para mim, a conclusão é que os agents que escolhem entre clicar, programar, chamar ferramentas, usar interfaces gráficas e coisas desse tipo são o rumo que as coisas estão tomando. Holo-4 nos mostra que essa capacidade vem desses ambientes de treinamento, vem do aprendizado por reforço e vem, basicamente, de adaptar o modelo para trabalhar também com um harness específico. Isso também nos mostra algumas coisas interessantes sobre a diferença entre modelos densos e MoE. Enfim, como sempre, deixei os links para o blog e para os modelos

17:27 e até mesmo para o visualizador de trajetórias na descrição. Me contem nos comentários o que vocês acham. Estou muito curioso para saber quantos de vocês estão realmente usando agentes para interação com o computador ou agentes de navegador, coisas assim, em vez de se limitarem a ferramentas, código, MCPs, APIs e coisas desse tipo. Já falei de alguns agents de navegação na web no passado e certamente me apresentaram vários deles, mas nem sempre me convenceram de que são realmente úteis em comparação com usar apenas um modelo comum e um harness personalizado. Enfim, como sempre, se você achou o vídeo útil, clique em gostei e inscreva-se, e

18:00 falo com vocês no próximo vídeo. Até mais.

Transcrição original

[00:00] Okay, so imagine you’ve built an agent that can use a computer. It looks at a screen, it can click, it can type, but now you drop that into a server with no screen. it’s just gonna get stuck. It’s got nothing to look at. It was built for visual kinds of things. If you flip it around, if you’ve got an agent that’s great at calling tools and APIs, but you then ask it to pull a report out of some old app or something like that, that has no API, it’s also stuck, right? It doesn’t have the ability to look at the UI. It doesn’t have the ability to actually act on that and so far up

[00:32] until now, people have generally tended to make models to do one side of that line or the other. So either being able to do the visual kind of stuff, and act on things, click on things, that kind of thing, or being able to actually do the API related stuff, the non-visual kind of stuff Unfortunately though, the problem is that real work doesn’t stay on one side or the other of that line more and more as people using agents to do a whole variety of different tasks, it often means that it’s gotta click through some legacy UI.

[01:03] It’s then gotta be cleaning a CSV file. It’s then gotta be posting it to Slack or to some other API And right now, the way that people have sort of handled this is you tend to have lots of different models. You chain models together. So you’ve got one visual model that you force everything as screenshots. You’ve got another model which is doing your orchestration and dealing with MCPs, et cetera So in this video, I wanna talk about a model from a company in Paris called H Company and they’re the lab behind Holo Models. They’ve just released Holo4, And that’s what I want to go through here.

[01:34] This is basically an open weight model trained to click, to write, to run code, to call MCPs, to do API tools, et cetera. And most importantly, to be able to orchestrate and choose between those actions as it goes along And I kind of feel there are two really interesting parts here. There’s the model itself, which we’ll look at, but the other part is how you train a model to make that choice and I should point out that they’ve actually got a family of Holo models here. So we’ll have a look at those. We’ll have a look at how they fit into an agent, how they’re built, and

[02:06] also perhaps where they’re falling short, et cetera Alright, so let’s recap what an actual agent loop is you basically give the agent a task. The model looks at what’s going on and it decides on one action, right? Then the harness, which is just the code around it, executes that action. It does the click, it runs code, it calls the tool. And then obviously it captures what happened, whether that’s a new screenshot, whether that’s just some return from an API, and it feeds that back into the model along with the memory of the previous steps around it

[02:40] And this loop just goes round and round, right? This is fundamentally the base of what’s going on here I guess the key thing here is that the model itself never actually touches anything. It only decides. the harness actually does all the doing And that matters more and more nowadays. When we look at benchmarks, we see that models can score really differently depending on the harness that are actually running with it Now for Holo 4, they’ve actually optimized this to work with three main lanes of sort of actions here. The first are GUIs, right?

[03:10] Graphical user interfaces. The model looks at a screenshot, then says, “Click here, type this,” and you can kind of think of it as the agent using the computer a web device, a browser the way that you do it. it works on anything that a human can use, but it’s gonna be slow, and it can often break when someone moves a button or changes the UI, et cetera. The second lane is code. So the model writes a script, runs it in a sandbox or a shell, and it gets an output back. That’s fast, that’s precise, but it only works when you can actually write some

[03:42] software to do the particular task, right? it can’t just easily write a Python code to know which button to press on a visual output. the third lane relates a bit to the second lane, but this is where you’ve got tools. So MCP servers, APIs, that kind of thing. The model calls a function and it gets back structured data. and in many ways this is the most reliable of the three here. but obviously the challenge is it only works if there is an MCP or an API or some kind of tool that is actually gonna do what you want it to do now

[04:14] the challenge has been for many people running agents, especially local agents, that these three different lanes often require either different models or different setups with your agent harness. If you’ve got something that’s doing screenshots, that’s going to eat, a huge amount of context compared to just JSON files or a few lines from a terminal output, et cetera and for exactly that reason, most people have tended to ignore running something that could actually do visual stuff just because it’s often not practical to do locally and going back to the example I talked about in the intro,

[04:47] something like exporting a report from some kind of legacy app through a GUI. you want it to go through an e-commerce site and find different things that are not available through their API then you wanna take that, clean it up for a CSV file with a Python script, and then post it to an API like a Slack, et cetera is really the type of goal that Holo-4 is sort of working on here. They talk about this as being working across interfaces it’s not just that it supports MCP as a feature, it’s trained to pick the right lane

[05:17] between those images, code, or tools And in many ways, that’s what sets it apart. The earlier Holo models that they already trained were using function calling. The big difference here, though, is that they’ve trained this model to do all three together Graphical user interfaces is a first-class option, code is a first-class option, and tools are a first-class option. They’re not just add-ons now the big question for me was Would you use this as your only model or alongside of another one? and the answer is perhaps kind of both.

[05:48] H runs all their benchmarks with Holo as the sole model, doing both the planning and the acting But you could also put this underneath a bigger model for doing orchestration or a different model if you wanted to do that H actually has their own harness and SDK called High Agents, which runs their hosted agents and can plug into things like Claude Code over MCP. so your main model plans the job and hands the screen-heavy work to Holo And I do think that may make sense for certain use cases where you just want

[06:19] to use this for doing the GUI stuff, for doing all the computer use agents kind of stuff All right, so let’s look at what each company actually shipped here. They’ve got two main models here, the Holo4 27B, which is a dense model, built on the Qwen 3.8 27B, and then they’ve also got the Holo4 35Ba3b, right? So that’s basically a mixture of experts model with 3B active. That one is actually still built on the Qwen 3.6 model Along with those two models, they’ve also released Holotron Nano, which is the same recipe for

[06:51] actually making the first two, but applied to NVIDIA’s Nemotron 3 Nano Omni there And so I made a video about that Nemotron 3 Nano Omni, a mouthful of a name there. but you can check that out if you want to see more of some of the reasons why people are using that smaller model. All right, so the weights for all of these are on Hugging Face. They’ve got a bunch of different quantizations, et cetera. They’ve also got their own API if you want to run it through that. The full bfloat 16-bit version here is 54 gigs. So I’m gonna be running this on my Dell Pro Max machine

[07:22] with an RTX Pro 6000 in here. So a big shout-out and thanks to Dell for sponsoring the compute for this one of the challenges that you wanna think about wherever you’re gonna choose to run this is that screenshots fill up your KV cache very fast. So you need to make sure that you’re leaving, plenty of headroom specifically for that Okay, so if we look at the benchmarks in here, we can see that they’re actually comparing, both the 27B dense version and the mixture of experts version and the original Qwen 3.8 27B, along with a bunch of

[07:53] models that were sort of frontier perhaps a week, two weeks ago. And I got to say, I feel for a lot of these companies when you basically benchmark what you’re about to release and then the frontier labs go and release something completely new but honestly, I feel like the frontier ones are more just for a guide of what sort of state of the art for this thing. Obviously, none of those we can run locally, and obviously if you’re paying for API usage with images on those, that can get very expensive very quickly So if we look at things like OS World, they’re really not that far behind the frontier models.

[08:25] In fact, you can see the 27B here is actually a little bit ahead of what now is the old GPT-5.5 model Now, when it comes to OS world, yes, they’re quite a bit behind But again, don’t just look at the accuracy scores here. Really pay attention to the costs, right? Because while Opus 5.5 and Astra are coming out on top, you can see that the cost of running those compared to the 27B is like seven times more here the other big takeaway I would say from the benchmarks here is it’s

[08:55] really kind of fascinating just how far behind the mixture of expert model is. So when we look at something like OS World, we can see that the 35B MoE is scoring less than half what the 27B dense model is and while it’s not as dramatic as that for the other benchmarks in here, there really is a clear advantage to using the dense model for these kinds of tasks. and I guess it makes more sense that if we compare sort of active parameters, we’re comparing 27 billion to 3 billion and it just does seem that for images,

[09:27] and getting representations out of images The 27 billion dense model just does that so much better here All right, so just quickly, how do they actually train the model to choose a latent like this? ’cause this is one of the parts that I find really interesting here. So H Company built what they’re calling an agentic task factory. It’s a set of pipelines that build like interactive environments and tasks that can be checked automatically. So things like screenshots of real websites, open source software using specific web apps, specific MCP servers, and even things like desktop environments

[10:02] and the interesting thing there is that some of those environments are kind of hybrid, meaning that you could take the state of that, for example, like a website or something, and you could actually do it through either a GUI way by looking at the website through screenshots, or you could do it perhaps by an MCP way or by using some code to look for something on the website. so over many of these different tasks then, the model can actually solve the task by clicking or by calling a tool And then reinforcement learning sits over all of that and rewards the model for whatever works the best in that situation.

[10:36] so that’s how the model learns that clicking through five menus is perhaps gonna be the slow way, when there’s an API sitting there And also vice versa, that perhaps using a screenshot to get a bunch of detailed information when there is no detailed API available is going to be the way that the RL reinforces it and makes the model better at things like that. So the training itself is supervised fine-tuning on about 127 billion tokens. then creating two separate RL experts which get merged back into the one model on top of that, the other thing that they did was rebuild their actual

[11:09] harness to actually fit in with this They were then able to basically tag sort of what failed and have engineers review those that look at like how could we improve the harness to actually work with this kind of output from the model. so it’s interesting here that some of the biggest wins were a reliable memory that can track sort of hundreds of steps and it can relate those steps together perhaps in a better way because it’s been trained on these three different lanes Alright. So that same recipe was used for the Qwen 3.8 dense model, the 3.6 MOE

[11:40] and the Nemotron And I think it’s pretty clear that what they’re really focusing on here is a really strong post-training pipeline rather than over customizations for any one specific model. They’re really setting themselves up here for when the Qwen4 models come out and Alibaba has actually recently confirmed that there is going to be a Qwen 4 27B. So I think everyone’s gonna be looking forward to that. and you could imagine a Holo 4.5 or 5 that actually improves on all of this even more All right, so let’s take a quick look and demo at how this actually works

[12:11] Okay, so you can see here this is going to use the GUI element of this. So it’s basically going to the Hugging Face page. we’ve given it, the task of open the Holo-4 collection, and list out the model’s, precisions. And you can see that sure enough, it’s gone to, different elements there. It’s actually finding the collections, the Holo-4 collection, and it will go on, for quite a while to do this. But you’ll notice at the bottom that everything, going through here is, actually a GUI task in there.

[12:42] so let me just stop this one, and let’s look at some of the other ones. I’ve built a UI that’s using a little mini harness, at the back end, And that harness, we can give it an MCP if we turn it on. We can give it, access to tools, access to code, et cetera. So I’m gonna try going through, the first task. . so here it’s basically got a made-up, admin panel so that this is running locally. You can actually see that this is a list of orders there. and it’s using the GUI in this one.

[13:13] We’ve got the MCP turned off, so it doesn’t have the ability to use the MCP, anything here. So it’s literally having to navigate that, webpage and go through and get stuff. Now, it’s getting it, and then it’s actually using code, to put it all together. All right? So, you can see finally it comes back with the answer out. In this case, we can see that it basically downloaded the CSV file. It then ran Python on the CSV file, it then gave us our answer back. Now, it started out with the GUI there.

[13:44] If we look at the bottom, we can see it went one, two, three GUI steps, then it went to code, and then it gave us our final answer out. let’s look at the exact same thing though now if we give it an MCP on. So now we’ve got, the MCP is actually on, so it doesn’t need to go to all the UI stuff now, right? It can actually just go and say, “Hey, we’ve got a tool, export orders,” and it will go through. it’s going to basically get, the same, kind of thing, and we’ve got the, answers out at the end, as well here, going through this.

[14:18] And you can see that obviously that was a lot less steps, and none of them were GUI in this case. It was basically just a, the tool, and then code and then output there If we wanted to basically just do everything, where it’s, doing various clicks as it goes through, you can see it did a click on the overdue, it did a click on the export CSV file. Again, we had multiple GUIs there, and then it’s running code before it’s going to go back to the model and give us our final, response out. here’s an example that I put together where, it’s basically now just using code.

[14:50] so it’s able to go through a file, pull out different information, reconcile the two different order exports here, and list any mismatches that it’s finding in there And the main thing, to notice here is that it’s just using code this time. it’s basically just putting that all together, and then at some point here, it’s gonna give us our final result out. And you can see actually We’ve got some environment issues going on there where it’s actually ran into some, problems with that You can see that eventually it’s starting to use Pandas, and then

[15:20] finally we get our answer out. Now, it took quite a long time there, right? That was, a minute 37 seconds. I’ve obviously cut some bits out for the recording. but you can see that it’s done each of these steps, and that’s the whole thing with this model is that It can choose to just do the GUI and use just the graphical user interface and then process, those screenshots and then work out where to actually click, on the UI. It can do the code like we’ve seen in this one, and it can use, tools like

[15:51] the MCP, if they’re available and it sees those in the tool repository going into the model, et cetera. Okay, so just to finish up, another cool thing that they’ve published are the actual trajectories, of what’s going on in here. So you can actually come in and have a look at how these trajectories actually went Now the big question to sort of finish up on is should you use this? well, I certainly think it’s worth checking out here. Unfortunately, the biggest issue with this, I would say, is the license. that while it’s open weight and you can check this out, this is actually a non-commercial license, right?

[16:22] even though the Qwen base model underneath this is Apache 2.0, and even though their Holo 3.1, models were Apache 2.0, unfortunately this doesn’t fall into that category so you can experiment, you can prototype, you can do research with this. But if you want to ship a product, you’re gonna have to go through H’s API or you’re gonna need to contact them directly Now, one thing that I do think they deserve some credit for is that every trajectory behind these benchmark scores that they’ve put out are actually open. So you could actually go through and learn a lot from those if you were

[16:56] trying to make your own model for doing this so for me, the takeaway here is that agents choosing between clicking, coding, calling, using GUIs, those sorts of things, is where things are heading. Holo-4 shows us that that ability comes from these training environments, comes from reinforcement learning, comes from basically incorporating the model to work with a specific harness as well it also shows us some interesting things about the dense versus MoE gap, in there Anyway, as always, I’ve put the links to the blog and the models

[17:27] and even the trajectory viewer in the description there let me know in the comments what you think. I’m really curious to hear from you guys how many of you are actually doing sort of computer use or browser agents, things like that versus just sticking to basically tools, code, MCPs, APIs, that kind of thing I’ve covered some browser use agents in the past and I’ve certainly been pitched a bunch of them, but I haven’t always been convinced how actually useful they are over just using a normal model and a custom harness. Anyway, as always, if you found the video useful, click like and subscribe, and

[18:00] I will talk to you in the next video. Bye for now