Como executar sessões de agentes do GitHub Copilot em qualquer dispositivo | GitHub Copilot Day

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: How to run GitHub Copilot agent sessions across any device | GitHub Copilot Day · Canal: GitHub · 11:50 · Assistir no YouTube

Tópicos: Agentes de IA, Engenharia de software com IA, Ferramentas de desenvolvimento com IA

Resumo

Patrick Nicoletis apresenta o Agent Host Protocol (AHP), um protocolo que permite acessar runtimes de agentes em diferentes dispositivos e ambientes. Na demonstração, ele conecta o Copilot CLI a um host remoto em um servidor Linux doméstico e mostra como iniciar e compartilhar sessões entre clientes. O protocolo também pode integrar ambientes próprios ao Mission Control no GitHub.com, permitindo executar sessões em máquinas locais ou na nuvem. O repositório público e as especificações do AHP estão disponíveis para quem quiser explorar a tecnologia.

Pontos-chave

O GitHub Copilot SDK é um runtime portátil para agentes, usado no GitHub e em produtos da Microsoft.
O Agent Host Protocol foi concebido para conectar clientes a diferentes runtimes e ambientes.
O copilot D pode iniciar um host em uma máquina e disponibilizá-lo para conexão por outros clientes.
O Copilot CLI pode se conectar a um host remoto, iniciar sessões e interagir com o agente nesse ambiente.
Vários clientes podem se conectar à mesma sessão e receber atualizações em tempo real.
O AHP busca facilitar a transição entre dispositivos, como laptop, telefone e máquinas pessoais ou de trabalho.
O Mission Control pode usar ambientes personalizados que executem hosts compatíveis com o AHP.
O repositório público do protocolo está em Microsoft/agenthostprotocol.

Capítulos

Início	Capítulo	Resumo
00:05	GitHub Copilot SDK e Agent Host Protocol	Patrick apresenta o runtime do Copilot e explica como o AHP conecta runtimes a diferentes dispositivos.
02:44	Iniciando um host remoto	A demonstração mostra como iniciar o copilot D em uma máquina doméstica e obter o identificador do ambiente.
05:20	Conexão e sessões entre clientes	O Copilot CLI se conecta ao host remoto, inicia uma sessão e permite que vários clientes acompanhem e conduzam a interação.
09:39	Mission Control e próximos passos	Patrick demonstra a execução de sessões em ambientes personalizados pelo Mission Control e indica onde acessar o protocolo.

Citações

O protocolo foi criado para garantir que possamos encontrar os usuários onde quer que estejam. — 01:41

Isso iniciou um runtime no meu servidor Linux local, em casa. — 07:00

Você pode passar do laptop para o telefone, do telefone de volta para o laptop. — 09:08

Você não está limitado a executar coisas em Actions ou em ambientes remotos na nuvem. — 10:47

Conceitos e entidades

Agent Host Protocol (conceito): Protocolo apresentado para conectar clientes a hosts que executam runtimes de agentes em diferentes ambientes.
GitHub Copilot SDK (ferramenta): Runtime portátil para agentes usado no GitHub e em produtos da Microsoft.
Copilot D (ferramenta): Implementação de referência usada na demonstração para iniciar um serviço host em uma máquina.
Copilot CLI (ferramenta): Cliente de linha de comando usado para se conectar ao host remoto e interagir com sessões.
Mission Control (ferramenta): Experiência em github.com/copilot/agents que pode executar sessões em ambientes conectados pelo AHP.
Tailscale (ferramenta): Rede privada mencionada na demonstração como meio de acessar máquinas remotas.
Microsoft/agenthostprotocol (repo): Repositório público do Agent Host Protocol.
Patrick Nicoletis (pessoa): Gerente de produto da equipe do GitHub Copilot e apresentador da demonstração.

Tradução completa (pt-BR)

00:05 Olá, pessoal. Meu nome é Patrick Nicoletis. Sou gerente de produto da equipe do GitHub Copilot. Trabalho especificamente no Copilot SDK e no runtime, o que me permite trabalhar em várias interfaces e realizar muitas tarefas relacionadas às necessidades que se espera que os agents atendam e pelas quais sejam responsáveis no futuro, à medida que fazemos essa transição para esse novo mundo empolgante. Antes de entrar no tema principal, que é o protocolo agent host, quero falar um pouco sobre o Copilot SDK, sobre como ele se relaciona especificamente com o protocolo agent host e sobre alguns dos investimentos que estamos fazendo aqui no GitHub, além de alguns dos novos recursos empolgantes que…

