Microsoft Unveils VS Code Agents Window to Run Multi-Repo AI Tasks

The New Agents Window in VS Code | LIVE169 — Visual Studio Code

Visual Studio Code

Delegating tasks across concurrent autonomous agents causes developer burnout and excessive token costs unless workspaces consolidate orchestration and route execution steps to cheaper models.

AI-assisted summary of The New Agents Window in VS Code | LIVE169 — original source. Check the original for full context.

Source published:

Key ideas

  • VS Code introduced the Agents Window, a native multi-workspace control center designed to reduce the mental overhead of running autonomous agents across disparate repositories, branches, and worktrees. (1:02)
  • The Agents Window integrates with VS Code Dev Tunnels, allowing developers to orchestrate and monitor agent tasks on remote home or cloud machines directly from a single interface. (3:05)
  • To counteract notification fatigue from concurrent agents, custom hooks such as 'speak summary' can feed completion payloads directly into system speech synthesizers to vocalize what was accomplished. (4:27)
  • VS Code's new Auto model routing dynamically delegates implementation turns to the best-suited model with an integrated 10% discount, pairing well with frontier models reserved for high-level planning. (7:31)

Detailed notes

## Background Published on June 5, 2026, by Visual Studio Code on YouTube, this Microsoft Build 2026 broadcast session (LIVE169) features Burke Holland and VS Code product manager Harald Kirschner. According to the page description, the session explores the new Agents window, token optimization efforts across recent releases, and best practices for maximizing agent session efficiency.

## TL;DR In this broadcast segment, Harald Kirschner demonstrates the newly introduced Agents Window in Visual Studio Code, a unified multi-workspace interface designed to eliminate the context-switching overhead of tracking multiple autonomous agents. Kirschner explains how the tool integrates with remote environments like VS Code Dev Tunnels and inherits personal extensions, themes, and Git configurations across worktrees and repositories. He also shares personal workflow customizations, such as an audio hook that speaks task completion summaries aloud to prevent burnout, and explains cost-saving strategies like using large frontier models for initial planning alongside VS Code's Auto model routing for efficient execution.

## Atmosphere & style The presentation is brisk, casual, and distinctly technical, driven by the easygoing, banter-heavy rapport between Burke Holland and Harald Kirschner. Operating on a live conference broadcast stage, the mood feels pragmatic and developer-focused rather than polished corporate marketing, complete with self-deprecating jokes about internal job titles and relatable retail analogies like Kohl's savings receipts. Watching the session feels like listening in on two experienced colleagues sharing practical battle-tested hacks, balancing enthusiasm for autonomous agent workflows with frank discussions about mental fatigue and token costs.

## Bulletin - [01:02](https://www.youtube.com/watch?v=oB-AA6312EA&t=62s) VS Code introduced the Agents Window, a native multi-workspace control center designed to reduce the mental overhead of running autonomous agents across disparate repositories, branches, and worktrees. - [03:05](https://www.youtube.com/watch?v=oB-AA6312EA&t=185s) The Agents Window integrates with VS Code Dev Tunnels, allowing developers to orchestrate and monitor agent tasks on remote home or cloud machines directly from a single interface. - [04:27](https://www.youtube.com/watch?v=oB-AA6312EA&t=267s) To counteract notification fatigue from concurrent agents, custom hooks such as 'speak summary' can feed completion payloads directly into system speech synthesizers to vocalize what was accomplished. - [07:31](https://www.youtube.com/watch?v=oB-AA6312EA&t=451s) VS Code's new Auto model routing dynamically delegates implementation turns to the best-suited model with an integrated 10% discount, pairing well with frontier models reserved for high-level planning.

