Por dentro do Project HydraFusion: orquestração de vários modelos no GitHub Copilot | demonstração | GitHub Checkout

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: Inside Project HydraFusion: multi-model orchestration in the GitHub Copilot | demo | GitHub Checkout · Canal: GitHub · 13:04 · Assistir no YouTube

Tópicos: Agentes de IA, Ferramentas de desenvolvimento com IA, Inferência e otimização de modelos

Resumo

Julia apresenta o Project HydraFusion, um recurso experimental do GitHub Copilot CLI que escolhe como executar uma tarefa usando diferentes modelos. O sistema pode usar um único modelo, escalar para outro modelo ou combinar modelos em um ciclo de elaboração e revisão, conforme a complexidade da tarefa. A demonstração compara padrões de execução e uso de créditos de IA, destacando a eficiência de tokens observada em testes. A equipe também discute transparência, possíveis vieses na exibição dos modelos usados e planos para disponibilizar o recurso no app do GitHub Copilot e no VS Code.

Pontos-chave

O Project HydraFusion está disponível como research preview no modo experimental do GitHub Copilot CLI.
A pessoa usuária envia uma tarefa sem precisar escolher manualmente o modelo ou o padrão de execução.
O padrão single escolhe um modelo para executar a tarefa diretamente.
O padrão cascade começa com um modelo e pode escalar para outro se a resposta exigir mais capacidade.
O padrão critique cria um ciclo de elaboração, revisão e revisão do plano entre modelos.
A demonstração compara o uso de créditos de IA e a eficiência de tokens entre HydraFusion e outros modelos.
A interface mostra o padrão escolhido e os créditos usados, mas ainda não revela quais modelos foram acionados.
A equipe pretende melhorar a transparência sem induzir vieses sobre os modelos selecionados.
Os próximos passos incluem levar o recurso ao app do GitHub Copilot e ao VS Code, além de avançar para uma public preview.

Capítulos

Início	Capítulo	Resumo
00:00	Apresentação e acesso ao HydraFusion	Julia explica como ativar o modo experimental no CLI e selecionar o Project HydraFusion.
03:09	Padrões de execução	A conversa apresenta os padrões single, cascade e critique e explica quando o sistema pode usá-los.
06:17	Demonstração e eficiência de tokens	Os exemplos mostram os padrões cascade e critique e comparam o uso de créditos de IA.
09:57	Transparência e próximos passos	A equipe aborda a exibição dos modelos usados, os planos de expansão e a coleta de feedback.
12:01	Como testar e enviar feedback	O vídeo recapitula como encontrar o research preview e convida as pessoas a compartilhar opiniões.

Citações

Você pode simplesmente se concentrar na tarefa que quer executar. — 00:00

É só enviar seu prompt. O HydraFusion cuida do resto. — 05:12

Você se concentra na tarefa, e o Copilot e o HydraFusion cuidam do restante. — 09:57

Um prompt, e ele escolhe o padrão de que você precisa. — 12:33

Conceitos e entidades

Project HydraFusion (ferramenta): Recurso experimental que seleciona padrões de execução e combina modelos para atender a tarefas no GitHub Copilot.
GitHub Copilot CLI (ferramenta): Interface de linha de comando do GitHub Copilot onde o Project HydraFusion está disponível em modo experimental.
GitHub Copilot (ferramenta): Produto de assistência à programação do GitHub mencionado como ambiente para o Project HydraFusion.
VS Code (ferramenta): Editor no qual a equipe planeja disponibilizar o Project HydraFusion.
single (conceito): Padrão que escolhe um modelo para executar a tarefa diretamente.
cascade (conceito): Padrão que pode escalar a tarefa de um modelo para outro mais capaz.
critique (conceito): Padrão de execução em que modelos elaboram, revisam e refinam um plano em etapas.
Julia (pessoa): Convidada que apresenta o Project HydraFusion e explica seus padrões de execução.
Opus 5 (modelo): Modelo citado na demonstração como participante de execuções e revisões.
Fable 5.1 (modelo): Modelo comparado com HydraFusion e Opus em exemplos de uso de créditos de IA.
Luna (modelo): Modelo usado em uma etapa inicial de elaboração no exemplo de execução cascade.
Soul (modelo): Modelo usado para conferir e, em seguida, escalar uma tarefa na demonstração de cascade.