00:37 …chegarão nos próximos meses. Para contextualizar, o GitHub Copilot SDK é nosso runtime mais recente, moderno e de ponta para agents. Ele é usado dentro do GitHub. Também é usado em vários produtos da Microsoft, como os produtos do Office, para dar suporte aos novos recursos do modo agent que existem nesses serviços. Ao pensar no runtime em si, ele é altamente portátil. Foi projetado para funcionar em uma grande variedade de ambientes e sob uma grande variedade de restrições. Basta olhar os guias básicos de configuração para ver como…

01:10 …são diversos os ambientes nos quais você pode instalar o runtime hoje e, depois, quais problemas adicionais começam a surgir. O runtime pode ser instalado na sua máquina local como um aplicativo pessoal de produtividade, hospedado como um serviço gerenciado na nuvem ou executado dentro de outros aplicativos. Recentemente, fizemos algumas melhorias no nosso runtime que permitem incorporá-lo e executá-lo em ainda mais plataformas. Mas o protocolo agent host entra em cena numa interseção muito importante entre…

01:41 …os recursos do runtime e a sua capacidade de acessá-lo onde quer que você esteja. Algo em que a equipe está animada para trabalhar desde o começo deste ano é o que chamamos de protocolo agent host, que é essencialmente uma definição de protocolo que pode envolver não apenas o runtime do GitHub Copilot, mas qualquer runtime disponível hoje no mercado ou qualquer outro aplicativo agentic. A principal responsabilidade do protocolo é garantir que possamos atender os usuários onde quer que estejam. Embora seus hosts possam executar runtimes diferentes em momentos diferentes…

02:13 …sua capacidade de acessar esses hosts é mais diversificada do que nunca. Temos laptops, temos celulares e, às vezes, somos apresentados a novos formatos, como o Duo que vimos ontem. Acho que estamos realmente nos preparando para um mundo em que seus agents possam literalmente funcionar em qualquer lugar. Você pode movê-los entre diferentes locais. E, mais importante, independentemente do formato ou dispositivo que estiver disponível para você, também terá acesso a esse agent. E, enquanto continuamos levando esses recursos a lugares como o VS…

02:44 …Code, ao nosso runtime do GitHub Copilot e também às nossas outras interfaces para desenvolvedores, já podemos mostrar algumas das direções que estamos seguindo e, com sorte, vocês ficarão animados para ver aonde vamos chegar no futuro. Certo. Para mostrar o protocolo agent host na prática, vou usar algo muito comum entre os desenvolvedores. Acho que muitos de nós temos nossas próprias redes privadas do Tailscale. Em casa, por exemplo, estou sempre usando uma máquina Mac, uma Windows e uma Linux. Em cada uma delas, há agents do Copilot e também outros agents. Mas estou sempre limitado pelo fato de precisar ter um dispositivo conectado à minha rede do Tailscale para sequer acessar essas máquinas. E, no novo mundo, queremos mesmo abrir caminho para nos livrarmos até dessa limitação. Então, a primeira coisa que vou fazer é entrar no meu NAS doméstico. Acho que, no fim das contas, todos vamos acabar tendo NAS de 80 terabytes em casa, mas este é o meu pessoal, que uso para hospedar arquivos grandes, tudo o que minha família gosta de armazenar e manter num bom arquivo do que está acontecendo, além de fazer alguns…

03:14 …trabalhos de programação. Certo. O AHP vem com vários clientes. Criamos um internamente, que estamos usando como implementação de referência para levar recursos a outras interfaces. Vou falar um pouco sobre como você pode experimentar seus próprios hosts daqui a pouco, mas, por enquanto, vou usar este, que chamamos de copilot D. O copilot D nos permite iniciar um serviço em qualquer host. Como vocês podem ver neste argumento, podemos abrir um relay. Podemos definir facilmente um nome de ambiente; este é o nome da minha máquina Linux doméstica.

03:46 Há uma pasta de workspace. Quando você executa o host, qual é o diretório de trabalho atual ao qual ele fica tradicionalmente restrito? Se quiser, você também pode ter mais de um. E em que endereço você quer disponibilizá-lo, e qual é o nível básico de saída de log? Quando vocês virem o host iniciar, o que ele fará é gerar um identificador de ambiente. Vamos copiá-lo. No futuro, vamos tornar isso ainda mais simples e fácil de usar, mas, por enquanto, o ID do ambiente é tudo de que precisamos.