## Key takeaways - [00:00](https://www.youtube.com/watch?v=oB-AA6312EA&t=0s) Every new member of the VS Code team—regardless of whether they join as a PM, advocate, or technical writer—is required to write code and build an extension as their first task. - [01:02](https://www.youtube.com/watch?v=oB-AA6312EA&t=62s) The Agents Window provides a dedicated form factor built directly atop native VS Code rather than acting as a disconnected standalone tool. - [01:19](https://www.youtube.com/watch?v=oB-AA6312EA&t=79s) Traditional single-editor window workflows cause severe context switching and mental burnout once developers delegate tasks to multiple autonomous agents. - [02:21](https://www.youtube.com/watch?v=oB-AA6312EA&t=141s) The Agents Window preserves familiar user customizations out of the box, including themes, extensions, and Git configurations. - [03:05](https://www.youtube.com/watch?v=oB-AA6312EA&t=185s) VS Code Dev Tunnels enable instant remote workspace access by running 'code tunnel' on any host machine without complex networking or port forwarding. - [04:27](https://www.youtube.com/watch?v=oB-AA6312EA&t=267s) Managing parallel agent notifications is a major UX challenge, as generic audio chimes fail to communicate which project or task finished. - [06:00](https://www.youtube.com/watch?v=oB-AA6312EA&t=360s) Autonomous CLI agents trigger a 'task_complete' tool upon finishing, returning a structured summary that contrasts the initial prompt with the delivered output. - [06:00](https://www.youtube.com/watch?v=oB-AA6312EA&t=360s) Using local speech synthesis to announce finished agent summaries eliminates the need to alt-tab across windows to inspect status updates. - [07:31](https://www.youtube.com/watch?v=oB-AA6312EA&t=451s) A recommended cost-optimization workflow is to reserve larger frontier models for initial planning while delegating step-by-step execution to Auto model routing. - [07:31](https://www.youtube.com/watch?v=oB-AA6312EA&t=451s) VS Code's Auto model option dynamically evaluates task complexity per turn and offers an automatic 10% discount on execution tokens. - [07:31](https://www.youtube.com/watch?v=oB-AA6312EA&t=451s) Providing clear retroactive telemetry showing token cost savings compared to expensive frontier models would significantly improve user visibility into agent efficiency.

## Detailed walkthrough ### [00:00](https://www.youtube.com/watch?v=oB-AA6312EA&t=0s) Team Culture and the Technical PM Role in VS Code

Harald Kirschner joins Burke Holland on stage, prompting Burke to joke that virtually the entire Visual Studio Code team has taken over the broadcast stage throughout the day, name-dropping colleagues Courtney, Joanna, Josh, and Tyler. When Burke asks about Harald's role, Harald notes that his title in Slack is listed humorously as "PM-ish." He explains that the product manager role on the team has always been non-traditional and fluid: “VS Code has always been very technical on the PM side, as we saw with Courtney landing PRs.”

Harald reveals a core engineering expectation within the group: regardless of whether someone joins as a PM, an advocate, or a documentation writer, the very first task assigned is to write code and build an extension for VS Code. Harald recalls building one when he started five years earlier, and he has gone on to author over ten extensions since then.

