GitHub
As autonomous coding agents collapse traditional development workflows and overwhelm legacy repositories, GitHub is rebuilding Git's underlying architecture on Azure while shifting enterprise access to usage-based AI credits.
AI-assisted summary of Opening keynote: building the next era of software at GitHub Universe 2026 — original source. Check the original for full context.
Source published:
Key ideas
- GitHub has crossed 225 million registered developers and recorded 34.3 billion commits in 2026, driven by a structural shift toward agentic software development where developers orchestrate autonomous AI squads. (0:13)
- GitHub unveiled Copilot Projects and Copilot Automations, expanding AI assistance from single-session coding into multi-repo orchestration that can triage incidents from Sentry alerts and generate PRs autonomously. (14:55)
- Copilot Fusion coordinates dynamic model routing across single, cascade, and critique strategies, achieving near parity with frontier models while reducing compute costs by 50% and task execution times by 40%. (9:39)
- To support intense agent concurrency, GitHub overhauled its core Git architecture to decouple compute from storage on Azure Blob Storage, hitting 7,200 writes per second in stress tests with 5,000 parallel agents. (33:22)
- GitHub Enterprise accounts now receive access to all Copilot capabilities, including the Copilot app and automated code review, without dedicated seat licenses via a consumption-based AI credits model. (29:42)
Detailed notes
## Background Published on YouTube by GitHub on October 28, 2026, this opening keynote from GitHub Universe 2026 examines the next era of software development driven by autonomous agents. Presented by engineering leaders including Jay Parikh, Cassidy Williams, Burke Holland, Damian Brady, and April Leonard, the presentation showcases major updates across GitHub Copilot, agent orchestration workflows, and core developer tools.
## TL;DR Addressing an explosive surge to over 225 million developers and billions of agentic contributions, GitHub unveiled an end-to-end agentic delivery platform designed around a collapsing, non-linear software development lifecycle. Key product updates include the dedicated GitHub Copilot app, Copilot Fusion for dynamic multi-model routing, Copilot Dreaming and Memories for codebase instruction maintenance, Copilot Projects for multi-repo orchestration, and cloud-native Copilot Automations. To maintain quality and security at high velocity, GitHub introduced AI push protection, Agentic Autofix, Code Review Max, and a consumption-based pricing model for GitHub Enterprise. Finally, GitHub announced a fundamental overhaul of Git's underlying architecture, decoupling compute from Azure Blob Storage and introducing branch-level locking to handle thousands of concurrent agent writes per second.
## Atmosphere & style The presentation carries the polished, high-energy momentum of a flagship developer conference, blending rapid-fire live demos with playful stage banter about coffee puns, doomscrolling, and agents complaining about traffic. Presenters balance excitement over staggering growth statistics with candid humility regarding recent platform reliability challenges under intense load. The pacing moves briskly from developer UX features to deep storage infrastructure engineering, leaving listeners with an inspiring, forward-looking sense of developer empowerment in an agent-dominated era.
## Bulletin - [00:13](https://www.youtube.com/watch?v=AArI948SDz8&t=13s) GitHub has crossed 225 million registered developers and recorded 34.3 billion commits in 2026, driven by a structural shift toward agentic software development where developers orchestrate autonomous AI squads. - [14:55](https://www.youtube.com/watch?v=AArI948SDz8&t=895s) GitHub unveiled Copilot Projects and Copilot Automations, expanding AI assistance from single-session coding into multi-repo orchestration that can triage incidents from Sentry alerts and generate PRs autonomously. - [09:39](https://www.youtube.com/watch?v=AArI948SDz8&t=579s) Copilot Fusion coordinates dynamic model routing across single, cascade, and critique strategies, achieving near parity with frontier models while reducing compute costs by 50% and task execution times by 40%. - [33:22](https://www.youtube.com/watch?v=AArI948SDz8&t=2002s) To support intense agent concurrency, GitHub overhauled its core Git architecture to decouple compute from storage on Azure Blob Storage, hitting 7,200 writes per second in stress tests with 5,000 parallel agents. - [29:42](https://www.youtube.com/watch?v=AArI948SDz8&t=1782s) GitHub Enterprise accounts now receive access to all Copilot capabilities, including the Copilot app and automated code review, without dedicated seat licenses via a consumption-based AI credits model.
## Key takeaways - [03:26](https://www.youtube.com/watch?v=AArI948SDz8&t=206s) Developer workflows have transformed from AI-assisted code completion into orchestrating dozens of agentic workflows, causing the traditional sequential software development lifecycle to collapse. - [06:10](https://www.youtube.com/watch?v=AArI948SDz8&t=370s) The GitHub Copilot app serves as a central hub for agent workflows, utilizing verified enterprise Connectors (Slack, Sentry, Vercel) to eliminate manual context switching. - [09:39](https://www.youtube.com/watch?v=AArI948SDz8&t=579s) Copilot Fusion dynamically routes tasks across models using single, cascade, or critique patterns to maximize quality while significantly cutting compute cost and runtime. - [09:39](https://www.youtube.com/watch?v=AArI948SDz8&t=579s) Copilot Canvases provide interactive runtime surfaces where autonomous agents can operate web browsers, terminals, and custom user interfaces to test and verify code changes visually. - [12:46](https://www.youtube.com/watch?v=AArI948SDz8&t=766s) Copilot Dreaming addresses prompt and context drift by continuously opening pull requests in the background to keep agent instruction files aligned with codebase changes. - [14:55](https://www.youtube.com/watch?v=AArI948SDz8&t=895s) Copilot Projects is now generally available, enabling developers to feed multimodal inputs (design mocks, Slack logs, compliance notes) into an orchestrator that delegates tasks to subagents across multiple repositories. - [18:51](https://www.youtube.com/watch?v=AArI948SDz8&t=1131s) A shared Copilot harness ensures session continuity across GitHub Mobile, the desktop app, VS Code, and CLI environments, backed by persistent cloud sandboxes. - [22:15](https://www.youtube.com/watch?v=AArI948SDz8&t=1335s) Copilot Automations function as cloud-native engineering squads that trigger on schedules, webhooks, or telemetry alerts to autonomously reproduce bugs, triage issues, and propose remediations. - [24:53](https://www.youtube.com/watch?v=AArI948SDz8&t=1493s) AI push protection detects and blocks exposed credentials locally at the git push boundary without relying on manually configured regular expression patterns. - [26:23](https://www.youtube.com/watch?v=AArI948SDz8&t=1583s) Code Review Max achieved the highest F1 score on ReviewBench for high-severity defects, reviewing PRs automatically before human engineers step in. - [26:23](https://www.youtube.com/watch?v=AArI948SDz8&t=1583s) Agent Merge continuously works behind the scenes to update stale pull requests, resolve git merge conflicts, and fix failing CI checks before executing final merges. - [29:42](https://www.youtube.com/watch?v=AArI948SDz8&t=1782s) GitHub Enterprise commercial licensing shifted to unseat-bound access for all Copilot features, billing organizations solely through consumption-based AI credits. - [35:53](https://www.youtube.com/watch?v=AArI948SDz8&t=2153s) GitHub's core Git engine was redesigned around branch-level write locking, ephemeral caching compute, and durable Azure Blob Storage to prevent repository-wide lock bottlenecks under heavy agent traffic. - [37:49](https://www.youtube.com/watch?v=AArI948SDz8&t=2269s) All GitHub repositories are scheduled to migrate to the next-generation decoupled Git storage architecture by early next year. - [40:00](https://www.youtube.com/watch?v=AArI948SDz8&t=2400s) Even as agentic generation scales exponentially, developer judgment remains the foundational constraint and guiding force for defining problems and evaluating software impact.
## Detailed walkthrough ### [00:13](https://www.youtube.com/watch?v=AArI948SDz8&t=13s) GitHub's Explosive Growth & the Agentic Shift
Jay Parikh, head of the GitHub team and the broader CoreAI team at Microsoft, opens GitHub Universe in San Francisco by reflecting on the prophecy from the previous year: 2026 was supposed to be the moment developers brought their agents to work on GitHub. The data demonstrates that they arrived at staggering scale. GitHub now hosts over 225 million developers globally across every country, adding a new developer every single second for the second consecutive year.
The Octoverse metrics illustrate an unprecedented surge in code velocity. Commits rose to 34.3 billion, code pushes reached 17.9 billion, and pull requests climbed to 1.3 billion. Open-source activity similarly accelerated to 2.5 billion contributions across 566 million open-source and public repositories—a year-over-year increase exceeding 30%. Highlighting projects making an impact, Parikh points out Ersilia (open-source, AI-powered drug discovery tools), OpenQuake by the Global Earthquake Model Foundation (earthquake hazard assessment software), and AI Skills by Matt Pocock (reusable instructions for coding agents to avoid common mistakes). Reviewing the visual curve of GitHub Actions jobs, Parikh admits that the steepness of the curve is almost intimidating.
> “Now this type of growth rate is extremely rare. It's pretty scary. It's being driven by the shift to Agentic software development.” — Jay Parikh
- Over 225 million registered developers worldwide; 1 new user per second for two consecutive years - 34.3 billion commits, 17.9 billion pushes, and 1.3 billion pull requests recorded in 2026 - 566 million open-source and public repositories, growing over 30% year over year - Key featured projects: Ersilia (drug discovery), OpenQuake (hazard mapping), and AI Skills by Matt Pocock (agent instruction sets)
[03:26](https://www.youtube.com/watch?v=AArI948SDz8&t=206s) Evolving for the Agentic Era
Developer workflows have transformed from hand-crafted code to AI-assisted editing, and now into the orchestration of dozens or hundreds of agentic workflows. Because work is continuously triggered by external signals—such as production incidents or team requests—the traditional software development lifecycle is no longer a linear sequence; the stages are collapsing into one another. To support this paradigm, GitHub is rebuilding its stack around a central learning machine that addresses three pillars:
1. **Velocity:** Transitioning from concept to production rapidly, efficiently, and cost-effectively. 2. **Intelligence:** Gathering organization-wide context into a continuous learning loop that improves future runs. 3. **Quality:** Preventing security vulnerabilities and functional defects from reaching production while maintaining extreme speed.
Parikh asserts that GitHub is building the industry's most complete end-to-end agentic delivery platform, while keeping the platform extensible so teams can incorporate external tools like Datadog, Figma, and Cloudflare.
> “The SDLC is no longer linear. In fact, the SDLC is collapsing. Most of us jump between these different stages depending on the task.” — Jay Parikh
```mermaid flowchart TD accTitle: The Agentic Software Delivery System accDescr: Diagram illustrating how signals trigger collapsed SDLC stages around a central learning machine.
subgraph Triggers["Triggers & Context"] S["Signals & Events"] C["Colleague Requests / Production"] end
subgraph CoreEngine["Agentic Core Delivery System"] CLM["Central Learning Machine"] V["Velocity<br>(Idea to Production)"] I["Intelligence<br>(Platform-Wide Context)"] Q["Quality<br>(Security & Bug Prevention)"] end
subgraph Ecosystem["Open Ecosystem"] EXT["Datadog, Figma, Cloudflare, etc."] end
S --> CLM C --> CLM CLM <--> V CLM <--> I CLM <--> Q CLM <--> EXT ```
[06:10](https://www.youtube.com/watch?v=AArI948SDz8&t=370s) The GitHub Copilot App & Connectors
Cassidy Williams joins the stage to demonstrate these capabilities using a real project: building a "coffee passport" feature for a coffee shop chain's platform. The feature rewards customers who visit and collect stamps across all store locations with free treats. Opening the GitHub Copilot app—a unified workspace for managing agents across projects, integrations, and automations (which also includes a hidden Easter egg minigame)—Williams inspects an issue that contains unresolved requirements regarding repeat visits.
Instead of switching back and forth between messaging and task-tracking tools, Williams resolves these questions directly within the Copilot app. This is powered by Connectors: managed services that integrate external applications like Slack, Microsoft Work IQ, Vercel, Netlify, and Sentry. Once authenticated with a verified badge, Connectors allow agents to securely pull context and cross-reference answers across all development surfaces without forcing developers to leave their workspace.
> “We can use connectors, and connectors are these managed services that sit in the Copilot app or whatever surface... So you can authenticate one place and then use them across all of your surfaces.” — Jay Parikh
- GitHub Copilot app serves as a centralized hub for multi-project agent orchestration, tool integration, and automations - Managed Connectors link verified enterprise systems including Slack, Work IQ, Vercel, Netlify, and Sentry - Single authentication step allows agents to retrieve company-wide context, eliminating manual context switching
[09:39](https://www.youtube.com/watch?v=AArI948SDz8&t=579s) Copilot Fusion, App Canvases & Copilot Dreaming
To implement the issue, Williams must choose a model. Parikh advises selecting Copilot Fusion, a routing system that coordinates across multiple AI models using three distinct execution strategies: single, cascade, or critique. In benchmarks like the Artificial Analysis Coding Agent Index, Copilot Fusion Max scored 60—within two points of Claude 3.5 Opus Max—while cutting compute cost in half and finishing tasks 40% faster.
Switching to a live session with an end-to-end implementation ready for testing, Williams checks Parikh’s demo passport profile. When asked about his drink preference, Parikh jokes that his standard order is just "plain coffee, nothing in it." Williams demonstrates agent-driven visual testing inside what appears to be an embedded browser, but is actually an interactive Copilot Canvas. Canvases allow autonomous agents to operate terminal environments, web browsers, and custom user interfaces directly.
As the agent navigates the web interface, Williams mentions an underlying technical hurdle: the application had recently been migrated from Java to SvelteKit (drawing light laughter from the crowd over the coffee pun). While the underlying code had been completely rewritten, the original developer instructions had fallen out of sync. To show how GitHub handles stale context, Williams tees up the PR inspection and asks Parikh to explain a new Copilot capability called "Dreaming."
> “Fusion coordinates between multiple models to deliver frontier level results at a lower cost. In fact, it decides what task requires, and then it picks the optimal execution pattern.” — Jay Parikh
- Copilot Fusion dynamically selects from three patterns: single model, model cascade, or critique - Artificial Analysis benchmark: Copilot Fusion Max achieved a score of 60, achieving parity with frontier models at 50% lower cost and 40% less execution time - Canvases provide interactive runtime surfaces (browser, terminal, custom) where autonomous agents can execute live workflows and self-verify UI features
[12:46](https://www.youtube.com/watch?v=AArI948SDz8&t=766s) Copilot Dreaming and Memories
Keeping instructions effective for autonomous agents over time presents a common trap: teams write detailed guidance, but within a few weeks the codebase drifts, newer and more capable models arrive, and the outdated prompts begin degrading performance rather than helping. Copilot Dreaming tackles this problem directly by operating in the background to ensure instructions and persistent memories continuously match the developer's current preferences and the modern state of the code.
```mermaid flowchart LR accTitle: Copilot Dreaming Background Sync accDescr: Process showing Copilot Dreaming updating instructions and memories via pull requests. subgraph S1["Code Evolution"] A["New Models & Changes"] --> B["Codebase Drifts"] end subgraph S2["Copilot Dreaming"] B --> C["Dreaming Engine"] C --> D["Updated Instructions"] C --> E["Updated Memories"] end subgraph S3["Developer Review"] D --> F["Pull Request Diff"] E --> F F --> G["Up-to-Date Agent Guidance"] end ```
On stage, Cassidy Williams reviews a pull request automatically generated by Copilot Dreaming. The PR diff cleans up an outdated instructions file to align with their modern, non-Java-based environment. While Cassidy jokes about how descriptive and verbose agents have become when summarizing their work, the real benefit lies in team-wide consistency: any agent picking up a new task automatically inherits accurate architectural decisions. Alongside instruction files, Copilot updates its store of learned memories—the accumulated record of personal preferences and team coding practices. Cassidy highlights being exceptionally particular about code standards:
> “Dreaming goes back and ensures that your instructions and memories always reflect your preferences, which I think you have a few.” — Jay Parikh
> “I'm very picky about my code base, and so it's really nice to be able to have all of these so that I get better outputs.” — Cassidy Williams
After confirming that the "fresh out of the oven" feature is running and authenticated properly, Cassidy inspects the code directly in VS Code before pivoting from managing individual agent sessions to orchestrating higher-level work across multiple repositories.
- Copilot Dreaming opens pull requests to synchronize agent instructions with changing architectures and newer LLMs. - Copilot Memories capture individual and team coding preferences to tailor future agent completions automatically. - Developers retain full control, reviewing instruction diffs in PRs and opening changes directly inside VS Code.
---
[14:55](https://www.youtube.com/watch?v=AArI948SDz8&t=895s) Copilot Projects and Orchestrated Multi-Repo Workflows
Burke Holland joins Jay Parikh on stage with his new Surface Laptop to demonstrate Copilot Projects, a workflow designed to relieve developers from manually driving single agent sessions. Burke initiates a project directly from the GitHub Copilot desktop app sidebar and binds all Fourth Coffee repositories into the session context. His goal is building a "Your Usual" feature that lets customers reorder their favorite coffee with a single tap.
Instead of guiding one agent loop step-by-step, Burke feeds multi-modal context into the Copilot orchestrator in rapid succession: high-fidelity design mocks, a Slack thread hammering out the implementation details, and notes from a Microsoft Teams meeting with legal and compliance regarding personalization rules. The Copilot orchestrator absorbs the stream of requests without requiring the developer to wait for individual tasks to resolve, spinning up new subagents across repositories as needed.
```mermaid flowchart TD accTitle: Copilot Projects Orchestration accDescr: How Copilot Projects orchestrates multiple repos, context sources, and subagents. subgraph Inputs["Context Streams"] A["Fourth Coffee Repos"] B["Design Team Mocks"] C["Slack Technical Debates"] D["Teams Legal/Compliance Call"] end subgraph Engine["Copilot Projects"] Inputs --> E["Copilot Orchestrator"] E --> F["Subagent: Frontend"] E --> G["Subagent: Backend Services"] E --> H["Subagent: Marketing Demos"] end subgraph Outputs["Results"] F --> I["Automated PRs in Project Overview"] G --> I H --> J["Pixel-Perfect Video Artifacts"] end ```
Burke explains that shipping software requires far more than raw code. Copilot can also produce peripheral assets; using custom skills, it generates pixel-perfect demo videos for marketing teams before the pull request even merges. Burke configures an automation to produce these preview videos daily upon feature completion. Because agents execute both locally and inside cloud sandboxes, developers can simply close their laptops while the squad completes implementation and opens pull requests.
> “He's actually working with the Copilot orchestrator here so he can keep firing them off, and Copilot will spin up new Subagents to tackle these requests.” — Jay Parikh
> “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 Holland
> “And I'm excited to announce that today GitHub Copilot projects is available to everyone.” — Burke Holland
- Copilot Projects natively spans multiple repositories, spinning up and assigning subagents based on the location of the codebase work. - Context injection handles diverse inputs in parallel, including design mocks, Slack chat logs, and compliance call notes. - Copilot generates non-code deliverables, such as pixel-perfect application demo videos for marketing teams. - Execution operates locally or across cloud environments, updating progress and pull requests in a unified project view. - Copilot Projects is announced as generally available to all developers.
---
[18:51](https://www.youtube.com/watch?v=AArI948SDz8&t=1131s) Copilot Fusion and Cross-Surface Continuity
Jay Parikh synthesizes the architectural pillars powering this agentic delivery system: the new GitHub Copilot desktop app acts as an agent-native environment, Copilot Projects sets broad goals across repositories, and Copilot Fusion dynamically selects the optimal model for each step of an assignment to deliver high performance at lower inference cost. To encourage adoption, Parikh announces that Copilot Fusion usage is discounted by 30% through the end of November.
Yet higher agent velocity introduces an operational dilemma: an explosion of code creates an overwhelming volume of pull requests, security audits, and deployment reviews that threaten to compromise engineering standards.
```mermaid flowchart LR accTitle: Cross-Surface Agent Continuity accDescr: Continuity flow across mobile, cloud sandboxes, and developer workstations. A["Phone (GitHub Mobile)"] -->|"Start agent triage"| B["Cloud Sandbox"] B -->|"Persistent Session"| C["VS Code / GitHub Desktop"] C -->|"Deploy / Delegate"| D["Copilot Automations"] ```
Damian Brady takes the stage to address maintaining quality and speed, walking out with his phone and joking that he is doing real work rather than doomscrolling. He demonstrates tackling a production bug in the Fourth Coffee ordering app: while the ordering system correctly halts orders before closing time, it fails to notify users. Brady triggers an agent triage session straight from his mobile device, which instantly initializes within a persistent cloud sandbox. Parikh notes that this seamless cross-device continuity—bridging mobile, the Copilot app, VS Code, and CLI workflows—is built upon the standardized Copilot harness deployed throughout Microsoft and now accessible to developers building custom agents on Microsoft Foundry.
> “Today, through the end of November, we want you to try Copilot fusion. So usage will be 30% off.” — Jay Parikh
> “So we want to make sure that you have strong continuity across all the surfaces. So you can start a task on your phone, pick it up from the app, move it to VS Code or the CLI or wherever you are.” — Jay Parikh
> “The agent has a clear direction forward, which means that I can pick up some other work and do something else that needs my focus because I'm not short on agents. J I'm short on attention and time.” — Damian Brady
- Copilot Fusion provides dynamic multi-model selection per task step to optimize inference costs and execution speed. - A 30% discount on Copilot Fusion runs through the end of November. - The shared Copilot harness guarantees session continuity across mobile devices, desktop apps, VS Code, and CLIs. - Microsoft Foundry now provides public developer access to the underlying Copilot agent harness.
---
[22:15](https://www.youtube.com/watch?v=AArI948SDz8&t=1335s) Copilot Automations and Autonomous Incident Remediation
Switching from his phone to VS Code on stage, Damian Brady demonstrates how the mobile session transitioned seamlessly to his desktop, complete with pre-generated architecture diagrams and proposed code patches. With a quick prompt instructing the agent to file a pull request upon completion, Brady delegates the fix and moves on, noting that human cognitive bandwidth is strictly single-threaded and the limiting factor in development.
Turning his focus to a broken "How ordering works" button on their web page, Brady encounters an instant HTTP 500 server error. Opening a custom troubleshooting canvas linked to Sentry production monitoring, he views the live error telemetry. Rather than manually clicking through dashboards to log tickets or draft fixes, Brady introduces Copilot Automations—a framework designed to let AI squads handle triage and delegation workflows independently. Jay Parikh explains that these cloud-native automations execute on schedules, ingest direct API triggers, or respond to repository and telemetry webhooks, functioning as an automated frontline engineering squad.
```mermaid flowchart TD accTitle: Copilot Automations Incident Response accDescr: Automated telemetry response via Copilot Automations from alert to PR. A["Production Error (HTTP 500)"] --> B["Sentry Monitoring Canvas"] B --> C{"Copilot Automation Trigger"} C -->|"Scheduled"| D["Cloud Agent Squad"] C -->|"Webhook / API"| D C -->|"Manual Run"| D D --> E["Triage & Root-Cause Diagnosis"] D --> F["Automated Pull Request & Remediation"] ```
> “Sure enough, that was a very fast 500 error. Okay, now I can see the details of that error in a custom canvas. So if I open this session, we are using Sentry in our production system to monitor these issues.” — Damian Brady
> “Copilot Automations lets you create AI powered workflows to work in your Repo. And they run in the cloud and you can respond to an event with it. You can run on a schedule, or it can be triggered manually to act as a squad of agents for you and your team.” — Jay Parikh
- Custom canvases integrate observability services like Sentry directly alongside Copilot agent workspaces. - Copilot Automations trigger via REST APIs, system webhooks, predefined schedules, or manual invocation. - Background agent squads run in the cloud to manage event-driven bug triage, issue tracking, and repetitive codebase chores.
[23:37](https://www.youtube.com/watch?v=AArI948SDz8&t=1417s) Orchestrating Cloud Automations and Specialist Agents
Damian Brady demonstrates how GitHub's new automations operate in the cloud, freeing developers from keeping laptops open overnight while maintaining strict operational guardrails. Developers can granularly configure permitted tool actions—such as granting an agent permission to draft pull requests while forbidding it from merging them. To prevent runaway costs, developers set explicit spend limits so agents do not exhaust allocated AI credits. Damian then showcases a subscriptions repository where an orchestrated chain of specialist agents works collaboratively to eliminate routine engineering toil. Rather than relying on a single monolithic model, the pipeline divides responsibilities across dedicated automations that handle each stage of the lifecycle.
```mermaid flowchart LR accTitle: Specialist Agent Automation Pipeline accDescr: Pipeline showing signals turning into verified fixes across specialist automations. A["Watch Signals & Create Issue"] --> B["Triage Issue"] B --> C["Reproduce & Capture Screenshots"] C --> D["Generate Fix"] D --> E["Verify Fix against Request"] ```
- Automations run fully in the cloud with strict spending caps to guarantee agents do not burn credits unexpectedly. - Specialist agents handle distinct tasks: monitoring incoming signals, triaging tickets, reproducing bugs with visual screenshots, generating code fixes, and verifying the resolution against original issue requirements. - Reflecting on how this shift changes day-to-day engineering, Damian notes: “Now, a process like this means that I can automate away a lot of the toil that I have, and so I can focus on the things that actually require my attention.”
[24:53](https://www.youtube.com/watch?v=AArI948SDz8&t=1493s) Proactive Security: AI Push Protection and Agentic Autofix
The demonstration transitions to security posture, highlighting enhancements to GitHub code scanning. Supported by broadened AI language capabilities, code scanning analyzes both legacy code and newly submitted changes to surface vulnerabilities alongside context on where the flaw exists, its vulnerability class, and standard remediation paths. Developers can delegate these alerts directly to Agentic Autofix, which ingests the diagnostic context and generates a pull request with an end-to-end fix ready for review.
To catch sensitive data even earlier in the developer workflow, GitHub incorporates AI push protection directly into git operations. Damian simulates accidentally committing a credential into a local file and running `git push`. Without relying on predefined regular expression patterns, the AI detects the secret and blocks the push locally before the commit ever reaches the remote repository.
- Code scanning surfaces vulnerability locations, classifications, and remediation steps, which Agentic Autofix converts into mergeable pull requests. - AI push protection prevents credential exposure proactively at the push boundary without requiring manually configured regex secret patterns.
[26:23](https://www.youtube.com/watch?v=AArI948SDz8&t=1583s) Copilot Code Review Max, Stacked PRs, and Agent Merge
Turning to code quality, Damian reviews a pull request created by Cassidy Williams' team for the coffee passport service endpoint, pointing out that GitHub Copilot acts as an automated reviewer on every pull request before any human engineer steps in. Jay Parikh steps in to provide context on the momentum behind Copilot Code Review and introduces its newest tier:
> “Copilot Code Review, we launched last year and so far it has surfaced 200 million findings for developers. And today we're introducing our deepest level of review yet. Code review Max. Now Max is a big step forward. It posted the highest F1 score on ReviewBench for high severity issues.”
Jay adds that Copilot Code Review is accessible even to developers without a standalone Copilot subscription through consumption-based AI credits. Damian then addresses the complexity of modern multi-part features by presenting stacked pull requests. Cassidy's feature is divided into three dependent PR layers—the UI changes, the service endpoint, and the data schema migrations—which can be reviewed and merged incrementally or all at once. Finally, Damian activates Agent Merge to combat stale pull requests. Agent Merge operates in the background to incorporate feedback, resolve merge conflicts, and remediate failing CI checks, automatically merging the PR once all checks pass. Damian remarks: “It's automated, it's organized, and it's secure from start to finish.”
```mermaid flowchart TD accTitle: Stacked Pull Request Architecture accDescr: Hierarchy of dependencies within a stacked pull request. subgraph Stack["Stacked Pull Requests"] PR1["Layer 3: UI Changes"] PR2["Layer 2: Service Endpoint Dependency"] PR3["Layer 1: Data Changes Dependency"] end PR1 --> PR2 PR2 --> PR3 ```
- Copilot Code Review has identified over 200 million findings since launch. - Code Review Max achieves the top F1 benchmark score on ReviewBench for high-severity defects and can be billed via AI credits. - Stacked pull requests organize complex interrelated code deliveries into manageable, dependent layers that can merge independently or as a complete stack. - Agent Merge continuously updates stale PRs by resolving git conflicts and resolving CI failures autonomously before executing the final merge.
[29:42](https://www.youtube.com/watch?v=AArI948SDz8&t=1782s) Enterprise Access Model and Infrastructure Scaling
Following the demos, Jay Parikh recaps the core capabilities powering fast, secure developer loops: seamless session continuity across developer surfaces, flexible automation harnesses triggered on-demand or via events, and Copilot Code Review filtering defects before they reach production. Jay then announces an update to GitHub's commercial model: starting immediately, GitHub Enterprise customers gain access to all Copilot capabilities—including the Copilot app, Copilot Code Review, and automations—without requiring individual seat licenses, paying strictly for the AI credits they consume.
Addressing platform stability, Jay acknowledges recent reliability issues driven by exponential platform growth, emphasizing that scale cannot be used as an excuse: “That's not meant to be an excuse, though. We will and we must do better.” To bolster the platform, GitHub has aggressively expanded hardware capacity and is progressing through a live migration to a multi-region deployment on Azure, targeting full completion early next year.
- GitHub Enterprise accounts can deploy all Copilot tools across their entire developer base without separate Copilot subscriptions, paying only for AI credit usage. - Capacity additions this year include over 4 million CPU cores, 160 petabytes of high-speed storage, and 50 terabits per second of network bandwidth. - Migration to a resilient, multi-region Azure hyperscale infrastructure is scheduled to wrap up early next year while maintaining continuous platform availability worldwide.
[33:22](https://www.youtube.com/watch?v=AArI948SDz8&t=2002s) A Next-Generation Git Architecture for the Agentic Era
Jay explains that raw capacity additions alone cannot solve the throughput challenges created by AI workloads, requiring GitHub to fundamentally rethink its operational primitives. To prepare for the agentic era, GitHub redesigned its core Git architecture around three principles: simplified primitives, complete decoupling of storage from compute, and minimal coordination overhead. To validate the architecture under extreme concurrency, engineers stress-tested a monorepo by dispatching 5,000 aggressive coding agents simultaneously, achieving a sustained 7,200 writes per second. In another benchmark, the team compressed 24 hours of traffic from GitHub's most active open-source repository into a single minute of playback, which the new stack processed effortlessly.
April Leonard joins Jay on stage to explain why this architectural overhaul is vital. As coding agents proliferate, every session initiates branches, inspects repository histories, and pushes commits concurrently, shifting the scale of Git activity dramatically. In September alone, developers and automated agents combined to generate more than 7 billion commits. April recalls an exchange with her own agents:
> “Now, the other day my agents complained about the traffic. I had to tell them, you're not in traffic, you are traffic, and we're already seeing it.”
- The revamped Git engine decouples compute from storage and minimizes state coordination to maximize throughput. - Stress testing demonstrated 7,200 sustained writes per second on a single monorepo under load from 5,000 simultaneous agents. - The platform sustained a 1,440x traffic acceleration, processing 24 hours of peak open-source traffic inside a one-minute window. - Overall platform activity reached more than 7 billion commits in the month of September alone, pushing the busiest repositories up against existing architectural thresholds.
[35:53](https://www.youtube.com/watch?v=AArI948SDz8&t=2153s) Rebuilding the Core Git Foundation for Agentic Scale
GitHub has embarked on a complete overhaul of the foundational infrastructure beneath Git to meet the demands of autonomous agents. The team began by tackling the immediate bottleneck: physical on-premises hosting. Over the past year, nearly every repository on GitHub was moved into Azure. However, for the roughly 100 busiest repositories, even a 25-millisecond latency penalty between data centers proved critical. To address this, the engineering team altered how Git coordinates write operations. Rather than locking an entire repository for every write, Git now locks only the specific branch being updated, allowing multiple agents targeting different branches to execute changes in parallel and yielding three to four times greater write throughput.
```mermaid flowchart TD accTitle: Decoupled Git Architecture on Azure accDescr: Git requests are served by ephemeral caching servers backed by Azure Blob Storage and a replicated log service.
subgraph Client["Write Coordination"] Agent["Autonomous Agents"] -->|"Branch-level lock"| Log["Replicated Log Service\n(Reference Transactions)"] end
subgraph StorageCompute["Decoupled Storage & Compute"] Log --> Ephemeral["Ephemeral Git Servers\n(In-memory caching)"] Ephemeral <-->|"Durable Source of Truth"| Blob["Azure Blob Storage\n(Git Object Data)"] end ```
To eliminate the scaling ceiling altogether, GitHub designed an entirely new architecture in deep partnership with the Azure Storage team. The effort was steered by three core engineering principles: simplify the primitives, decouple storage from compute, and minimize coordination. Under this model, source code resides durably in Azure Blob Storage as the ultimate source of truth. Ephemeral Git servers handle incoming requests and cache data for speed, allowing capacity to scale dynamically with demand. Critical-path coordination is stripped down to small reference transactions managed by a specialized replicated log service built for raw speed.
- The prior architecture capped out at dozens of pushes per second on any single repository, while the new architecture is designed to handle thousands. - In load testing, pointing 5,000 agents at a single repository sustained an unprecedented 7,200 writes per second—an increase of 180 times current production throughput. - On read benchmarks, GitHub's own load-testing harness reached its operating capacity before the new Git architecture showed any signs of degradation.
---
[37:49](https://www.youtube.com/watch?v=AArI948SDz8&t=2269s) Validating with Open Core and Upgrading the Global Platform Stack
To prove the architecture under live production conditions rather than synthetic benchmarks alone, GitHub teamed up with Open Core, one of the most active open-source projects hosted on the platform. Peter Steinberg, the creator of Open Core, evaluated the system just before departing for his TED talk, explaining: “GitHub change how the Git objects are stored, and it will affect us in a way that our agent will be able to operate much, much faster.” Steinberg highlighted that agents frequently waste cycles polling continuous integration systems, and the ability of the new infrastructure to proactively push events when tasks are ready will eliminate their primary operational bottlenecks. Every repository across GitHub is scheduled to migrate to this new storage architecture by early next year.
Beyond core repository storage, GitHub is aggressively scaling the broader operational platform to support agentic workflows:
- **GitHub AI Gateway:** The platform gateway currently processes trillions of tokens, with recent engineering efforts targeting aggressive prompt caching, latency reduction, and test harness execution. - **GitHub Actions:** Now processing billions of compute minutes each month, Actions is receiving a hardened control plane, simplified coordination layers, and expanded compute capacity to prevent workflow stalls. - **Global Network Infrastructure:** GitHub has deployed additional edge locations, quadrupled backhaul capacity connecting legacy GitHub data centers with Azure, and tuned TLS handshakes to ensure smooth transit for continuous agent traffic.
---
[40:00](https://www.youtube.com/watch?v=AArI948SDz8&t=2400s) The Next Era of Software Development
Closing out the keynote, the presenters reflected on how the rapid evolution across every layer of the GitHub stack—from the lower-level Git rebuild to developer-facing innovations like Copilot fusion, GitHub Copilot app, the CLI, and Visual Studio Code—converges into a single cohesive ecosystem. Even as agents step into automated coding, the engineering consensus remains clear: developer judgment is more vital than ever. As the speaker observed, “The hardest part of building has never been just writing code. It’s understanding a problem, imagining something better, and having the ability and the drive to make the work.”
The true leverage of the platform comes from communal collaboration, where an open idea shared by one engineer serves as the direct foundation for another creator's breakthrough. Looking ahead at the sheer trajectory of the industry, the speaker offered an expansive forecast: “In fact, I think all the software ever written may amount to just 1% of what humans and agents will build in the next five years.” The session concluded by underscoring that raw code volume is not the end goal, but rather the tangible impact the resulting software will deliver to the real world.
## Notable quotes > [40:00](https://www.youtube.com/watch?v=AArI948SDz8&t=2400s) The hardest part of building has never been just writing code. It’s understanding a problem, imagining something better, and having the ability and the drive to make the work.
> [40:00](https://www.youtube.com/watch?v=AArI948SDz8&t=2400s) In fact, I think all the software ever written may amount to just 1% of what humans and agents will build in the next five years.
> [03:26](https://www.youtube.com/watch?v=AArI948SDz8&t=206s) The SDLC is no longer linear. In fact, the SDLC is collapsing. — Jay Parikh
## Mentioned Agentic Autofix, Agent Merge, AI Push Protection, AI Skills, April Leonard, Artificial Analysis Coding Agent Index, Azure Blob Storage, Burke Holland, Cassidy Williams, Claude 3.5 Opus Max, Cloudflare, Copilot Automations, Copilot Canvases, Copilot Code Review, Copilot Code Review Max, Copilot Dreaming, Copilot Fusion, Copilot Memories, Copilot Projects, Damian Brady, Datadog, Ersilia, Figma, GitHub Actions, GitHub AI Gateway, GitHub Copilot, GitHub Enterprise, Global Earthquake Model Foundation, Jay Parikh, Matt Pocock, Microsoft Foundry, Microsoft Teams, Microsoft Work IQ, Netlify, Open Core, OpenQuake, Peter Steinberg, ReviewBench, Sentry, Slack, SvelteKit, Vercel, Visual Studio Code
## Video description Join us for the GitHub Universe 2026 opening keynote as we look at the next era of software, the developers building it, and the tools and workflows GitHub is creating to help them go further. Hear from engineering leaders April Leonard, Jay Parikh, Cassidy Williams, Burke Holland, and Damian Brady as they unveil major updates across GitHub Copilot, autonomous agent workflows, and core developer tools. Expect new announcements, live demos, and a few surprises along the way.
Speakers:
April Leonard, VP of Engineering for GitHub Copilot, GitHub Cassidy Williams, Sr. Director, Developer Advocacy, GitHub Burke Holland, Principal Cloud Advocate, Microsoft Jay Parikh, Executive Vice President, CoreAI, Microsoft Damian Brady, Staff Developer Advocate, GitHub
Watch more videos from GitHub Universe 2026: https://www.youtube.com/watch?v=AArI948SDz8&list=PLENrlACZ7mnU
— CHAPTERS —
00:00 GitHub's explosive growth & agentic shift 03:26 Evolving for the agentic era 06:10 GitHub Copilot app & connectors 09:39 Copilot fusion, Copilot app canvases & Copilot dreaming 14:55 Copilot projects & Copilot automations 19:59 Agent-powered quality & security 31:25 Rebuilding GitHub's core infrastructure 40:00 The future of software development
#GitHubUniverse #GitHubCopilot #SoftwareDevelopment
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=AArI948SDz8)