04:18 E agora temos um host em execução nesta máquina. Isso, por si só, não significa muita coisa, mas, quando volto à minha máquina local, o que vou fazer nesta aba aqui, posso simplesmente entrar diretamente no Copilot CLI, que espero que todos vocês já conheçam bem a esta altura. Vamos ativá-lo e, nas próximas builds, haverá um comando /ahp. Ele permite conectar-se a hosts. Permite ver sessões nos hosts e reiniciá-las. Há…

04:48 …alguns outros recursos empolgantes relacionados a isso também, mas, para mostrar os principais conceitos do AHP, primeiro vou mostrar o comando de host. No momento, não estamos conectados a nenhum host. O Copilot CLI não foi configurado para se conectar a um. Mas posso executar um comando AHP cloud, passar a própria variável de ambiente e, se voltarmos para esta aba do AHP, devemos ver algumas conexões chegando também. O bom é que agora conectei, essencialmente, minha instância local do Copilot CLI…

05:20 …à nuvem e, através dela, à minha máquina local, que é a máquina Linux que está em casa neste momento. Posso executar novamente os comandos de hosts do AHP. Vocês podem ver que estamos conectados externamente por meio do Copilot D. São exibidos as versões do protocolo, os IDs de ambiente etc. Isso mostra que não só posso executar o Copilot localmente, como também estamos conectados, por meio da minha máquina, à minha máquina doméstica externa. Se quiser usar essa máquina em vez da outra, basta executar um comando /ahp use.

05:55 Isso me permitirá conectar diretamente à máquina. Essencialmente, também me permitirá criar novas sessões. Além disso, permitirá que eu me conecte a uma sessão, e vou mostrar um pouco dessa flexibilidade em instantes. Se quisermos iniciar uma nova sessão, basta executar /ahp new. Isso atualizará minha interface para exibir o host remoto. Assim, de forma parecida com o caminho que mostrei para a pasta do workspace, isso não é mais um diretório na minha máquina local. Na verdade, ele inicia um runtime no meu servidor Linux local, em casa. Define como diretório de trabalho atual a pasta do workspace na qual estou executando diretamente o host AHP. E posso interagir diretamente com o agent nessa máquina. Um dos grandes benefícios disso é que, mesmo que o runtime esteja sendo executado em outro lugar, esses clientes externos bem leves — seja o CLI, o VS Code, o aplicativo do GitHub Copilot ou qualquer outro cliente…

06:28 comando. Isso me permitirá conectar diretamente à máquina. E isso basicamente me permitirá criar novas sessões. Também me permitirá me anexar a sessões, e já vou mostrar um pouco dessa flexibilidade incrível. Se quisermos iniciar uma nova sessão, basta executar {slash} AHP new. Isso atualizará minha interface para que ela reflita o host remoto. Então, assim como no caminho que mostrei para a pasta do meu workspace, isso não é mais, na verdade,

07:00 um diretório na minha máquina local. Na verdade, isso iniciou um ambiente de execução no meu servidor Linux local, em casa. Ele definiu o diretório de trabalho atual como a pasta do workspace em que estou executando diretamente o host AHP. E posso interagir diretamente com o agent nessa máquina. Um dos grandes benefícios disso, mais uma vez, é que, embora o ambiente de execução esteja rodando em outro lugar, esses clientes externos bem leves — seja a CLI, o VS Code, o aplicativo GitHub Copilot ou qualquer outro cliente —

07:32 que gostaríamos de criar, que esteja alinhado ao protocolo, possa acessar essa interface, conectar-se ao sistema e realmente conduzir a sessão agentic. Mas não para por aí. Alguns dos recursos exclusivos que vêm com algo assim e que representam uma ótima adição à nossa tecnologia de acesso remoto são a possibilidade de anexar várias sessões ao mesmo tempo. Então, se eu adicionar também o host AHP a este cliente,

08:04 executo um comando diferente. Então, vamos dar uma olhada nas sessões. Ops. Ops. Ajuda se eu adicionar isso no final. Você verá que há uma sessão ativa, que é esta E39. Você verá o OnePlus One, que corresponde ao meu prompt, mostrando que posso anexar diretamente a essa sessão. Então, se eu usar AHP attach, copiamos este identificador aqui. Devemos conseguir conectar nossas sessões