[01:02](https://www.youtube.com/watch?v=oB-AA6312EA&t=62s) Introduction to the New Agents Window

Burke transitions to the core topic, clarifying whether the feature is called the "Agent Sessions Window" or the "Agents Window." Harald clarifies that while "Sessions" was used during initial naming, it is officially called the **Agents Window**. He explains the fundamental divergence between traditional coding and modern agent workflows. In the classic VS Code editor, developers work directly in code mode, hopping between source files to establish and retain a mental model of their codebase.

```mermaid flowchart TD accTitle: Agents Window Multi-Workspace Architecture accDescr: Diagram illustrating how the Agents Window aggregates multiple workspaces, dev tunnels, and agent sessions in a unified hub.

subgraph Sources["Workspaces & Environments"] Local["Local Git Worktrees"] Remote["Remote Repositories / GitHub"] Tunnel["VS Code Dev Tunnels (Home Desktop)"] end

subgraph Hub["VS Code Agents Window"] Orch["Unified Multi-Workspace Control Center"] Ext["Inherited VS Code Extensions, Themes & Git Settings"] end

subgraph Sessions["Active Agent Sessions"] S1["Session: VS Code Docs"] S2["Session: Open-Source PRs (e.g., HNRC)"] S3["Autonomous CLI Agent Harnesses"] end

Local --> Orch Remote --> Orch Tunnel --> Orch Orch --- Ext Orch --> S1 Orch --> S2 Orch --> S3 ```

However, as developers begin delegating work to autonomous agents across several different projects or git worktrees, the conventional single-editor layout breaks down. Jumping across multiple VS Code editor windows to monitor progress creates heavy mental overhead and destroys context. The Agents Window solves this by providing a unified multi-workspace view:

> “Once you start working with agents, even across multiple projects, there's a lot of overhead and switching between VS Code windows and regaining context.”

- **Native Architecture**: It is not a completely detached application, but a dedicated form-factor layer sitting directly on top of the native VS Code application. - **Unified Surface**: It allows running multiple agents across distinct repositories, pull requests, worktrees, and remote machines all in one central dashboard. - **Workflow Interoperability**: While currently accessible directly from VS Code via "Open in Agents," the team previously tested a standalone app variant and intends to allow launching it independently. - **Familiar Foundation**: The window preserves a user's themes, language extensions, and Git configurations out of the box.

[03:05](https://www.youtube.com/watch?v=oB-AA6312EA&t=185s) Remote Agent Orchestration via Dev Tunnels

When launching a new agent session, the user selects the destination workspace and the agent harness. These target workspaces are not restricted to local drives; they can target GitHub repositories or remote machines. Harald shares that he relies heavily on this for his day-to-day workflow, regularly targeting a remote desktop at home using VS Code Dev Tunnels.

Burke emphasizes that Dev Tunnels remain one of the most underrated features of the entire Visual Studio Code ecosystem: “It's like the most slept on feature of Visual Studio Code.” With dev tunnels, a user can simply run the command `code tunnel` on any machine (or enable it through the settings gear menu), sign in via GitHub or Microsoft, and instantly generate a secure tunnel URL. This gives full browser-based or remote VS Code access into that host system without complex networking configurations. Harald keeps a tunnel persistently running on his home machine so he can dispatch agent tasks and supervise multi-repo open-source work directly within the single Agents Window interface.

[04:27](https://www.youtube.com/watch?v=oB-AA6312EA&t=267s) The Burden of Context Switching and Custom Audio Hooks

Harald displays his live interface containing collapsible sessions across various projects, including `VS Code docs` and `HNRC` (an open-source project focused on creating repository-level custom instructions). Burke points out a common pain point: with several agents running at once, generic notification chimes cause confusion because developers cannot tell which task just concluded. Harald notes that managing agent distraction is an ongoing research problem across UI design: “We see that in many of our user testing and even ourselves. It's just burns you out really, really hard.”

To solve the notification ambiguity without constantly alt-tabbing, Harald built a custom automation hook: - In VS Code's customization settings, he configured a hook called **`speak summary`**. - When an agent completes its job in an autonomous CLI workflow (which runs from start to finish without prompting for manual intervention), it triggers a completion tool called `task_complete`. - The completion payload includes a succinct written summary where the model reframes what was requested and what it actually delivered. - The hook feeds that textual summary into local macOS speech models (Siri voices). - Instead of an uninformative notification bell, the computer speaks aloud into the room: “I'm done and here's what I did.”

[07:31](https://www.youtube.com/watch?v=oB-AA6312EA&t=451s) Token Cost Optimizations and Automatic Model Routing

In the remaining minutes of the presentation, Harald touches on token economy and cost optimization efforts integrated into the platform. With new pricing tiers arriving, VS Code has added intelligent backend routing to minimize token consumption without degrading generation quality.

Harald highlights the distinction between autonomous task loops and the **Auto** model option: - **Planning vs. Implementation Strategy**: Harald's core recommendation for developers is to use larger, high-capability frontier models to generate the high-level plan, and then delegate execution to the Auto model: “Use the bigger model for planning and then use auto for implementation and that will look at like what you're trying to do and then route it to the best model.” - **Auto Model Routing**: VS Code's Auto model option dynamically evaluates task complexity per turn, automatically selecting models (including fast models like MAI Fast) and providing a built-in 10% discount on the task run. - **Potential Cost Savings Telemetry**: Burke suggests that VS Code should present a clear comparison showing exactly how many tokens were saved against running an expensive model like Claude 3.5 Sonnet / Opus end-to-end—humorously comparing it to receipts from retail store Kohl's that display how many dollars were saved at the register. Harald agrees this retroactive savings breakdown would be a valuable metric to display to users.

[09:27](https://www.youtube.com/watch?v=oB-AA6312EA&t=567s) Session Wrap-up and Next Segment

As the presentation concludes, the hosts wrap up the broadcast after addressing questions from the audience. Bringing the session to a close, Burke Holland signs off to send the livestream to a brief intermission before the upcoming programming begins, concluding: “All right, thank you for joining us. We will be right back.”

## Notable quotes > [01:02](https://www.youtube.com/watch?v=oB-AA6312EA&t=62s) Once you start working with agents, even across multiple projects, there's a lot of overhead and switching between VS Code windows and regaining context. — Harald Kirschner

> [07:31](https://www.youtube.com/watch?v=oB-AA6312EA&t=451s) Use the bigger model for planning and then use auto for implementation and that will look at like what you're trying to do and then route it to the best model. — Harald Kirschner

## Mentioned Burke Holland, Claude 3.5 Sonnet, Courtney, GitHub, Harald Kirschner, HNRC, Joanna, Josh, Kohl's, MAI Fast, Microsoft, Microsoft Build 2026, Opus, Siri, Tyler, Visual Studio Code, VS Code Dev Tunnels

## Video description Agent sessions are more powerful than ever and the VS Code team has been building the visibility and efficiency to match. Harald Kirschner walks through the new Agents window, the token optimization work shipping across recent releases, and how to get the most out of every session.

To learn more, please check out these resources: * https://aka.ms/VSCode/Agentswindow * https://aka.ms/VSCode/Learn * https://aka.ms/VSCode/TTCompression * https://code.visualstudio.com/learn

𝗦𝗽𝗲𝗮𝗸𝗲𝗿𝘀: * Harald Kirschner * Burke Holland

𝗦𝗲𝘀𝘀𝗶𝗼𝗻 𝗜𝗻𝗳𝗼𝗿𝗺𝗮𝘁𝗶𝗼𝗻: This is one of many sessions from the Microsoft Build 2026 event. View even more sessions on-demand and learn about Microsoft Build at https://build.microsoft.com

LIVE169 | English (US)

Broadcast Stage

#MSBuild

Chapters: 0:00 - Introduction with Harold from VS Code team 00:00:23 - Discussion about VS Code team roles and technical PM structure 00:01:02 - Introduction of new VS Code Agent Window feature 00:01:19 - Explanation of agent window purpose—managing multiple projects and agents 00:02:21 - Clarification that Agent Window is part of VS Code with multi-workspace support 00:03:05 - Demo setup and features like extensibility and Git settings 00:03:39 - Explanation of VS Code Dev Tunnels for remote access 00:04:27 - Agent sessions overview and user context switching challenges 00:06:00 - Customizations and hooks—speaking task summaries in VS Code 00:07:31 - Cost optimizations and new auto model routing for token savings

[Source](https://www.youtube.com/watch?v=oB-AA6312EA)

Reading summary

Visual Studio Code has introduced the Agents Window, a dedicated multi-workspace interface designed to orchestrate autonomous coding agents across multiple repositories, worktrees, and remote environments from a single view. Presenting the feature, VS Code technical product manager Harald Kirschner and host Burke Holland demonstrated how the new surface mitigates window-switching fatigue, leverages dev tunnels for remote tasks, and optimizes token consumption. Unified Multi-Workspace Control Center (1:02) In traditional workflows, developers work in code mode across a single project, mentally tracking changes across individual files. Kirschner explained that this workflow breaks down when managing autonomous agents across distinct repositories or git worktrees, where jumping between multiple editor windows creates significant cognitive overhead and context switching. The Agents Window addresses this by acting as a native multi-workspace aggregation layer directly within VS Code, letting developers monitor simultaneous agent runs across disparate codebases in one centralized dashboard. Remote Agent Execution with Dev Tunnels (3:05) Agent sessions within the Agents Window are not restricted to local drives; they can target GitHub repositories and remote host machines. Kirschner noted that he regularly uses VS Code Dev Tunnels to dispatch agent sessions to a remote desktop machine running persistently at home. Holland characterized dev tunnels as one of the platform's most underutilized features, noting that executing the `code tunnel` command or enabling it in settings allows instant, secure remote access through GitHub or Microsoft authentication without complex network configuration. Addressing Alert Fatigue via Audio Hooks (4:27) Running multiple autonomous tasks simultaneously introduces notification ambiguity, as standard UI chimes fail to communicate which project completed or what was done. Kirschner emphasized that managing agent-driven interruptions is an ongoing UI challenge that frequently contributes to developer burnout. To address this, he configured a custom `speak summary` automation hook in VS Code settings. When an autonomous CLI agent completes a job, its `task_complete` tool passes a concise summary of requested versus delivered work into local macOS speech synthesis, audibly announcing the completed outcome into the room. Token Economy and Dynamic Model Routing (7:31) To control token expenditure under emerging platform pricing tiers, VS Code has integrated dynamic model routing. Kirschner recommended a split workflow: developers should use high-capability frontier models to generate broad planning architecture, then hand off execution to the built-in 'Auto' model selector. The Auto option evaluates per-turn complexity to route tasks to efficient engines—such as MAI Fast—while offering a built-in 10% discount on the run. Holland proposed incorporating receipt-style telemetry to clearly report retroactive token savings compared to running high-end frontier models continuously. The Agents Window shifts VS Code from a single-editor paradigm toward an orchestration hub for autonomous agents, though managing notification noise and token overhead remains an evolving challenge. The team plans to support launching the tool independently while exploring retroactive savings metrics for users.

Source quotes

[1:02] Harald Kirschner: Once you start working with agents, even across multiple projects, there's a lot of overhead and switching between VS Code windows and regaining context. [7:31] Harald Kirschner: Use the bigger model for planning and then use auto for implementation and that will look at like what you're trying to do and then route it to the best model.

Original transcript

[0:00] All right, thank you. [0:01] We're back and we have Harold from the VS Code [0:05] team. [0:05] Is there anybody from the VS Code team that's not [0:08] here on the stage today? [0:10] I feel like it's literally. [0:11] Excellent people like we knew it took over to stage. [0:13] You did? [0:14] Yes. [0:14] Courtney and Joanna and Josh and yeah. [0:17] Yeah, this guy Tyler, you probably know him. [0:19] OK. [0:20] You're APM. [0:23] You're APM on the VS Code team. [0:25] Yes, I think my title in slack is PM ish. [0:28] He that's your official. [0:29] Channel, yeah, because it's so shifting how we work and [0:33] always has been. [0:34] VS Code has always been very technical on the PM [0:36] side, as we saw with Courtney landing PRS. [0:40] When you join the team, actually the first thing you [0:43] do, even as APM, as an advocate, as as a [0:45] Darks writer, is you have to write. [0:47] Build something. [0:48] Code extension. [0:49] So it's, it's a, it's an engineering did. [0:51] They make you do. [0:52] That yes which? [0:53] One what did you write? [0:55] I forgot it's it's five years ago and now I [0:57] wrote 10 more extensions, so it's one of my extensions. [1:00] Yeah, you've read a lot of extensions. [1:02] OK, so today though we're talking about agent, the agent [1:07] sessions window. [1:08] Is it the agent sessions window or the agent window? [1:11] The agent's window sessions was the first name. [1:15] Now it's called the agent. [1:16] Window. [1:16] Now it's the agent window. [1:17] What is the agent window? [1:19] Yeah, so I want to. [1:21] So we have the this classic VS Code like how [1:24] you basically would write code in the past or how [1:27] most people have are still writing code. [1:30] And you if you want to see code, then you [1:32] would use the VS Code editor. [1:34] You switch between files, you you're in the code mode. [1:38] And we see that in the user research that people [1:40] sometimes just need to spend time and code to build [1:43] the mental picture and don't necessarily work with a lot [1:45] of agents. [1:46] But once you start working with agents, even across multiple [1:49] projects, there's a lot of overhead and switching between VS [1:52] Code windows and regaining context. [1:55] And that's where we have the the agents window is [1:58] that allows you. [1:59] It's basically the same way you can just get up [2:03] here open in the agents and it opens the same [2:06] workspace you have open in this multi workspace environment where [2:10] I can now have all my workspaces and all the [2:14] agents that are running in PRS in different work trees [2:17] and even remote in one place. [2:19] So this is a new app. [2:21] It's the same app. [2:22] It's the same app VS Code app, but a different [2:25] form factor on top of it. [2:26] OK so do I have to open VS Code to [2:28] open this or can I just open this? [2:30] Eventually you can open this. [2:31] We actually had a separate app for a while so [2:34] you could open both. [2:35] Yeah, I thought I remembered it. [2:36] And then you could open VS Code from the window [2:38] or vice versa. [2:39] Yes. [2:40] OK, so that's coming. [2:41] It's coming. [2:41] Yeah. [2:41] OK. [2:41] Yeah. [2:42] All right. [2:42] So show us around here. [2:43] How is this? [2:44] It looks, I'm going to be honest, that looks like [2:47] VS Code. [2:48] Yes, So you get the same kind of homey feel [2:51] of of VS Code with your theme. [2:53] We we're bringing over more of the extension extensibility as [2:57] well, but like all your language extension that you have [2:59] installed and other extensions will power. [3:02] Works as well a lot of the. [3:05] Settings of how you handle git. [3:07] So on the last day, basically as soon as you [3:09] hit hit new, you basically ask like which of these [3:11] workspaces do you actually want to spawn something in which [3:14] agent? [3:14] And then you can pick the harness. [3:15] We already had Tyler here talk about Clot and we [3:18] have this. [3:19] Did those have to be local folders or can it [3:21] be? [3:22] They can be remote as well, so I. [3:23] Can pick local or from. [3:25] GitHub, GitHub repo or remote. [3:27] And that's what I've actually been using a lot. [3:28] So right now it's not online but my local desktop [3:31] that I have. [3:32] I have a deaf tunnel running. [3:35] At home. [3:35] At home. [3:36] Yes, I think. [3:37] Do you all know about deaf tunnels? [3:39] It's so if you don't know this in VS Code [3:41] you can go to the gear and say turn on [3:43] dev. [3:43] Is it called dev tunnels? [3:45] Yes, any any window you have. [3:47] Just any window. [3:48] And it will give you a URL that you can [3:50] use to access your computer from anywhere via the web. [3:54] It just puts VS Code in the browser, powered by [3:56] your machine wherever it's running, secured behind your login. [4:00] It's like the greatest feature in. [4:01] The world it's own session all the ways you can [4:03] do remote it's. [4:03] Like the most slept on feature of Visual Studio Code. [4:06] Yeah, OK. [4:07] If if you're on a remote on any instance, you [4:09] basically do code tunnel and it opens up the tunnel. [4:12] You login with GitHub or Microsoft. [4:13] Yeah, I have one running up all the time, Yeah. [4:16] So that's that's just working out-of-the-box. [4:18] So we have that running, but I mostly work in [4:21] different repos, sometimes cross repo, sometimes remote, where I just [4:25] run things on my on my home machine. [4:27] But in this case, I have a lot of things [4:30] I do work a lot in open source. [4:31] So it's nice to see everything in one place that [4:34] I have going on and just check in like, how's [4:36] this PR going? [4:37] So it's somewhat more of a agent orchestration, Control Center [4:40] kind of situation Evan has. [4:42] Each one of these these are sessions. [4:45] So I see VS code, yes, VS Code CD notes. [4:50] I can't read that. [4:51] Which one? [4:52] VS Code docs. [4:53] Yes docs, we had the game show earlier. [4:56] Oh, that's. [4:56] That session HNRC is an open source project to create [5:00] custom instructions and repos. [5:01] So they're in like these collapsible. [5:03] Is there a different view or is that the only [5:05] view? [5:05] There is a little more sorting, you can sort of [5:07] update it and time and workspace. [5:09] But I think that's, that's where I hope we we [5:11] figure out more of the like, how do you we [5:14] do manage agents as well. [5:15] Right now it looks similar to how many other UIS [5:18] manage their agents. [5:19] Yeah, yeah. [5:19] But I mean, that's an unsolved problem that context switching. [5:22] We see that in many of our user testing and [5:24] even ourselves. [5:25] It's just burns. [5:26] You out really, really hard, yeah. [5:28] So we need one to solve. [5:29] That's one of the big problems we want to solve. [5:31] So when you when you're when the when agents are [5:34] working or done, how do you know like this is [5:36] this is one of the things I struggle with right [5:39] now in all of these, like in, for instance, in [5:42] the GitHub copilot app, Great, great experience. [5:45] Whenever an agent is done, it Dings. [5:47] And so now my computer is just like Ding, Ding, [5:49] Ding, Ding. [5:50] And I don't know right which agent is done or [5:53] where it is, but I don't know what else it's [5:55] supposed to do to tell me that it's done. [5:58] So my, my, my hack I had if, if I [6:00] go into my customizations, I have it off right now [6:03] because would be, it's very interesting to get that on [6:06] a live stage. [6:07] I actually have where's my hook? [6:10] Let's see why. [6:10] That's why I open a new window. [6:15] So customizations allow you to control it also somewhat. [6:18] And I know you, you saw demos of like people [6:20] doing fun things of hooks to, to get audio going. [6:24] My, my favorite is we go on customizations also then [6:28] hooks. [6:29] There's a it's big, there's a speak summary. [6:33] So this this one is basically a hook that uses [6:37] series local speech models to use what autopilot does. [6:42] If you see CLI autopilot, it's meant to complete everything [6:45] you gave it and not asking for anything in between. [6:48] But in the end, it caused this tool task, complete [6:51] with a description of what it did to get the [6:54] model to kind of reframe all the what it was [6:56] supposed to do and what it finished. [6:58] So it. [6:58] Finishes, calls the hub, sends it to a local. [7:02] And then it speaks it back to me, so I [7:04] have my computer saying it. [7:05] Says to you, I'm done and here's what I did. [7:07] Yes. [7:08] No. [7:08] Way, yes, that's. [7:08] So much. [7:09] Fun. [7:09] Can you demo it? [7:10] No, I should, I should, I haven't made it by [7:14] the way. [7:15] I used it for a while and suddenly my my [7:16] computer in the office speaks. [7:18] OK, I'm you have to go back and then, but [7:20] it's. [7:20] That's brilliant. [7:21] I got to try this. [7:22] Yeah, I want to, but sorry, because we want to [7:25] talk. [7:25] About the agent, I'm sorry, I'm sorry. [7:27] Yes. [7:28] You have a minute and 26 seconds. [7:30] OK. [7:31] What else we want to talk about was the cost [7:33] optimizations we did. [7:34] So we have the I did actually just this quick [7:37] analysis what we did and had it righted. [7:41] Here we go, open it up. [7:43] Wait, where's my cost improvements? [7:46] Let me open that. [7:47] Where did we put it changes OK cost improvement say [7:53] let me scroll up here. [7:55] So we had, we've been doing a ton because we're [7:58] shipping this new pricing model and we want to give [8:00] people really the best experience, the best what we. [8:03] Can get for a token. [8:05] So we if you have seen we the auto model [8:07] we have does routing actually based on task complexity and [8:10] gives you a 10% discount of what you're running. [8:13] So this is my biggest recommendation, use the bigger model [8:16] for planning and then use auto for implementation and that [8:19] will look at like what you're trying to do and [8:22] then route it to the best model including. [8:24] The new auto auto does that now, yes. [8:26] So it will call. [8:27] We'll use Mai Mai fast. [8:29] Oh, really interesting. [8:30] So plan with the big model and then send it. [8:34] Auto is not autopilot. [8:36] Auto is the model. [8:38] Yes, OK. [8:39] And that will save you tokens. [8:40] Different. [8:41] Yeah. [8:41] That's like basically do we know how much it's 10% [8:44] discount? [8:45] Yeah, but how do you know how many tokens that [8:47] you're saving versus like just burning it on Opus 46 [8:49] we. [8:49] Should eventually tell you that that that's a good idea, [8:51] but. [8:51] Yeah, that would be interesting also. [8:52] Automatically done. [8:53] So we can maybe tell you in hindsight of what [8:55] it would have been on the big model that would. [8:58] Be great. [8:58] You should show that. [8:59] Yeah. [8:59] That you. [9:00] Yeah. [9:00] It's like when you go to when you go to [9:02] Kohl's and they're like, you saved $55 today and you're [9:06] like, you feel good about yourself. [9:08] You're like, oh. [9:08] You're a good money Bart man. [9:10] I'm so good at this game. [9:12] Yeah, Tom is. [9:13] Tom wants you to leave. [9:14] I want you to stay. [9:16] Yeah, unfortunately. [9:17] There's a bunch of stuff you check on release notes [9:20] or there's always something about cost and token savings, so [9:23] check out those as well. [9:24] Thank you for joining us, Harold. [9:25] I'm sorry I took up all your time asking dumb [9:27] questions. [9:28] All right, thank you for joining us. [9:29] We will be right back.