Tradução completa (pt-BR)

00:00 Qual é o modelo mais recente que devo usar? Como devo usá-lo? Eles não precisam se preocupar com qual modelo escolher. Basicamente, podem se concentrar apenas na tarefa que querem executar. Julia, seja bem-vinda ao GitHub Checkout. Muito obrigada por me receberem. Estou muito animada por estar aqui. >> Estou muito animado para conversar com você hoje, porque há muito tempo me pergunto como essas coisas surgem — e quando digo “essas coisas”, quero dizer: o projeto de que vamos falar hoje é considerado um modelo. Acho que será como nosso primeiro contato com essa tecnologia, mas ela também é

00:31 uma tecnologia que temos usado com o GitHub Copilot para ajudar nossos usuários a escolher modelos melhores e serem mais eficientes ao trabalhar com o Copilot. E você vai ter que nos explicar o que é o Project HydraFusion e como ele surgiu. Vamos começar do início. >> No momento, ele está disponível na CLI, em caráter experimental. Então, ao testá-lo, primeiro execute /experimental. Depois de habilitar isso, basta executar

01:02 /models. Agora, você consegue encontrar o HydraFusion Research Preview na seleção de modelos. É muito simples. Basicamente, você pode usá-lo como qualquer outro modelo: basta dar a ele uma tarefa, qualquer tipo de prompt que você tenha. Ele vai começar a executá-la, mas escolherá o padrão certo para você. Assim, você não precisa se preocupar com a dificuldade da tarefa nem com coisas desse tipo. Ele vai executá-la e começar a implementá-la para você.

01:33 >> Você poderia nos falar um pouco sobre a diferença entre isso e o Auto? Nós também temos usado a seleção automática de modelos. Essa é a tecnologia subjacente à seleção automática de modelos ou é algo completamente diferente? Originalmente, acho que no começo deste ano, introduzimos o que consideramos a versão 1 do Auto, que era muito orientada pela capacidade disponível. O usuário digitava um prompt de texto e, com base no que sabíamos sobre onde havia melhor disponibilidade e capacidade, encaminhávamos para

02:05 o modelo que, naquele momento, parecia ser o mais adequado. Mas percebemos que o encaminhamento baseado na capacidade é uma das coisas que as pessoas levam em consideração, mas talvez não seja a opção ideal, porque, no fim das contas, tudo depende da sua intenção. Foi por isso que, em maio de 2026 — neste ano —, lançamos no Auto o que estamos chamando de Hydra. Já analisamos a intenção e, em vez de apenas encaminhar para o modelo com maior capacidade disponível, pontuamos sua

02:38 intenção de quatro maneiras diferentes. Dependendo da pontuação mais alta, o problema de otimização já se revela. O HydraFusion leva isso ao próximo nível: em vez de você escolher apenas um modelo e pronto, estamos introduzindo o cascade critique, que envolve mais interação entre esses modelos. Também estamos vendo muitos ganhos de eficiência — ou de eficiência de tokens — em geral, porque não dependemos apenas de um modelo. Dependemos de vários

03:09 modelos diferentes e, dependendo da sua tarefa, podemos escolher a estratégia de execução certa para você. Muitos de nós já fazíamos isso manualmente, certo? Usávamos certo modelo para certa tarefa porque tínhamos a impressão de que ele a executaria melhor. Mas nem todas as tarefas são iguais. Você poderia nos explicar como funciona esse processo de tomada de decisão que leva à seleção do padrão? Adoraria entender melhor. >> Há três maneiras de fazer isso. Uma se chama single, outra