08:37 umas às outras. Se você já usou nossa tecnologia de acesso remoto, normalmente ela era baseada em solicitações. Ela realmente colocava você numa situação em que podia haver um único cliente ativo capaz de controlar a própria sessão. Agora você tem recursos mais avançados em termos de reprodução em tempo real. Você tem recursos avançados nos sistemas de reprodução e na forma como as sessões podem ser portáveis entre clientes. E isso se traduz também em atualizações ao vivo entre clientes. Como você vê, digitei em um

09:08 cliente 2 + 3. Assim que pressiono Enter, isso também pode ir para o outro cliente. Você pode ver a resposta nos dois. Nosso objetivo principal é garantir que, ao conectar novos clientes à experiência e removê-los, cada um possa participar e assumir o controle ativo. Assim, você pode passar do laptop para o celular, do celular de volta para o laptop, da máquina de trabalho para a máquina pessoal, dependendo do contexto em que estiver trabalhando. Mas tudo isso fica disponível por meio deste novo protocolo AHP. Mais uma vez, estamos incorporando-o às nossas interfaces e também o estamos compartilhando

09:39 publicamente e nos aprofundando nele para encontrar mais maneiras de aprimorar a oferta e também adicionar suporte a mais ambientes de execução. Quando pensamos em como isso se traduz, em última análise, nas experiências do github.com, uma das coisas mais empolgantes para mim, pessoalmente, é sua integração ao Mission Control. Nosso serviço Copilot D, que, mais uma vez, estamos buscando trazer funcionalidades diretamente para nosso ambiente de execução, permite que você interaja diretamente com esses ambientes de execução remota pelo Mission Control. Então, enquanto analisamos IDE, CLI e dispositivos móveis, vamos falar um pouco

10:13 sobre a web. Para contextualizar, o Mission Control fica em github.com/copilot/agents. Se você olhar para esta tela inicial, há algumas opções que devem ser familiares à maioria dos usuários que executam tarefas nesta tela. Mas, no fim das contas, o mais empolgante para mim no AHP é o fato de que agora você pode adicionar ambientes ao menu suspenso personalizado de ações e executar novas sessões nas suas próprias máquinas locais, em máquinas na nuvem, onde quer que estejam, desde que executem os hosts AHP corretos e se conectem de volta ao Mission Control. Ele

10:47 agora é um novo ambiente no qual você pode executar tarefas. Portanto, você não fica limitado a executar coisas em actions ou em ambientes remotos na nuvem; também pode executá-las nas máquinas da sua casa, continuando a conectar sua rede de agents e definindo onde quer executar agents ou onde isso é mais vantajoso, de acordo com a situação atual. Então, mais uma vez, se simplesmente enviarmos uma consulta aqui, ela deverá ser encaminhada para o meu ambiente. Você verá uma resposta. E, novamente, tudo isso está sendo executado pelo github.com. Está sendo executado na minha

11:18 rede privada. E, à medida que nos libertarmos de todas as nossas configurações do Tailscale e eliminarmos essa exigência, teremos, em última análise, mais flexibilidade e liberdade para acessar seus agents em qualquer lugar e, mais uma vez, movê-los para onde você quiser. Para mais informações, vou mostrar rapidamente alguns links na tela. O repo do AHP é público em Microsoft/agenthostprotocol. Também temos um site com as especificações do protocolo. O Mission Control está lá e, além disso, se você quiser experimentar o host integrado ao VS Code, deixei um

11:50 comando code agent host lá. Você deve conseguir iniciá-lo usando a versão estável mais recente do VS Code, para começar a experimentar seu próprio host agora mesmo. Obrigado a todos.

Transcrição original

[00:05] Hey everyone. My name is Patrick Nicoletis. I’m a product manager on the GitHub Copilot team. I specifically work on the Copilot SDK and runtime, which gives me an ability to work across many surfaces and accomplish many tasks related to the needs that agents are supposed to live up to and be responsible for in the future as we make this transition to this exciting new world. Before I I dive into the core topic, which is the agent host protocol, I want to touch a little bit on the Copilot SDK and how it relates to agent host protocol in particular and some of the investments that we’re making over here at GitHub and some of the exciting new

