GitHub Rebuilds Git Core to Handle Thousands of Concurrent AI Pushes

Everything announced at GitHub Universe 2026: opening keynote recap — GitHub

GitHub

GitHub replaced repository-wide write locks with branch-level coordination because surging autonomous agent workloads overwhelm legacy version control infrastructure.

AI-assisted summary of Everything announced at GitHub Universe 2026: opening keynote recap — original source. Check the original for full context.

Source published:

Key ideas

  • GitHub has surpassed 225 million developers and introduced a dedicated GitHub Copilot app featuring unified connectors for Slack, Sentry, Vercel, and Netlify. (0:00)
  • Copilot Fusion dynamically routes tasks through single, cascade, or critique model patterns, scoring 60 on the Artificial Analysis Coding Agent Index while cutting costs by 50% and execution time by 40%. (1:26)
  • Copilot Projects is now generally available, enabling engineering teams to orchestrate autonomous fleets of specialized agents across multiple connected repositories. (2:06)
  • GitHub launched Code Review Max, achieving the top F1 score on ReviewBench for high-severity defects, and made Copilot Code Review available without a paid subscription. (4:55)
  • GitHub re-engineered Git's core storage model to use branch-level locking instead of repository-wide locks, increasing write throughput by 3x to 4x and scaling push capacity to thousands per second. (5:51)

Detailed notes

## Background Published on YouTube by GitHub on October 29, 2026, this video provides an edited cutdown of the opening keynote at GitHub Universe 2026. The description outlines the platform's vision for the agentic era, highlighting announcements such as the dedicated GitHub Copilot app, third-party connectors, Copilot Fusion, multi-repository management with Copilot Projects, Code Review Max, and deep architectural upgrades to Git.

## TL;DR The keynote outlines GitHub's evolution into an agent-centric development platform serving over 225 million developers. Key product launches include a standalone GitHub Copilot app equipped with external tool connectors and Copilot Fusion, a meta-orchestrator that routes tasks across multiple models to slash costs and execution times. To manage complex software stacks, Copilot Projects deploys autonomous agent fleets across multiple repositories, complemented by cloud sandboxes that ensure state continuity across mobile, CLI, and desktop IDEs. Additionally, GitHub launched Code Review Max for high-severity static analysis and fundamentally re-architected Git hosting with branch-level locking to support thousands of concurrent agent pushes per second.

## Atmosphere & style The presentation carries the brisk, polished momentum of a flagship developer conference, rotating smoothly between presenters delivering live feature demos and architectural breakdowns. The atmosphere balances pragmatic engineering enthusiasm and relatable developer humor—such as joking about the dread of micromanaging autonomous agents—with deep technical pride when discussing lower-level infrastructure overhauls. It feels forward-looking yet concrete, methodically showing how conceptual agent workflows map directly onto codebases, PR reviews, and low-latency storage systems.

## Bulletin - [00:00](https://www.youtube.com/watch?v=xbCa0aa4tRM&t=0s) GitHub has surpassed 225 million developers and introduced a dedicated GitHub Copilot app featuring unified connectors for Slack, Sentry, Vercel, and Netlify. - [01:26](https://www.youtube.com/watch?v=xbCa0aa4tRM&t=86s) Copilot Fusion dynamically routes tasks through single, cascade, or critique model patterns, scoring 60 on the Artificial Analysis Coding Agent Index while cutting costs by 50% and execution time by 40%. - [02:06](https://www.youtube.com/watch?v=xbCa0aa4tRM&t=126s) Copilot Projects is now generally available, enabling engineering teams to orchestrate autonomous fleets of specialized agents across multiple connected repositories. - [04:55](https://www.youtube.com/watch?v=xbCa0aa4tRM&t=295s) GitHub launched Code Review Max, achieving the top F1 score on ReviewBench for high-severity defects, and made Copilot Code Review available without a paid subscription. - [05:51](https://www.youtube.com/watch?v=xbCa0aa4tRM&t=351s) GitHub re-engineered Git's core storage model to use branch-level locking instead of repository-wide locks, increasing write throughput by 3x to 4x and scaling push capacity to thousands per second.