03:39 se chama cascade e a outra, critique. Single é a maneira mais direta de o HydraFusion resolver sua tarefa. Imagine que você digita algo, ele escolhe um modelo e o executa. Pronto, aqui está a resposta. Ele escolheu esse modelo e temos confiança de que essa é a resposta mais eficiente em termos de tokens — ou a mais eficiente —, mas também a mais correta. Depois, temos as outras duas opções, que consideram que algumas tarefas podem ser mais complexas. É aí que podemos

04:10 encaminhar a tarefa para cascade ou para critique. Pense no cascade assim: você dá a tarefa que pretende realizar a um modelo. Ele tenta executá-la pela primeira vez e, ótimo, se a resposta estiver correta e tivermos bastante confiança de que está boa, perfeito: seguimos por esse caminho. Mas, se ainda não chegamos lá e achamos que é necessário outro caminho, vamos encaminhá-la para um modelo mais potente. Assim, usamos outro modelo, que entra em ação e ajuda a executá-la. Perfeito.

04:41 Ele produz sua própria resposta. E a terceira opção, a mais complexa, é chamada critique. Nesse caso, há um pouco de interação entre os modelos: temos um modelo autor e um modelo crítico, que se ajudam a elaborar um plano preliminar antes de passar à execução e ao algoritmo de resposta, tentando oferecer aos usuários finais a resposta ideal. E

05:12 o interessante é que vemos usuários e desenvolvedores já usando padrões desse tipo há anos, desde que começamos a introduzir novos modelos. >> Para o usuário, não é preciso selecionar mais nada. Basta inserir o prompt, e pronto. O HydraFusion cuida do resto. >> Isso mesmo. Tenho até uma demonstração rápida aqui. Bem à direita, você pode ver que escolhemos o HydraFusion para a nossa intenção e estamos comparando-o com Fable 5.1 e Opus. E, como

05:46 você pode ver, o Hydra escolheu single como estratégia de execução. Só queria esclarecer que todas essas são a mesma tarefa. Basicamente, estamos dando a mesma tarefa e o mesmo prompt a esses três modelos diferentes, e queríamos ver como eles se sairiam em termos de eficiência de tokens. É por isso que, aqui embaixo, você pode ver quantos créditos de IA estão sendo usados. Como outro exemplo, vamos fazer isso de novo. Vamos dar a eles outra tarefa. Mais uma vez, ele escolhe single aqui

06:17 e escolheu single como a estratégia de execução adequada. Mais uma vez, você pode ver os créditos de IA usados pelo Opus, pelo Fable, pelo Fable 5.1 e pelo HydraFusion. E, de novo, o HydraFusion está entre os melhores em eficiência de tokens. Para demonstrar o padrão de execução cascade: primeiro, um modelo foi escolhido. Depois, foi necessário encaminhar a tarefa para um modelo mais complexo. Para elaborar o rascunho, foi usado Luna. Em seguida, Soul foi usado para verificar, e depois a tarefa foi encaminhada novamente

06:47 para Soul, porque precisávamos de um pouco mais de potência do que Luna conseguia nos oferecer. No fim das contas, o HydraFusion ainda é o mais eficiente em termos de tokens, se compararmos com Opus e Fable 5.1. E o último padrão de execução, que já mencionamos, chama-se critique. Ele definitivamente tem a maior taxa de aprovação. É uma das estratégias de execução mais complexas que poderiam ser escolhidas, porque aqui usamos Opus 5 para elaborar o rascunho. Depois, usamos

07:20 outro modelo muito potente, o 5.6 Soul, para revisá-lo. E, por fim, na última etapa, o plano é revisado, e aqui usamos Opus 5 novamente. Há um pouco de interação entre eles. O motivo é que detectamos que essa é uma tarefa muito complexa. Por isso, precisávamos de um pouco mais de potência no geral. Ou, considerando o conjunto, o HydraFusion está mostrando ganhos de eficiência de tokens realmente empolgantes, sabendo que, na última tarefa, precisávamos