[00:37] features that will be landing in the coming months here. For context, the GitHub Copilot SDK is our latest cutting-edge modern runtime for agents. Uh it’s used within GitHub. It’s also used across Microsoft such as the Office products to power the new agent mode capabilities that exist in those services as well. Uh when you think about the actual runtime, uh it’s highly portable. It’s designed to run in a whole host of different environments, a whole host of different constraints that are able to be applied to it. Just looking at the basic setup guides, you can see how

[01:10] diverse the the actual environments are that you can stick the runtime in today and then, you know, what additional problems start surfacing after that point. Um the runtime can be actually baked on your local machine as a local personal productivity application, can be hosted in a managed service in the cloud, can be run in process in other applications. Um we’ve recently made some improvements to our runtime that enable even more platforms that you can embed it in and run it on as well. Um but agent host protocol comes in at a really important intersection between

[01:41] runtime capabilities and your ability to access that runtime wherever you are. Uh and so something that the team has been excited to be working on since earlier this year, we call it the agent host protocol, uh which is essentially a definition for a protocol that can be wrapped around not just the GitHub Copilot runtime, uh but any runtime on the market today or any other agentic application. The core responsibility of the protocol is to make sure that we can meet users wherever they are. Uh while your hosts might be running different runtimes at different points

[02:13] in time, your ability to access that host is more diverse than ever. Uh we have laptops, we have phones, uh sometimes we will be introduced to new form factors like the Duo that we saw yesterday. And I think we’re really preparing for a world where your agents can literally run anywhere. You can move them between locations. And more importantly, no matter which form factor or device you have available to you, you have access to that agent as well. Uh and so while we continue to bring these capabilities into places like VS

[02:44] Code and our our GitHub Copilot runtime as well as our other developer surfaces, we can already show off some of the directions that we’re already heading and and hopefully uh you’ll be excited to see where where we’re leading to in the future. All right. To actually show off the agent host protocol, uh I’m going to use something that is is very common in the developer circles. Uh I think you’ll find many of us have our own private little Tailscale networks. Uh where at home, you know, I’m running a Mac, Windows, and Linux machine at all times. Each one is running Copilot

[03:14] agents as well as other agents, too. Um but I’m always limited by the fact that I need to have a device connected to my Tailscale network to even access those machines. And really we want to set the stage to break free of even that constraint in the new world. Uh so the first thing that I’ll do is I’ll actually just go ahead and log into uh my home NAS. Uh at this point, uh I think we’re all going to end up with 80 terabyte NASs at home, but this is my personal one that I use to host large files, all the stuff my family likes to store and and keep a nice archive of what’s going on as well as do some

[03:46] coding work. All right. AHP comes with a variety of clients. Um we have built one internally that we’re using as a reference implementation to bring capabilities down into other surfaces. So, I’ll talk a little bit about how you can play with your own hosts in a little bit, but for now, I’m going to use this one we call copilot D. Uh copilot D allows us to spin up a service on any host. Um we can, as you can see in this argument here, open up a relay. We can define an environment name easily, so this is my home Linux machine.

[04:18] Um there’s a workspace folder. So, when you actually run the host, you know, what current working directory is it uh traditionally limited to? You can have more than one if you like to as well. And then, what do you want to expose it on and and what’s the basic log output level? Uh when you’ll see the the host spin up itself, um what it does is it produces an environment’s identifier. We’re just going to go ahead and copy that. Uh in the future, we’re going to make this even friendlier and easier to use, but for now, the environment ID will be all that we need.

[04:48] And we now have a host running on this machine. Uh which doesn’t mean much by itself, but when I actually come back to my local machine, which I’ll do over here on this tab right here, I can actually just go right into the copilot CLI directly, which hopefully you all are very familiar with at this point. Um we’ll go ahead and turn it on, and then inside of uh upcoming builds, there’s a /ahp command. Um what this allows you to do is connect to hosts. It allows you to see sessions across the hosts, restart them. Um

[05:20] there’s a few other exciting features related to it as well, but to really show off the core AHP concepts, what I’m going to first do is just show you the host command. Um we are not attached to any host currently. The copilot CLI hasn’t been configured to be connected to one. But what I can do is run an AHP cloud command, give it the environment variable itself, and then if we flip back over to this AHP uh tab, we should see some connections coming in as well. Um the nice thing is uh now I’ve bridged essentially my local Copilot CLI