## Key takeaways - [00:00](https://www.youtube.com/watch?v=xbCa0aa4tRM&t=0s) GitHub's community has expanded to over 225 million registered developers as platform infrastructure pivots to support autonomous agentic workflows. - [00:45](https://www.youtube.com/watch?v=xbCa0aa4tRM&t=45s) The standalone GitHub Copilot app serves as a central home base for coordinating agentic tasks, automations, and third-party developer tool integrations. - [00:45](https://www.youtube.com/watch?v=xbCa0aa4tRM&t=45s) Unified connectors provide single-point authentication across external services including Slack, Work IQ, Vercel, Netlify, and Sentry for consistent context retrieval across Copilot environments. - [01:26](https://www.youtube.com/watch?v=xbCa0aa4tRM&t=86s) Copilot Fusion functions as a meta-orchestrator that dynamically selects between single-model execution, tiered cascades, and multi-model critique patterns based on task complexity. - [01:26](https://www.youtube.com/watch?v=xbCa0aa4tRM&t=86s) On the Artificial Analysis Coding Agent Index, Copilot Fusion Max achieved a score of 60, trailing Opus 5.5 Max by just two points while slashing cost per task by half and duration by 40%. - [02:06](https://www.youtube.com/watch?v=xbCa0aa4tRM&t=126s) Copilot Projects allows teams to bind multiple repositories into a unified workspace, eliminating the manual friction of micromanaging multi-repo changes. - [02:06](https://www.youtube.com/watch?v=xbCa0aa4tRM&t=126s) Fleets of specialized agents can be autonomously generated and assigned across linked repositories depending on where code updates, migrations, or tests are needed. - [03:43](https://www.youtube.com/watch?v=xbCa0aa4tRM&t=223s) Workflows initiated on mobile execute inside isolated cloud sandboxes, preserving session state across web, VS Code, and terminal CLI interfaces. - [03:43](https://www.youtube.com/watch?v=xbCa0aa4tRM&t=223s) The standardized Copilot agent harness used internally across Microsoft has been made available for custom agent development on Microsoft Foundry. - [03:43](https://www.youtube.com/watch?v=xbCa0aa4tRM&t=223s) GitHub's security stack integrates real-time Sentry telemetry, AI push protection, secret scanning, and automated vulnerability scanning with guided remediation. - [04:55](https://www.youtube.com/watch?v=xbCa0aa4tRM&t=295s) Copilot Code Review has reached 200 million findings and is now accessible to all developers without requiring a paid Copilot subscription. - [04:55](https://www.youtube.com/watch?v=xbCa0aa4tRM&t=295s) Code Review Max represents GitHub's deepest static analysis tier, achieving the highest F1 score on the ReviewBench benchmark for high-severity defects. - [05:51](https://www.youtube.com/watch?v=xbCa0aa4tRM&t=351s) Concurrent AI agent workloads exposed physical data center latency bottlenecks across GitHub's top 100 most active repositories. - [05:51](https://www.youtube.com/watch?v=xbCa0aa4tRM&t=351s) Replacing legacy whole-repository write locks with branch-specific locking prevents agent fleets on separate feature branches from blocking one another. - [05:51](https://www.youtube.com/watch?v=xbCa0aa4tRM&t=351s) The rebuilt Git architecture scales repository push handling from dozens of pushes per second to thousands of concurrent pushes per second. - [05:51](https://www.youtube.com/watch?v=xbCa0aa4tRM&t=351s) High-velocity open-source project OpenClaw validated the redesigned Git foundation under heavy parallel agentic production traffic.

## Detailed walkthrough ### [00:00](https://www.youtube.com/watch?v=xbCa0aa4tRM&t=0s) The Agentic Era and the GitHub Copilot App

Opening the keynote, Jay reflects on the rapid evolution of developer workflows, noting that the platform's vision for autonomous software collaboration has officially materialized. There are now over 225 million developers building on GitHub, and an accompanying visualization of GitHub Actions job volume highlights the staggering operational leap between 2024 and 2026. Setting the tone for the morning's announcements, Jay explains: “When we were here last year, we talked about how 2026 was going to be the year where developers and all of their agents showed up for work on GitHub.” To demonstrate these foundational primitives in action, he brings Cassidy to the stage.