07:51 para tomar a decisão de escolher o Critique, para alternar entre os dois modelos muito fortes. Mas tínhamos tanta confiança em escolher esses dois modelos mais fortes que estávamos dispostos a levar em consideração o pequeno aumento na eficiência de tokens e nos créditos, para garantir que a resposta recebida pelos usuários finais fosse a certa, aquela que eles querem. Mas, no geral, se você pensar em todas as diferentes tarefas que pode

08:22 fazer, o HydraFusion ainda é uma das opções que apresenta um ganho muito alto de eficiência de tokens. >> Depois que as tarefas são executadas, dá para ver qual padrão foi selecionado pelo HydraFusion? >> Duas coisas. Sim, já mostramos qual padrão foi escolhido. E, se você se lembra da minha demonstração lá no começo, deu para ver que o Single foi o escolhido. Então, mostramos qual padrão queríamos mostrar. E também dá para ver, no final, os créditos de IA usados. O que ainda não estamos

08:55 mostrando, e é algo que estamos debatendo agora, é se queremos mostrar às pessoas quais modelos foram usados. O motivo é este — e foi por isso que, originalmente, não começamos mostrando isso: fizemos algumas experiências e, se colocarmos um determinado modelo diante dos usuários finais, pode haver um viés. Seja qual for o modelo que escolhermos, temos essas opiniões bem consolidadas sobre os modelos mais recentes, certo? Phi-1, Opus 5. Sabemos que são modelos muito

09:27 fortes, mas também muito caros. Então, não queríamos influenciar os usuários ao talvez nos verem escolhendo Luna, que ainda é um modelo muito capaz, mas sabíamos que, naquele momento, para elaborar seu plano, Luna era perfeitamente adequado. E não queríamos que as pessoas vissem um modelo específico e formassem certas opiniões. Por isso, tomamos a decisão de design de não mostrá-lo. Sabemos que precisamos trazer mais informações para nossos usuários finais, porque

09:57 também gostamos de transparência, certo? Sim. Então, precisamos encontrar o equilíbrio certo entre o que queremos mostrar e evitar criar certos vieses nos usuários finais. >> Agradeço por isso. No fim das contas, o melhor é que você, como desenvolvedor, não precisa se preocupar com todo esse processo e toda essa complexidade. Você só se concentra na tarefa em questão: continue desenvolvendo e deixe o Copilot e o HydraFusion pensarem. Todas essas decisões em camadas, muito complexas, que acontecem nos bastidores, podem ser tomadas por você. Então, adoro isso. E o que

10:29 vem a seguir? Quais são os planos para o projeto? Primeiro, sempre recomendo conferir nosso blog. Ele tem muito mais detalhes, caso isso seja algo do seu interesse. Ele também explica como fizemos os benchmarks antes do lançamento, e temos uma publicação externa para discussão. Então, sempre incentivo as pessoas a participarem e responderem por lá, dizendo o que acham, especialmente enquanto estamos fazendo iterações. Quais são as duas coisas principais em que estamos trabalhando agora? A grande prioridade é a adoção, mas também queremos disponibilizá-lo para

10:59 mais desenvolvedores que não usam necessariamente apenas a CLI. Por isso, queremos disponibilizá-lo no aplicativo GitHub Copilot e também no VS Code. Isso está sendo desenvolvido agora. E também já falamos sobre melhorias de UX, certo? Precisamos encontrar o equilíbrio certo entre o que queremos mostrar aos usuários finais. Queremos oferecer transparência e visibilidade a todos vocês sobre o que está acontecendo, mas também garantir que não introduzamos esses vieses nem mostremos coisas que aprendemos nas experiências e que