[05:55] instance to the cloud uh through the cloud to my local machine, uh which is the Linux box that’s currently sitting at home. I can rerun the AHP hosts commands. You can see that we are connected externally through Copilot D. You get protocol versions, environment IDs, etc. Um this is showing that not only am I able to run Copilot uh locally, but we are connected through uh my machine to my external home machine as well. If I want to actually use that instead, I can simply run a {slash} AHP use

[06:28] command. This will allow me to connect directly to the machine. And it it will essentially uh enable me to create new sessions. It’ll also allow me to attach, which I’ll show you some of that that fun flexibility in a second here. Uh if we want to start a new session, um we can just do {slash} AHP new. This will uh update my interface to actually reflect the remote host instead. And so similar to the path that I showed you for my workspace folder, this is not actually

[07:00] anymore a a directory on my local machine. This is actually spun up a runtime on my local Linux server at home. It’s set the current working directory to the workspace folder that I’m running the AHP host uh on directly. And I can go ahead and interface with the agent directly on that machine. Um one of the huge benefits of this again is that even though the runtime is running elsewhere, these really thin external clients, whether it’s the CLI, whether it’s VS Code, uh the GitHub Copilot app, or any other client you’d

[07:32] like to build uh that aligns with the protocol, can access this uh interface, can connect to the system, and can actually drive the agentic session. Um but it doesn’t really just stop there. Uh, some of the unique capabilities that come with something like this uh that represent a really nice addition to our remoting technology is you’re able to attach multiple sessions at the same time. Um, so if I go ahead and add the AHP host onto this client as well,

[08:04] I run a different command. So, take a look at the sessions. Oops. Oops. Helps if I add it at the end. You’ll see that there is an active session, which is this E39. You’ll see the OnePlus One, which matches my prompt, showing that uh I can actually uh attach to that session directly. So, if I use AHP attach, we copy this identifier right here. We should be able to bridge our sessions

[08:37] together. Uh, if you’ve used our remoting technology before, uh typically it was pull-based. It was really forcing you into a situation where you could have one active clients uh that could steer the session itself. Now you get uh more advanced capabilities when it comes to real-time replayability. Um, you get advanced capabilities when it comes to the playback systems and how sessions can be portable across clients. And what this really translates to is you get live updates across clients as well. As you see, I typed in one

[09:08] client 2 + 3. As soon as I hit enter, it can go to the other client, too. You can see the response on both. Um, our core objective and goal is to make sure as you bridge new clients into the experience and take them out, each one can participate in it to be the active driver. That way you can transition from your laptop to your phone, from your phone back to your laptop, from your work machine to your personal machine, depending on the context in which you’re operating in. But it all is made available using this new AHP protocol. Again, that we’re embedding in our surfaces and we’re also uh sharing

[09:39] publicly and and diving deep looking for more ways to improve the offering and also add more runtime support, as well. When you think about how this translates ultimately to the github.com experiences, one of the most exciting things personally uh to me is its integration into mission control. Um our Copilot D service, which again, we’re looking to bring functionality directly into our runtime, as well, uh enables you to actually engage with these remote execution environments directly from mission control. And so, while we look at IDE, CLI, mobile, let’s talk a little

[10:13] bit about the web. Um for context, mission control is under github.com/copilot/agents. Uh if you look at this main home screen, uh there are a few options that should be familiar to most uh users that have uh that execute tasks on this screen. But, ultimately, the most exciting thing to me with AHP is the fact that you can now bring environments into the custom drop-down for actions and execute new sessions on your own local machines, cloud machines, wherever they might be, as long as they run the right AHP hosts, they connect back to mission control, it

[10:47] is now a new environment that you can execute on. So, you’re not constrained by running things in actions or running things in remote cloud environments, uh you can actually run these on your home machines, as well, to continue to bridge uh your agent network and define where you want to run agents most or where it benefits you based on your current scenario. So, again, if we just simply hit a query here, uh it should actually route that down to my environment. You’ll see a response. And again, this is all running off of github.com. It’s running in my

[11:18] private network. And as we break free of all of our Tailscale setups uh and remove that requirement, ultimately, uh we’ll find more flexibility and freedom to access your agents anywhere and again, move them where you want to go, as well. For more additional information, I’ll I’ll flash a few links on the screen. The AHP repo is public underneath Microsoft/agenthostprotocol. We have a website with the protocol specifications available as well. Mission control is on there and then in addition if you like to play around with the host built into VS code, I left a

[11:50] command code agent host there. You should be able to fire it up using the latest stable edition of VS code so you can start playing with your own host right away. Thank you all.