Cassidy introduces the standalone GitHub Copilot app, presenting it as a centralized home base designed to coordinate agentic workflows, orchestrate automations, and manage integrations across multiple concurrent software projects. Walking through a practical scenario involving an upcoming passport feature, Cassidy shows how open questions can be answered instantly right inside the app, even when querying teammates like her coworker Seth. Jay points out that this seamless context retrieval is driven by connectors—managed services integrated directly into the Copilot surface that securely bridge external developer tools such as Slack, Work IQ, Vercel, Netlify, and Sentry. Authenticating once through these connectors makes external tool data and team communications accessible across all Copilot environments.

- **Developer Growth**: The GitHub community has surpassed 225 million registered developers. - **Unified Tool Connectors**: Connectors provide single-point authentication across Slack, Work IQ, Vercel, Netlify, and Sentry for consistent data access across all development surfaces.

---

[01:26](https://www.youtube.com/watch?v=xbCa0aa4tRM&t=86s) Multi-Model Orchestration with Copilot Fusion

When deciding which underlying intelligence should power the app's tasks, Jay recommends Copilot Fusion. Rather than binding a task to a single large language model, Fusion serves as a dynamic meta-orchestrator that evaluates the incoming work and automatically routes it through the most effective model combination and execution strategy. As Jay clarifies regarding its design: “Fusion coordinates between multiple models to deliver frontier level results at a lower cost, in fact.”

Fusion dynamically selects among three distinct operational patterns depending on task complexity: single model execution, a tiered cascade pattern, or a critique pattern where multiple models verify and refine code output. In benchmark evaluations on the Artificial Analysis Coding Agent Index, Copilot Fusion Max achieved a score of 60, placing it within two points of Opus 5.5 Max while cutting cost per task in half and reducing execution duration by 40%. To encourage teams to integrate the orchestrator into daily workflows, Jay announces a promotional 30% usage discount on Copilot Fusion through the end of November.

```mermaid flowchart TD accTitle: Copilot Fusion Execution Patterns accDescr: Diagram illustrating how Copilot Fusion selects between single, cascade, and critique execution patterns. TASK["Incoming Development Task"] --> FUSION["Copilot Fusion Router"] subgraph Patterns["Execution Patterns"] FUSION -->|"Simple task"| P1["Single Model Pattern"] FUSION -->|"Tiered evaluation"| P2["Cascade Pattern"] FUSION -->|"High-accuracy verification"| P3["Critique Pattern"] end P1 & P2 & P3 --> OUT["Frontier Results (-50% Cost, -40% Time)"] ```

---

[02:06](https://www.youtube.com/watch?v=xbCa0aa4tRM&t=126s) Multi-Repository Agent Fleets with Copilot Projects

Burke joins the stage wielding a new Surface Laptop Ultra to demonstrate Copilot Projects, which he describes as his personal favorite way to interact with GitHub Copilot. To begin, he navigates directly to the sidebar of the GitHub Copilot app and creates a project, immediately attaching multiple repositories from the fictional Fourth Coffee organization to establish full multi-repo context.

Modern feature development rarely stays confined to a single code repository. Copilot Projects accommodates this reality by spinning up autonomous fleets of specialized agents and dispatching them across different codebases according to where code changes, migrations, or tests need to occur. Emphasizing the relief from manual orchestration overhead, Burke jokes: “Y’all, nobody likes micromanaging agents. With Copilot Projects, you get to get out of that business completely so that you can just focus on the results..” Jay echoes that this automated delegation across repositories is central to accelerating engineering velocity, announcing that GitHub Copilot Projects is immediately available to all developers.

- **Multi-Repo Context**: Teams can link disparate organizational repositories into a single unified project workspace. - **Autonomous Agent Assignment**: Copilot dynamically spins up and assigns agents to specific repositories based on the sub-tasks required. - **General Availability**: GitHub Copilot Projects launched for all users on the day of the keynote.

---

[03:43](https://www.youtube.com/watch?v=xbCa0aa4tRM&t=223s) Cross-Surface Continuity, Cloud Sandboxes, and Code Review Max

Damian takes over the demonstration to showcase real-world incident remediation and continuity across mobile and desktop environments. Handling an issue where an "order ahead" feature shuts down before a cafe closes without informing customers, Damian kicks off an autonomous Copilot fix from his mobile phone. The system initializes the task inside an isolated cloud sandbox, enabling him to detach cleanly and pick up the exact session state later from another interface. Jay highlights that this continuity spans the mobile app, web, VS Code, and the terminal CLI, all driven by the standardized Copilot harness deployed throughout Microsoft and now accessible for custom agent creation on Microsoft Foundry.

Transitioning to another failure on the Fourth Coffee website, Damian inspects a broken "how ordering works" button that instantly triggers an HTTP 500 error. Within a custom canvas view linked to production Sentry telemetry, Damian reviews the error alert. Beyond point-in-time exception handling, GitHub code scanning analyzes both incoming and historical code across the repository, flagging vulnerabilities along with precise line locations, vulnerability classifications, and guided remediation steps. Combined with secret scanning and AI-assisted push protection, this suite automates proactive repository defense.

To elevate pull request inspection, Damian highlights the trajectory of Copilot Code Review, which has surfaced 200 million findings for developers since its debut. GitHub is now launching Code Review Max, its deepest static analysis tier to date. Underlining its precision, Damian states: “It posted the highest F1 score on ReviewBench for high severity issues.” Furthermore, Copilot Code Review is made universally accessible to all developers, without requiring a paid Copilot subscription.

- **Cross-Surface Continuity**: Developers can trigger a cloud-sandboxed session on mobile and resume across VS Code, CLI, or GitHub.com without losing state. - **Agent Framework on Foundry**: The foundational Copilot harness can be leveraged by developers on Microsoft Foundry to build bespoke agents. - **Security Defenses**: GitHub's automated protection layers combine real-time Sentry alert integration, code scanning vulnerability remediation, secret scanning, and AI push protection. - **Code Review Max**: Provides top-tier F1 accuracy on high-severity defects according to ReviewBench benchmarks and is available without a Copilot subscription.

---

[05:51](https://www.youtube.com/watch?v=xbCa0aa4tRM&t=351s) Rebuilding Git's Foundation for Concurrent Agent Workloads

April takes the stage to address the massive infrastructure demands imposed by autonomous AI agents. While a human developer pushes code intermittently, thousands of concurrent agents generate branches, query commit history, and push simultaneous commits across every repository. Because all of this agentic throughput ultimately converges on Git, GitHub has re-engineered the lower-level foundation of Git hosting from the ground up.

The first architectural bottleneck addressed was physical repository hosting. For the top 100 most active repositories on the platform, even a 25-millisecond latency window between data centers introduced crippling contention. To resolve this, GitHub overhauled Git's write coordination model. Historically, an incoming push acquired an exclusive lock over the entire repository; the new storage architecture restricts locking strictly to the individual branch receiving the update. This allows fleets of agents operating on distinct feature branches to push in parallel without blocking one another, increasing write throughput by three to four times. While the legacy hosting layer choked at dozens of pushes per second per repository, the modernized architecture is architected to handle thousands of concurrent pushes per second, with internal load testing suites maxing out their own capacity before saturating Git's new read pipeline.

```mermaid flowchart TD accTitle: Git Write Coordination Architecture accDescr: Comparison between legacy repository-wide locking and the new branch-level write locking for agentic workflows. subgraph Legacy["Legacy Architecture (Repo-Level Lock)"] R1["Incoming Pushes"] --> L1["Full Repository Lock"] L1 --> B1["Bottleneck: Dozens of pushes / sec"] end subgraph Modern["New Architecture (Branch-Level Lock)"] R2["Concurrent Agent Pushes"] --> L2["Branch-Specific Locks"] L2 --> B2["Branch A Writes"] L2 --> B3["Branch B Writes"] B2 & B3 --> OUT["Throughput: Thousands of pushes / sec"] end ```

To validate the architecture against intense real-world traffic, GitHub partnered with Peter Steinberg, creator of OpenClaw, one of the platform's busiest open-source repositories. Reflecting on the impact of these architectural upgrades for demanding projects, Steinberg remarks: “GitHub is being able to tell us when something is ready, that you’re building the foundation for that right now and it will solve pretty much all our existing problems.”

Concluding the keynote, Jay reviews how GitHub has updated every layer of its software stack—from branch-level Git locking up through multi-model orchestration with Copilot Fusion, multi-repo project management, and cross-surface continuity across the CLI, VS Code, and the Copilot app—to establish an infrastructure tailored for the agentic era.

- **Branch-Level Locking**: Replaces legacy whole-repo write locks with per-branch locking, driving a 3x to 4x increase in write throughput. - **Push Scalability**: Scaled per-repo push ingestion capacity from dozens of pushes per second to thousands per second. - **Latency Optimization**: Mitigated physical data center latency bottlenecks (under 25 milliseconds) across the top 100 busiest repositories on GitHub. - **Production Validation**: Partnered with high-velocity open-source project OpenClaw to validate parallel agent workloads under production traffic.

## Notable quotes > [01:26](https://www.youtube.com/watch?v=xbCa0aa4tRM&t=86s) Fusion coordinates between multiple models to deliver frontier level results at a lower cost, in fact. — Jay

> [02:06](https://www.youtube.com/watch?v=xbCa0aa4tRM&t=126s) Y’all, nobody likes micromanaging agents. With Copilot Projects, you get to get out of that business completely so that you can just focus on the results.. — Burke

## Mentioned GitHub, GitHub Universe 2026, Jay, Cassidy, Seth, GitHub Copilot, Slack, Work IQ, Vercel, Netlify, Sentry, Copilot Fusion, Copilot Fusion Max, Artificial Analysis Coding Agent Index, Opus 5.5 Max, Burke, Surface Laptop Ultra, Copilot Projects, Fourth Coffee, Damian, Microsoft, Microsoft Foundry, VS Code, Copilot Code Review, Code Review Max, ReviewBench, April, Git, Peter Steinberg, OpenClaw

## Video description Missed the opening keynote at GitHub Universe 2026? Catch up on every major announcement and live demo in this cutdown of the morning session. Explore the dedicated GitHub Copilot app, third-party connectors, and Copilot Fusion for multi-model orchestration at lower costs. Discover how Copilot Projects manages fleets of agents across multiple repositories, plus the launch of Code Review Max and deep architectural upgrades to Git. Visit https://githubuniverse.com to explore all on-demand sessions, documentation, and technical deep dives.

Watch more videos from GitHub Universe 2026: https://www.youtube.com/watch?v=AArI948SDz8&list=PLENrlACZ7mnU

— CHAPTERS —

0:00 Welcome to GitHub Universe 2026 0:45 The new GitHub Copilot app and connectors 1:26 Introducing Copilot Fusion 2:06 Managing multi-repo work with Copilot Projects 3:43 Cross-surface continuity and cloud sandboxes 4:55 Code scanning and Code Review Max 5:51 Rebuilding the foundation of Git 7:20 Evolving GitHub for the agentic era

#GitHubUniverse #GitHubCopilot #DeveloperTools

Stay up-to-date on all things GitHub by connecting with us:

YouTube: https://gh.io/subgithub Blog: https://github.blog X: https://twitter.com/github LinkedIn: https://linkedin.com/company/github Insider newsletter: https://resources.github.com/newsletter/ Instagram: https://www.instagram.com/github TikTok: https://www.tiktok.com/@github

About GitHub It’s where over 180 million developers create, share, and ship the best code possible. It’s a place for anyone, from anywhere, to build anything—it’s where the world builds software. https://github.com

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

Reading summary

At GitHub Universe 2026, GitHub announced a stack-wide overhaul designed for autonomous AI agents, spanning a standalone orchestration app, multi-model routing, and an architectural redesign of Git's core write pipeline. Unified Agent Workflows and Multi-Repository Context (0:00) GitHub introduced the standalone GitHub Copilot app alongside Copilot Projects to serve as a central operational hub for managing autonomous agents across software systems. The Copilot app incorporates integrated connectors for external developer services, including Slack, Work IQ, Vercel, Netlify, and Sentry, using a single-point authentication layer to pull team discussions and monitoring context into agent sessions. With the platform's user base exceeding 225 million registered developers, these features aim to reduce manual administrative overhead across complex codebases. Copilot Projects expands these workflows by enabling developers to connect multiple organizational repositories into a single unified workspace. Instead of requiring human engineers to manually coordinate agent tasks, the system dispatches autonomous fleets of specialized agents directly to target repositories where migrations, testing, or code edits are needed. GitHub announced that Copilot Projects is immediately generally available to all developers. Copilot Fusion and Multi-Model Routing (1:26) To handle incoming programming tasks efficiently, GitHub presented Copilot Fusion, a dynamic meta-orchestrator that routes workloads across models rather than relying on a single engine. Fusion evaluates task complexity and selects between three operational strategies: a single-model run for simple requests, a tiered cascade pattern, or a critique pattern where multiple models cross-verify and refine code. According to Jay, this coordination aims to deliver frontier-tier results while controlling resource costs. In benchmark testing on the Artificial Analysis Coding Agent Index, GitHub reported that Copilot Fusion Max achieved a score of 60, trailing Opus 5.5 Max by two points while halving cost per task and decreasing execution time by 40%. GitHub announced a promotional 30% usage discount for Fusion through the end of November to encourage adoption. Cross-Surface Sessions and Expanded Code Review (3:43) Addressing developer continuity across varied working environments, GitHub demonstrated sessions that launch in isolated cloud sandboxes from mobile devices and resume without state loss across web, terminal CLI, and VS Code surfaces. This continuity is powered by a standardized Copilot harness deployed across Microsoft and made available for custom agent development on Microsoft Foundry. For operational defense, the workflow links real-time Sentry alert telemetry with automated code scanning, secret scanning, and AI-assisted push protection to guide vulnerability remediation. In pull request workflows, GitHub launched Code Review Max, its deepest static analysis tier. Damian reported that Copilot Code Review has reached 200 million findings to date, and claimed that Code Review Max posted the highest F1 score on the ReviewBench benchmark for high-severity issues. The core review functionality has also been made universally available to developers without requiring a paid Copilot subscription. Re-Engineering Git Storage for Parallel Writes (5:51) To accommodate the high-volume write demands created by thousands of concurrent AI agents, GitHub restructured Git's underlying hosting architecture. Historically, an incoming push locked the entire repository, capping throughput at dozens of pushes per second and causing severe contention across data centers when latency hovered around 25 milliseconds. The rebuilt storage layer replaces global repository locks with branch-specific write coordination, allowing parallel agent fleets operating on independent branches to push simultaneously. April noted that this change increases write throughput by three to four times, elevating ingestion capacity to thousands of concurrent pushes per second per repository. The redesigned infrastructure was validated against production workloads in partnership with OpenClaw, one of GitHub's highest-velocity open-source repositories. GitHub positioned these updates as an end-to-end realignment of its platform for an agentic era, connecting lower-level branch locking with high-level multi-model and multi-repository management. The presentations relied on internal testing and partner validations, leaving real-world performance across diverse third-party enterprise environments to be demonstrated as adoption expands.

Source quotes

[1:26] Jay: Fusion coordinates between multiple models to deliver frontier level results at a lower cost, in fact. [2:06] Burke: Y’all, nobody likes micromanaging agents. With Copilot Projects, you get to get out of that business completely so that you can just focus on the results..

Original transcript

[0:00] Jay: Welcome to Universe. [0:03] When we were here last year, [0:04] we talked about [0:05] how 2026 was going to be the year [0:08] where developers and all of their agents [0:11] showed up for work on GitHub. [0:13] There are now over 225 million [0:18] developers on GitHub. [0:19] The delta between [0:21] 2024 and 2026 is remarkable. [0:25] As you can see [0:26] from this visualization of Actions jobs. [0:30] And today, [0:30] we’re going to show you [0:31] some of these primitives at work. [0:33] So let’s welcome Cassidy to the stage [0:35] to take us through it. [0:39] Cassidy: I’m very excited to show you [0:41] what we’re going to build. [0:42] So, hello. [0:43] Hello. [0:44] Let’s get some work done. [0:45] So this is the GitHub Copilot app. [0:48] If you haven’t seen it yet, [0:49] it’s a really awesome [0:50] single location [0:51] for working with agents [0:52] across multiple projects, [0:54] integration with external tools, automations, [0:56] and so much more. [0:57] Now, I just asked my coworker Seth [1:01] about this passport feature [1:02] because with these open questions [1:03] we need to get answers to them. [1:05] And how is it possible [1:07] that we’re able to get these answers [1:08] right here in the app, Jay? [1:09] Jay: We can use connectors. [1:11] And connectors are these managed services [1:13] that sit in the Copilot app [1:14] or whatever surface. [1:16] And they connect to services like Slack, [1:18] Work IQ, Vercel, Netlify and Sentry. [1:21] So you can authenticate [1:23] in one place [1:23] and then use them across [1:24] all of your surfaces. [1:26] Cassidy: So Jay, what should I pick? [1:27] Jay: You should use Copilot Fusion. [1:30] Okay. [1:30] Fusion coordinates [1:32] between multiple models [1:33] to deliver frontier [1:35] level results at a lower cost, in fact. [1:37] It decides [1:38] what task it requires, [1:39] and then it picks [1:40] the optimal execution pattern. [1:42] There’s three. [1:43] There’s single, cascade, or critique. [1:46] Recently in Artificial Analysis [1:48] Coding Agent Index, [1:50] Copilot Fusion Max scored 60. [1:53] And that’s [1:54] within two points of Opus 5.5 Max. [1:57] Now it did [1:59] all of this at half the cost per task [2:02] and at 40% less time per task. [2:06] Burke: Hey, Jay. Hey, everybody. [2:07] Good morning. [2:08] Thank you so much [2:09] for bringing me out here [2:10] to talk about Copilot Projects. [2:12] It is my favorite way [2:14] to work with GitHub Copilot, [2:16] and I’m excited [2:17] to show it to you [2:18] on my brand new Surface Laptop Ultra. [2:21] All right, [2:21] so what I want to do to get started [2:23] here is just create a project [2:24] right here [2:25] in the sidebar of the GitHub Copilot app. [2:28] And then once we do that, [2:30] we can go ahead and add [2:31] in the Fourth Coffee repositories [2:34] right here as context. [2:36] Jay: So, work like Burke is doing right now [2:39] often involves multiple repos. [2:41] And with Projects, Copilot spins up [2:44] as many agents [2:45] as it needs to tackle this feature, [2:47] and it will assign [2:48] those agents [2:49] depending on [2:50] whatever repo [2:51] the task needs to be completed in. [2:52] Burke: Y’all, [2:53] nobody likes micromanaging agents. [2:57] With Copilot Projects, [2:58] you get to get out of [2:59] that business completely [3:00] so that you can just focus [3:01] on the results.. [3:02] Jay: Exactly. [3:03] And when we talk [3:04] about increasing velocity, [3:05] this is a kind of thing [3:06] we’re talking about. [3:07] And I’m excited to announce that today, [3:10] GitHub Copilot Projects is available [3:12] to everyone. [3:16] Thank you, Burke. [3:17] And thank you Cassidy. [3:18] That was super fun. [3:19] So you just saw [3:21] some of the newest building blocks from [3:23] and for your agentic software delivery system. [3:26] Now, one additional note today: [3:28] Today, through the end of November, [3:30] we want you to try Copilot Fusion. [3:32] So usage will be 30% off. [3:35] So give it a try. [3:43] Jay: What’s going on? [3:43] Damian: There’s a bug in the app, right? [3:45] So the “order ahead” [3:47] feature stops taking orders [3:48] before a cafe closes, [3:49] which is right, [3:50] but the site doesn’t tell the customer. [3:52] So, I can start a Copilot session [3:54] to fix this from my phone. [3:55] And it spins up a session [3:57] in a cloud sandbox, [3:58] which allows me to pick it up later. [4:00] Jay: Thanks. [4:00] So, we want to make sure [4:02] that you have strong [4:03] continuity across all the surfaces, [4:06] so you can start a task on your phone, [4:08] pick it up from the app, [4:09] move it to VS Code, or the CLI [4:11] or dot com, wherever you are. [4:13] Now this is all [4:14] powered by the same Copilot harness, [4:17] which has also been rolled out [4:19] across all of Microsoft. [4:20] And starting today, [4:22] you can take this harness [4:23] and you can build an agent [4:24] for whatever you want to do [4:26] on Microsoft Foundry, as well. [4:27] Damian: So I can move on to [4:28] the next thing that needs my attention. [4:30] And it looks like there is an error [4:31] with the “how ordering works” button, [4:33] so I’ll just have a quick [4:34] look how ordering works on our page. [4:37] Sure enough, [4:38] that was a very fast 500 error. [4:39] Okay, [4:40] now I can see the details of that error [4:43] in a custom canvas. [4:44] So if I open this session, [4:46] we are using Sentry [4:47] in our production system [4:48] to monitor these issues. [4:50] And we can see right here [4:51] there’s an alert. [4:52] So I could create an issue here [4:55] or fix it with Copilot, but [4:57] GitHub code scanning [4:58] can scan through our entire codebase [5:01] to look for vulnerabilities [5:02] in new and existing code. [5:04] For example, [5:05] when we find a vulnerability, [5:07] we get all of this information [5:08] about where in the code [5:09] the vulnerability is, [5:11] what type of vulnerability it is, [5:13] and how we would typically [5:14] fix that vulnerability. [5:16] So between [5:17] secret scanning and AI push protection, [5:20] our security posture is a lot better. [5:22] Copilot Code Review we launched last year [5:24] and so far [5:25] it has surfaced [5:26] 200 million findings for developers. [5:29] And today, [5:30] we’re introducing our deepest level [5:32] of review yet. [5:33] Code Review Max. [5:35] Now Max is a big step forward. [5:37] It posted the highest F1 score [5:40] on ReviewBench for high severity issues. [5:43] Copilot Code Review is also available [5:46] to everyone [5:47] without a Copilot subscription. [5:51] April: You just saw, [5:52] what one [5:53] developer can do with a fleet of agents. [5:55] Now imagine that across [5:57] every developer [5:58] and every repository. [6:00] Every agent session [6:02] creates branches, reads history, [6:05] and pushes changes, [6:06] often all at the same time. [6:08] And all of that activity lands on Git. [6:11] So, we have been rebuilding [6:14] the foundation underneath Git. [6:17] First, [6:17] we remove the immediate bottleneck: [6:19] physical hosting. [6:21] For roughly [6:22] 100 of the busiest repositories, [6:24] even 25 milliseconds between data [6:27] centers mattered. [6:28] So, we changed how Git coordinates writes. [6:31] Instead of locking an entire repository [6:34] for every write, [6:35] we lock only the branch being updated. [6:38] Agents working on different [6:39] branches can now move in parallel, [6:41] delivering 3 to 4 times [6:44] more write throughput. [6:45] The old architecture [6:46] topped out [6:46] at dozens of pushes [6:48] a second on a single repository. [6:50] This one is designed for thousands. [6:53] And on reads, our own load [6:55] testing harness [6:56] hit its own limits [6:57] before the new architecture did. [6:59] But look, benchmarks [7:01] only take you so far. [7:02] So, we wanted real traffic. [7:04] We partnered with OpenClaw, [7:05] one of the busiest open [7:06] source projects on GitHub, [7:08] and we caught up with Peter Steinberg, [7:10] the creator of OpenClaw. [7:11] Peter: GitHub is being able to tell us [7:13] when something is ready, [7:14] that you’re building the foundation [7:15] for that right now [7:16] and it will solve [7:18] pretty much all our existing problems. [7:20] Jay: We’ve shown you a lot this morning, [7:23] and we’ve shown you how we’re evolving [7:26] every layer [7:26] of the GitHub stack for this agentic era. [7:30] We’ve shown you how it comes to life [7:33] in our new Git architecture, [7:35] and in new tools like Copilot Fusion, [7:38] and the continuity [7:39] across all the surfaces [7:41] you use like VS Code, to the CLI [7:45] to the new GitHub Copilot app. [7:47] I can’t wait to see what you build. [7:49] Thank you and have an awesome Universe.