11:30 não queremos necessariamente mostrar aos usuários finais, para não influenciar suas opiniões. Mas sabemos que definitivamente há algumas coisas em que precisamos trabalhar. O próximo passo é a prévia pública, o que também é muito empolgante. Ainda não sabemos quando, mas definitivamente já está entre nossas prioridades. >> Agradeço por isso. E, escutem, é por isso que precisamos que vocês, nossos usuários, ativem o recurso. Basta executar /experimental on. Vocês precisam ativar o modo experimental na CLI para habilitá-lo e, em seguida,

12:01 /model, que vai mostrar a lista habitual de modelos, mas vocês poderão ver o Project HydraFusion nela. >> Seja lá no que estiver trabalhando agora, essas são as tarefas que queremos atender. No fim das contas, queremos criar recursos e funcionalidades para as suas tarefas do dia a dia. Então, é só experimentar e nos contar como está funcionando para vocês, especialmente em relação à eficiência de tokens, pois foi isso que observamos nos nossos evals offline, mas também em muitos experimentos e testes online, feitos por mim e por toda a equipe de pesquisa. Então, sem vieses: divirtam-se

12:33 com ele e contem para nós o que acham. >> Incrível. Muito obrigada, Julia, por apresentar o Project HydraFusion para nós. Mal posso esperar para ver o que vem a seguir. E essa foi a primeira olhada no Project HydraFusion. Um prompt, e ele escolhe o padrão de que você precisa: Single, Cascade ou Critique, dependendo da tarefa em questão. Se quiser experimentar, ative o modo experimental na CLI e execute /model para encontrar a prévia de pesquisa. E, por favor, não se esqueça de deixar seu feedback. Julia e a equipe leem

13:04 a publicação externa para discussão todos os dias. Então, se tiver algo interessante, conte para eles por lá. E não se esqueça de se inscrever neste canal para não perder nenhum lançamento ou atualização de recursos. Envie as alterações e vejo vocês no próximo lançamento.

Transcrição original

[00:00] what’s the latest model I should be using? How should I be using it? They don’t have to worry about what model to pick. You can essentially just focus on the task you want to execute. Julia, welcome to GitHub Checkout. Thank you so much for having me. Super excited to be here. >> I am so excited to talk to you today because I have long wondered how these things come to be and what I say these things. The project we’re going to be talking about today is considered a model. I guess it will be like our first dip into that technology, but it’s also

[00:31] a technology that we’ve been using with GitHub copilot uh to help our users make better model selections and be more efficient when they’re working with Copilot and that is you’ll have to explain to us what project hydroofusion is, how it came to be. Let’s start from the beginning. >> Right now it’s available in the CLI. It’s under experimental. So make sure whenever you’re testing it, you’re first doing SAS slash experimental. And once you’ve enabled this, you can just do

[01:02] slashmodels. And now you’re able to find hydrofusion research preview in your model selection. And it’s very easy. You can essentially just use this as any other model where you just give it a task, any kind of prompt that you have. It will then go and start executing it but it will pick the right pattern for you because you don’t essentially have to worry about it how difficult you task it any of these kind of things and then it will go and execute and start implementing for you.

[01:33] >> Could you tell us a little bit about the difference between this and auto because we have been using auto model select as well. Is this the underlying technology for auto model select or this is something completely mobile? So originally I think at the beginning of this year we introduced what we consider auto version one and it was very much skew or capacity driven. So a user was typing in a text prompt and based on we knowing where the best availability the best capacity was. We were routing to

[02:05] that model in that moment that sounded or was the perfect fit. But we saw that capacity routing isn’t it’s one of the things that people are considering but it’s it might not be the perfect one because at the end of the day it is depending on your intent. So that’s where in May 2026, so this year we released within auto what we are calling hydra we already looking at the intent and rather than just routing to the best capacitywide model we are scoring your

[02:38] intent on four different ways to score it and depending on the highest score that’s where the optimization problem is already showing. Hydrofusion is essentially taking it to the next level rather than only you picking one model and that’s it. Now that’s where we are introducing cascade critique where it’s going to be more of a back and forth between these models and that’s where we also seeing a lot of these um efficiency or token efficiency gains overall because we are not just relying on one model. We are relying on a bunch of

[03:09] different models and depending on your task we can pick the right execution strategy for you. For a lot of us, we’ve been doing this manually, right? Like we’ve been sort of using this model for this because we have the impression that they will execute better for that task. But not all task are built equal. So if you could talk us through what that decision making that leads into the pattern selection works like I love to understand that better. >> So there are three ways how this could be done. One is called single, one is

[03:39] called cascade and one is called critique. single one is the most um straightforward way how hydro fusion will go and solve your task. Think of you typing something in and it will pick one model and it will go and execute and great here’s the answer and that it has chosen and we have the confidence that this is the most token efficient or efficient answer but also the most correct one. Then we have the two other one which we know sometimes tasks can be more complex and this is where we are

[04:10] either delegating to cascade or either delegating to critique. Cascade you can think of okay you’re giving one model this task that you have intended it’s trying it with its first um past and great if the answer is correct and we have a lot of confidence that this is this is looking good perfect this is the way where we will go but if you’re if you’re not there yet and if we are thinking hey there is another path that is needed we will be essentially escalating it to a stronger model so we

[04:41] are using another model to come in and it will help it go and execute it and perfect. It will come up with its own answer. And then the third one which is the most complex one which is considered or called critique. And here we will have a little bit of a back and forth between models where we have an author model and we have a critique model and they are helping each other to come up with a drafted plan before going into the execution and into the answer algorithm and trying to give our end users the perfect and great answer. And

[05:12] the interesting thing is we’ve seen these kind of patterns users or developers already been doing for like for years once we started introducing new and new models >> on the user. You don’t have to select anything else. Just setting out your prompt and that’s it. Hydro fusion takes care of the rest. >> That is correct. So I even have a short little demo with me. All the way on the right you can see we picked Hydra Fusion for our intent and um we are comparing it across Fable 5.1 and Opus and as you

[05:46] can see Hydra picked single as the execution um strategy. I just wanted you to know that all of these are the same task. So we are essentially giving all of these three different models the same task, the same prompt and we we were curious on what it goes and does on the level of token efficiency. So that’s where you can see all the way down here what are the AI credits that are being used as another example. So that’s why we are doing it again. We are giving it another task. Again it picks single here

[06:17] and it picked single as the right execution strategy. And again you can see the AI credits being used across Opus Fable Fable 5.1 and Hydro Fusion. And again hydrofusion here is one of the winners in ter terms of token efficiency. to demo the cascade execution pattern. First a model was picked. It then needed to escalate it to a more complex one. So here for drafting it used Luna. Then it used soul for checking and then it escalated it again

[06:47] to soul because we needed a little bit more power than Luna can were able to provide us. And at the end of the day hydrofusion is still the most token efficient one if you look across opus and just fable 5.1. And then the last execution pattern we already touched on which is called critiqued. This definitely has the highest fast radius. It’s one of the most complex um execution strategy that could be picked because here we have Opus 5 as the model that is using the drafting. It then uses

[07:20] another very strong model which is 5.6 soul to review it. And then all the way the last step is where it’s revising the plan and here it’s using opus 5 again. So there’s a little bit of a back and forth and the reason behind that is because we had detected that this is a very complex task. So we needed a little bit more power overall or if you think of the total Hydro Fusion is definitely showing the very exciting token efficiency gains that we were having knowing that with the last one we needed

[07:51] um to make uh the decision for picking critique um for going back and forth between the two very strong models. But we had so much confident in picking those two stronger models that we are we were willing to take the little bit of higher token um efficiency um credits here into consideration and to make sure that the answer our end users are getting is the right one that they want. But overall, if you think about all of the different tasks you can

[08:22] be doing, hydrofusion is still one of the ones that is showing um the very high token efficiency gain. >> Once the attacks are executed, like do you get to see what pattern was selected by hydro fusion? >> So two things. Yes, we are already showing what pattern has been picked. And if you remember my demo all the way at the beginning, we were able to see that single was the one that was picked. So we are showing what’s the pattern we wanted to show. And also you can see at the end the AI credits that were used for it. The things that we are not yet

[08:55] showing and that’s something we are debating right now is do we want to show people what models have been used and the reason behind that is and that’s why we originally didn’t go out with showing was we’ve done some experimentation and if we are putting a certain model in front of our end users there might be a bias whatever we have picked as the model we have these very high level um thoughts about the latest models, right? Fifi one, Opus 5. We know these are very

[09:27] strong ones, but also very costly ones. So, we didn’t want to bias users by maybe seeing us picking Luna, which is still a very capable model, but we knew in that moment for drafting your plan, Luna is totally um okay for using it. And we didn’t want to bias people seeing a specific model and having certain thoughts. So, that’s why we made the design decision to not showing it. We do know we have to bring in some more information for our end users because we

[09:57] do like transparency as well, right? Yes. So we have to find the right balance between what we want to show without putting certain biases towards our end users. >> I appreciate that. At the end of the day, the best part is that that top process and all of that complexity you don’t have to worry about as a developer. You just focus on the task ahead. keep building and let co-pilot and hydrofusion do the thinking and all these very layer very complex decisions that are happening underneath can do it for you. So I love that. So what’s

[10:29] coming next like what’s in the plans for uh the project? First of all I always recommend check out our blog. It has a lot of more details if this is something that you are interested in. It also explains on how we benchmarked right before our release and we do have an external discussion post. So I always encourage people to go in and respond there whatever you’re feeling especially while we are iterating on it. So what are the very two things that we are working on right now? The very big one is um for adoption but also get it into

[10:59] more hands of our developers who don’t necessarily just use the CLI. So that’s why we want to make it available in the GitHub copilot app but also in VS code. So this is being worked on right now. And then also we already talked about UX improvements, right? We have to find a right balance between what we want to shout show to our end users. We want to provide you all transparency and visibility and what is happening while also making sure we are not putting these biases in or things that we have learned from experimentation that we

[11:30] don’t necessarily want to show to our end users to put any kind of bias into their head. But we know there’s definitely some things we have to work on. The next step is public preview which is also super exciting. We don’t know yet when, but it’s definitely already on top of our minds. >> I appreciate that. And listen, this is why we need you um our users to go and enable it. So, all you have to do is to go slashexperimental on. You have to turn experimental mode on on the CLI to be able to enable it and then

[12:01] slashmodel, which is going to bring you to the normal list of models, but you’ll be able to see project hydroofusion there. >> Whatever you’re working on right now, these are the tasks we want at the end of the day. We want to build features, functionalities for your daily um drivers, for your daily tasks. So just go and try it and let us know how it’s working for you especially around token efficiency as this is one we’ve seen in our offline evas but also while doing a lot of online experiment and online testing me myself the entire research team. So no biases here just go have fun

[12:33] with it and let us know um your thoughts on it. >> Amazing. Thank you so much, Julia, for bringing project hydroofusion to us. I can’t wait to see what’s next. And that was your first look at project hydroofusion. One prompt end and it picks the pattern you need. Single cascade or critique depending on the task at hand. If you want to try it, turn on experimental mode in the CLI and run /model to find the research preview. And please don’t forget to leave your feedback. Julia and the team are reading

[13:04] the external discussion post every day. So if you had something interesting, please tell them there. And don’t forget to subscribe to this channel so you never miss another release or feature update. Push the changes domain and I’ll catch you on the next release.