GitHub Universe Day 1 Keynote

Video authored by the channel shown, not by IANIA; all rights belong to the creator. Transcript and summary generated automatically; the original-language content is preserved.

Original language: English

Original video: GitHub Universe Day 1 Keynote · Channel: GitHub · 52:27 · Watch on YouTube

Topics: AI agents, Task and workflow automation, Cybersecurity and software security, AI developer tools

Summary

At GitHub Universe, speakers describe how AI agents are changing software development, from working on individual coding tasks to coordinating multiple agents and workflows. GitHub presents new tools including the Copilot app, Projects, Fusion, Automations, code review improvements, and ways to continue work across devices and environments. The keynote also covers security and quality features designed to keep pace with increased code production. Finally, GitHub outlines infrastructure investments and a redesigned Git architecture intended to support the growing scale of agent-driven development.

Key points

Developers describe a shift toward orchestrating multiple agents and spending more time directing work than writing or reviewing code by hand.
GitHub reports growth in its developer community and public repositories, and links rising platform activity to agentic software development.
GitHub Copilot Projects lets users coordinate work across repositories, provide context, and delegate tasks to multiple agents.
Copilot Fusion selects models and execution patterns for tasks, with GitHub announcing a temporary 30% discount on usage through the end of November.
Copilot Automations can respond to events, run on schedules, or be triggered manually, with controls over tools and spending.
GitHub demonstrates security and quality features including AI-powered secret detection, code scanning, Copilot code review, stacked pull requests, and Agent Merge.
GitHub Enterprise customers can use Copilot features without a separate subscription and pay for them with AI credits.
GitHub says it is adding infrastructure capacity and migrating to a multi-region Azure deployment, with completion expected early next year.
A redesigned Git architecture decouples storage from compute and reduces coordination; GitHub reports sustaining 7,200 writes per second in testing.

Chapters

Start	Chapter	Summary
01:18	How developers’ work is changing	Developers discuss how improved models have shifted their work toward multi-agent orchestration, rapid experimentation, and directing software systems.
10:52	GitHub’s growth and the agentic era	Jay Parikh shares platform growth figures and describes the need to evolve GitHub’s software delivery stack for agent-driven development.
13:59	A software delivery system for agents	The keynote frames velocity, intelligence, and quality as core goals for a flexible, extensible agentic software delivery system.
17:41	Copilot app, connectors, and Fusion	A demo shows how the Copilot app uses connectors for project context and how Copilot Fusion selects models and execution patterns.
25:23	Copilot Projects across repositories	The demo shows a project coordinating agents across repositories and using design, chat, and meeting context to implement a feature.
29:30	New tools for building with agents	GitHub recaps the Copilot app, Projects, and Fusion, and announces a temporary discount for Fusion usage.
31:04	Continuity and Copilot Automations	A demo follows work from a phone to VS Code and shows cloud automations that can triage issues and coordinate specialist agents.
35:43	Security, code review, and pull requests	The presentation covers AI-assisted vulnerability fixes and secret detection, Copilot code review, stacked pull requests, and automated merging.
40:24	Quality features and Enterprise access	Jay summarizes session continuity, Automations, and code review, then announces Copilot feature access for GitHub Enterprise customers using AI credits.
42:01	Scaling GitHub infrastructure	GitHub discusses infrastructure capacity additions, its multi-region Azure migration, and a new Git architecture designed for higher throughput.
45:09	A new Git architecture	April explains how GitHub reduced write bottlenecks and redesigned storage and coordination, reporting a test sustained 7,200 writes per second.
49:21	Platform improvements and closing remarks	The keynote reviews work on GitHub’s API gateway, Actions, and network, then closes with a reflection on creativity, collaboration, and software’s potential impact.

Quotes

it’s been amazing, but it’s like intense is the word I would use intense. — 02:52

Nobody likes micromanaging agents with copilot projects. — 29:00

I’m not short on agents J. I’m short on attention and time. — 32:37

you’re not in traffic, you are traffic. — 45:40

I believe that we’re still scratching the surface, though. — 51:56

Concepts and entities

GitHub, GitHub Copilot app, GitHub Copilot Projects, GitHub Copilot Fusion, Copilot Dreaming, Copilot Automations, Copilot code review Max, Microsoft Foundry, Sentry, Azure, Jay Parikh

Full transcript (original language)

01:18 Goes into what’s going to be announced to universe, and it’s just exciting. Like I’m excited for everyone else sees it and that’s really cool. I love that, I love that. Okay. And Sam, what about you? What universe number is this for you? This is number two. Number two. Last year you were here last year. Okay, I love that, I love that. This is this is number five, 5 or 6 for me. So so I think I’m the veteran here. But thank you all so much for being here. All right. So universe is always a really good time for us to reflect on like what ha changed in the last year. It’s a really good time to kind of

01:49 think about like, what has happened in the past 12 months. And the last year was a banger, like so much change. So my question for each of you is, what has changed the most about how you work as a developer? Like the models have obviously improved a ton and that’s unlocked a lot of opportunities, I think, for all of us. But what does that mean for how your work changes day to day? So Sam, I’m actually going to start with you. Okay. So one of the things that’s changed massively is I’ve gone from kind of working more on one thing at a time to sort of

02:21 multi agent orchestration side of things. So that’s kind of how I’m building. But then on the other side of things, I do a lot of open source work. Like I’m MCP maintainer and also we work on GitHub, MCP in public. And it’s a really important that the things that we’re working on with the developer love work here are really helping us to set it up, right? So that projects kind of open source projects keep the human element correctly, so that the collaboration is kind of fun and we’re not being just

02:52 bombarded with well-intentioned, but kind of too much to process. So yeah, like it’s a, it’s been a huge change and it’s been amazing, but it’s like intense is the word I would use intense. Okay. All right. Ace, what about you? What has changed the most about how you’ve been working in the last in the last 12 months? I would say the biggest thing is the mindset shift, right? Because for, for now, we, we went through engineering focusing on what the project you’re working on. You have side projects or other features that just take the back burner. But right now it’s as long as you think about

03:22 stuff, your idea, the mindset shift is I can deploy something that’s addressing that. And I just, you know, switch over to it, explore what’s happening, give you structures, and then next thing you know, sometimes when you’re working on something else, you have a finished product elsewhere. And I think it just changes how we build software or even think about advancing software in general. And that’s, that’s been really exciting to explore. That’s awesome. All right. And Maggie. Yeah. This time last year, I remember I wasn’t, I wasn’t writing code by hand, but we were still looking at code to review it. I would still actually check the code before we merged it in. Those days are very long gone. I mean,

03:53 I’m on a research team, so we’re a lot more cavalier about it than, than like a more production product. But now there’s like software factories merging stuff. Everything merges itself. Things are like testing itself. Like I, I operate at the level of like inputting ideas and decisions into the system. I am not involved in writing or shipping the code anymore

10:52 Please welcome Jay Parikh. Good morning. Good morning. Welcome to universe. It is great to be here with all of you in San Francisco and with everyone who’s tuning in online. I’m Jay. I lead the GitHub team and the broader AI team at Microsoft.

11:23 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. They definitely did. There are now over 225 million developers on GitHub, and that spans every country in the world. In fact, a new developer joined GitHub every second last year, and

11:55 that’s the second straight year this has happened. Now all of you have been extremely busy as well. This is the latest numbers from our octopus report. Code pushes increased to 34.3 or 17.9 billion. Commits jumped to 34.3 billion and jumped to 1.3 billion in 2026. And the open source community is

12:26 shipping and sharing more than it ever has. There are now 2.5 contributions happening in the open source community. Now, there are way too many amazing open source projects out there, but I did want to recognize a few. Brasilia is a nonprofit that is building open source, AI powered tools for drug discovery for researchers around the world. Open quake from the Global Earthquake Model Foundation has created open source software that helps

12:57 communities assess risks and hazards due to earthquakes. AI Skills by Matt Pocock is helping all of us with instructions and skills that work across coding agents and address common mistakes that we have. And these are just some of the most awesome projects. But there are so many more out there. In fact, now we’re up to 566 million open source and public repos on GitHub today, and that is up over 30% year

13:28 over year. But it’s not just the scale of this activity. It’s also the growth rate. Just look at these graphs. Now this type of growth rate is extremely rare. It’s pretty scary. It’s being driven by the shift to agentic software development. The delta between 2024 and 2026 is remarkable. As you can see from this

13:59 visualization of actions jobs. Now, this is an exciting moment, and many of us are already seeing significant impact from using agents in our work. But there is still a lot of things that we need to build. And that’s what I want to talk about today. It’s how we’re evolving every layer of the GitHub stack for this agentic era. We want to empower you, developers of the world, to

14:29 spend more time creating, collaborating, and completing software work using agents. Later this morning, we’re going to show you how we’re scaling the foundation of this new era as well. But first, I want to walk you through all the work that we’ve been doing to help you build with agents. Our jobs as developers are changing rapidly. In a couple of years, we’ve moved from typing lines

14:59 of code by hand to being assisted by AI to now managing dozens, sometimes hundreds of agentic workflows. The end goal remains the same, though completing meaningful software work. But the path, the mechanisms, and the systems we use are very different. Things are now often triggered by a signal or an event, a request from a colleague, maybe an event in production. The SDLC

15:30 is no longer linear. In fact, the Sclc is collapsing. Most of us jump between these different stages depending on the task. Now agents are handling the bulk of the implementation and the verification work, and everything feeds into and out of this central learning machine. We can now build a truly agentic software delivery system, one that solves for velocity, intelligence, and

16:04 quality. Now, it’s worth taking a second to unpack these three. Velocity is all about helping you with your agents get from idea to production. And you want to do this quickly, efficiently, and cost effectively. Intelligence is about assembling that context platform wide and using a continuous learning engine so that you can complete work better and better over time. Quality. Now, of course, as we

16:35 increase velocity, we want to keep the quality of our high. We want to catch security issues before they land in production. And we also want to find other bugs and issues before we ship. Now at GitHub, we are building the most comprehensive end to end software delivery system in the industry. No other system can match what we are delivering to you. And as always, we’ve done. We are making the primitives

17:05 available so that you can make them into your own agentic software delivery system. And there’s a broad ecosystem of tools that you can plug into your system. This spans from Datadog to Figma to Cloudflare and much, much more. Now we’ll continue to add more, and the GitHub platform will remain open and extensible. And today we’re going to show you some of these primitives at work. So let’s welcome Cassidy to the stage to take us through it.

17:41 How’s everyone doing today? Okay. I’ll take it. How’s it going? Good. How are you doing today? Not bad. You. You ready? I’m very excited to show everybody what we’re going to build, so. Hello. Hello. Let’s get some work done. So this is the GitHub copilot app. If you haven’t seen it yet. It’s a really awesome single location for working with agents across multiple projects, integration with external tools, automations, and so much more. Plus, if you don’t know, there’s a little game in here

18:11 that you can play. Jay, have you played it? I have. What’s your high score? Four bad today. Okay. But anyway, so we are going to head over to issues. Let me find my mouse here. Okay, there we go. We’re going to head over to issues and work on our task for the day, which is building a coffee passport. Now, there’s going to be a lot of words here, but for some context, my team and I have been building what’s called a platform for a coffee shop chain, and we’re going to be

18:41 building a coffee passport here. I’m going to kick this off right there. Now, this issue has a lot of locations, and the coffee passport is for people who visit all of the different locations. They get stamps. And then when you get all the stamps, you win. You can get some cool treats and stuff. So we want to find out what counts as a visit. What happens after repeat visits and so on and so forth. Now, I just asked my coworker Seth about this passport feature because with these open questions, we need to get answers for them. And

19:12 how is it possible that we’re able to get these answers right here in the app J. We can use connectors and connectors. Are these managed services that sit in the copilot app or whatever service. And they connect to services like Slack, work IQ, Vercel, Netlify, and Sentry. So you can authenticate one place and then use them across all of your services. Yes. So in the customize tab right over here, these are all of the different connectors. There’s these features ones at the top. And now if you want to have those

19:43 GitHub managed ones where you don’t have to log in across multiple devices, you can see that cool little verified badge right there. And that means once you’ve connected, you have done it once and it looks great. And if I head over back to our issue and find our session, it looks like we got the answers to all of our questions. And I really love not dealing with context switching and going between multiple apps. It’s nice to not have to make assumptions. We have the source of truth right here, and because we now have the plan of everything all mapped out, I can just start kicking off this

20:14 session right here. So we’re going to start implementing this issue. But what model do I pick? We just have so many options. I just love that. But Jake what should I pick. You should use copilot fusion. Ooh. Okay. 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. There’s three. There’s single cascade

20:45 or critique. Now, some serious engineering work is going on into copilot fusion. And the results are super impressive. In fact, recently in artificial analysis, coding agent Index, Copilot fusion Max scored 60. And that’s within two points of opus five five Max. Now it did all of this at half the cost per task and at 40% less timeppt more of the boba tea budget. So

21:17 I really love geeking out about this. And I admit this is a very large feature. So I moved to our fresh out of the oven session so you can see what we actually built. We have some actual testing that happened. We had everything built out and everything is fully baked, so we can do some fun live testing to make sure that this all works. So I’m going to be opening up your demo account, Jake, and check out your passport. What’s your typical coffee order? Plain coffee. Nothing in it. You are super creative, man. It’s fast. Let’s

21:48 see. Let’s see what copilot picks for you. Now, as this goes, what is going to happen is the agent is going to start interacting with the browser and testing out this feature. And so we’re going to see what happens as it starts moving. The screen will start moving there. Now this looks like a browser but it isn’t. This is where you all go ooh ooh yeah. It’s not a browser. So it is actually what’s called a canvas. Now this is a canvas browser. But if I head over to the very

22:18 top right there, there’s a little plus sign. And if I click that, we have browser canvases, we have terminal canvases. We also have custom canvases, which we will talk about later. And this allows agents to interact with this browser in a bunch of different ways. And so I have two browser canvases right here and it’s moving around slowly but surely. I think that some things are getting set up. But while this is being tested, there’s a lot happening behind the scenes. Now there’s something that you wouldn’t necessarily see as the agent is starting to click

22:49 around and move things. We actually rewrote this app. It was originally in Java. Get it? It’s a coffee house and it’s too early. Too early, but still. So now it is in Sveltekit. So even though the code may have moved on and once again, it’s doing some interactions here, you’ll see it start logging in. The instructions for how this is built did not necessarily move on. But let me introduce you to copilot dreaming J. While I pull up the PR, would

23:19 you mind explaining what dreaming is? Absolutely. So everyone here probably has written custom instructions for their agents. They’re great for about three weeks. And then the code base moves, more intelligent models show up and the instructions end up hurting more than they help. Dreaming goes back and ensures that your instructions and memories always reflect your preferences, which I think you have a few. Yes, I have so many. I’m very picky. So in our particular case, Copilot Dreaming opened up a pull request here and I’m

23:50 looking at the div that it’s cleaning up our instructions file in this new non Java based world. And I’ll review all of these just like I would any other change. But now any agent that picks up a task will be going from up to date guidance. That’s up to date with all of our decisions, our code base and so on and so forth. And at the very bottom of this, once again, lots of words just describing what happened here. Everyone’s so verbose now with agents. You know, we have also some copilot memories updated as well. You can see all of

24:21 your memories, which are your preferences that copilot has learned about and your team’s practices. So you can see how much your outputs are tailored to you. And you can actually see all of my memories here. I am 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. Now, what’s also cool, if I head back over to our feature, I’m going to go back to our fresh out of the oven. You can see that things have logged in. You saw his passport a little bit earlier. Let’s just say I

24:51 liked what I saw. Everything is working as expected, but I still wanted to dig into the code. I can still go right up here and open this up in VS code and see all the code changes and dig into whatever I might need to. Now J this was all very cool and it’s really fun to once again see all this happening live, but I do have a whole lot of sessions over here on the side, and it’s just the way I like it. Oh, I’m zooming in so far. Anyway, I have a lot of sessions here and I like it. I usually have piles of repos, lots of things going on at once,

25:23 but there are other ways to do things. Are you thinking of copilot projects? I am. All right, thank you. Cassidy. Let’s bring on Bert to show us projects. Thanks, everyone. Hey. Morning, everybody. Thank you so much for bringing me out here to talk about copilot projects. It is my favorite way to work with GitHub copilot, and I’m excited to show it to you on my brand new Surface

25:54 Laptop launcher. Can I try? Go ahead. Okay. It’s too much time. Sorry, sorry. All right. So what I want to do to get started here is just create a project right here in the sidebar of the GitHub copilot app. And then once we do that, we can go ahead and add in the fourth coffee repositories right here as context. Now once we do this, these are now available for context in this chat. Now here’s what I want to do. I want to create a your usual feature so that customers

26:24 can easily reorder their usual with just one tap. Easy peasy. So what I’m going to do is come down and just add this prompt, and then just go ahead and send this. So work like Burke is doing right now often involves multiple repos. And with projects, copilot spins up as many agents as it needs to tackle this feature, and it will assign those agents depending on whatever repo the task needs to be completed in. Exactly. And I’m going to send in some additional context here,

26:55 like these mocks that our design team provided. We’re going to need those. Oh, and we did have a conversation in Slack where we figured out kind of exactly how this would work. So I’m going to send this as well. Oh, and I forgot we also had a teams call with legal and compliance. It’s a personalization feature. So we want to make sure that the agents also have that context. Now Burke doesn’t have to wait for the agents to finish before he sends his additional prompts. He’s not steering an actual individual agent loop. He’s actually working with the copilot orchestrator here so he

27:25 can keep firing them off, and copilot will spin up new Subagents to tackle these requests. Answer the questions, and it’ll still have the context across the entire project. And that’s my favorite part of this. Now, Jay, as you know, and as all of you know, there’s way more to shipping something than just the code, right? Absolutely. For example, marketing is for sure going to want to know how this feature works so that they can promote, promote it. Wouldn’t it be cool if copilot can generate the

27:56 artifacts for us? Believe it or not, copilot can do that. So I’m going to come over here to the library and we’ve got these little videos that we make for marketing. And these are actually built by GitHub copilot. We’ve given it a skill and these are pixel perfect match to our application. So marketing can get these little demos before the code even ships. And what I’d like to do here is I’d like to go ahead and create an automation so that every day these videos automatically get created when

28:26 a new feature ships. So they just automatically show up over here in the library, right there in our automations. Beautiful. Now, if we look at this, we’ve got what, five, six, eight agents that have now been running on this project. And these agents can run locally or they can run in the cloud. So we can just shut the laptop and move on to other things to keep right on moving. And because I asked copilot to create PRS,

28:57 those are automatically showing up here in our project overview as the agents finish their work. 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. Exactly. And when we talk about increasing velocity, this is the kind of thing we’re talking about. And I’m excited to announce that today, GitHub Copilot Projects is available to everyone. All right. Thank

29:30 you, Burke, and thank you, Cassidy. That was super fun. So you just saw some of the newest building blocks from in for your software delivery system, a few of them to call out, specifically the GitHub copilot app, which is a new agent native desktop, bringing your agents and your work together, and then projects where you can set the goal. You can see what’s moving and you can direct what copilot takes on next across one repo or many GitHub copilot fusion

30:01 automatically selects the right models throughout the process for completing the task that you’re working on, and it delivers better performance at a lower cost. Now, one additional note today, today, through the end of November, we want you to try copilot fusion. So usage will be 30% off. So give it a try. Okay. So together all of these components empower, use, empower you to use agents to

30:33 move your work forward. But you got to stay in control to. But with agents also writing so much more code, we have way many more pull requests. We have way many more security reviews, and we have many more deployments to get done. So how do you manage to do all of this and ensure that you still keep the quality bar high? This another big area of focus for us. We want to make sure that nothing slows you down day to day and to take us through that.

31:04 Let’s welcome to the stage. Oh, hi, Jay. What’s going on? I promise I’m not doomscrolling. Yeah, I’m not doomscrolling. I’m sure doing some work. I promise we can show you actually, on the screen. All right, set that up. There’s a bug in the app. Right. So the order ahead feature stops taking orders before a cafe closes, which is right, but the site doesn’t tell the customer. So I can start a copilot session to fix this from my

31:35 phone. And it spins up a session in a cloud sandbox, which allows me to pick it up later. Nice. 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.com, wherever you are. Now, this is all powered by the same copilot harness, which has also been rolled out across all of Microsoft. And starting today, you can take this harness and you can build an agent for whatever you want to do on

32:06 Microsoft Foundry as well. Yeah, it’s one of my favorite things. I do this all the time. Start on one device, come into another one. So like right here, here is that same session I just started in vs code. Now I promise, Jay, while you were talking, I read through all of this and I checked all the code. We’ve even got diagrams here. Yeah it’s great. It’s ready to go. So I’m just going to say it looks good to me. Let’s do a PR when you’re done. And so the important thing here is that the agent has a clear direction forward, which means that I can pick up some other work and do

32:37 something else that needs my focus, because I’m not short on agents J. I’m short on attention and time. I’m very single threaded, right? I know I’ve been I’ve been waiting for a firmware update, but they’re not coming so I can move on to the next thing that needs my attention. And it looks like there is an error with the how ordering works button. So I’ll just have a quick look how ordering works on our page. Sure enough, that was a very fast 500 error. Okay, now I can see the details of that error

33:09 in a custom canvas. So if I open this session, we are using sentry in our production system to monitor these issues. And we can see right here there’s an alert. Now I don’t want to just see an alert. I want to do something about that alert so I could create an issue here or fix it with copilot. But like, why am I clicking buttons? It’s the year 2000, right? I should, this stuff should happen automatically. So to get that happening automatically, I’m going to use a feature called Copilot Automations. And while

33:39 I open that, Jay, can you tell everyone about automations? Sure. So 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, so you can let them take on triaging and delegation tasks while you focus elsewhere. Yeah. So in this one that I’m showing everyone, you can see that it runs via an API or I

34:11 can manually trigger it, but I’ve got all these automatic triggers that I can use as well. It runs in the cloud, so I don’t have to keep my laptop open when I go home. And importantly, we can choose which tools it’s allowed to use. So for example, I can get it to create pull requests, but it’s not allowed to merge them. So that’s really handy. Here’s my prompt. One other really cool feature is that I can control how much it spends. So I know that my agents aren’t going to go rogue and burn all my AI credits because they’re not free. No. Now this is just one

34:42 isolated automation, right? I want to show you something even cooler that we’re doing in another repository. This is my subscriptions repository. And here we have a series of automations that all work together to take a lot of the toil away from me. So we have a series of automations that pick up, watch for signals and create issues. Then we have an automation that triages those issues, and then one that reproduces them and gives me screenshots, another one that fixes them, and another one that verifies the fix against the against the original

35:12 request. And now these are all specialist automations that do just that piece of work really well. 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. So that’s what automations does for me. All right. I’m going to do a quick pivot, and we’re going to talk about some ways to improve the security posture of our application. All right. So GitHub code scanning can scan through our entire code base to

35:43 look for vulnerabilities in new and existing code. Now we’ve even expanded the language support with AI here so we can find more issues. So for example, when we find a vulnerability, we get all of this information about where in the code, the vulnerability it is, what type of vulnerability it is, and how we would typically fix that vulnerability. So even if we don’t have one of those fancy automations running, we can just assign this to a genetic auto fix. And all of that information is there for the agent to help fix it. And what

36:15 we end up with ultimately is just a pull request with a suggested fix. Now this evaluates all the code in our repository, right. But I want to show you a way we can help prevent security issues even earlier. So here I have accidentally committed a secret to a file just on my local machine. Right. So I’m going to git push this. I wouldn’t recommend anybody does this. Nope, not a good idea. However, this secret was detected by AI.

36:47 Now this is before it even reached our repository. And I didn’t even have to provide a pattern for it to match. It just got picked up automatically. So between secret scanning and AI push protection, our security posture is a lot better. But what about the quality of the work we’re producing? Right? Let’s jump back and have a look at a pull request, which is one of the ones that Cassidy and team worked on for the coffee service coffee passport service endpoint. And we can see here one of the reviewers is GitHub

37:18 copilot. So we make sure that every pull request, whether it comes from an agent or a person, is reviewed by copilot code review before any human does a code review. Now there’s a lot in this, so I’m just going to well, there’s one suggestion here which I’m going to look at. So while I’m doing that, Jay, are you able to tell people catch people up on what copilot code review is? Yeah, absolutely. So copilot code review we launched last year and so far it has surfaced 200 million findings for developers. And today we’re introducing our

37:49 deepest level of review yet code review Max. Now Max is a big step forward. It posted the highest F1 score on review bench for high severity issues. Now we’re continuing to do work here and it’s getting better and better over time. Copilot code review is also available to everyone without a copilot subscription. You just pay for the review with AI credits. Yeah, it’s something we use a lot and it helps me a huge amount. Now I’ve reviewed those

38:21 pull requests. I’m really efficient today. If you noticed, I’ve reviewed all of those suggestions. They look great. And so we are going to look at merging that pull request. And actually it’s more than just one pull request. It turns out that this piece of work that Cassidy and team did is three different, but very related pieces of work. So we have organized this work into using a new feature called pull stacked pull requests. So here’s the UI change. Here’s

38:51 the endpoint, the service that it depends on. And then the data changes as well that it depends on. So this stack of pull requests can be merged all together. Or it can be merged one at a time. The other side effect of these, the amount of code that’s flowing through our system these days is that sometimes before I can get to do a code review, the code changes underneath and that pull request becomes stale, right? So here is that session we started at the beginning on

39:22 the phone, and it’s created a pull request. Now I’m going to use a feature called Agent Merge to automatically resolve issues. So it will look at background in the background. It will look at addressing feedback. It’ll fix CI failures and it’ll resolve conflicts. And because we have all of that security and code quality process in place, I feel confident enough to turn on merge pull requests as well. So once every check passes and all

39:52 of these issues have been resolved, it will merge the pull request for me. So that issue I started on at the start of the stage when I was absolutely working on my phone. It’s effectively done. I can move on to something else. That’s amazing. It is amazing. Yeah. So that’s what my day looks like now. It’s automated, it’s organized, and it’s secure from start to finish. Thanks, Timo. All right. See you later. Now the team is doing some great work here. You just saw a

40:24 bunch of features that will help you keep the quality bar high while you ship. And you don’t have to slow down. I want to just recap a couple of important things here. So session continuity, you can continue your work across multiple surfaces. And they’re all powered by the same fast, efficient harness automations allows you to define the job once and run it on demand on a schedule or in response to some other activity. And then copilot code review is an

40:56 important part to keep that quality by quality bar high, and it’ll serve as meaningful and actionable bugs so that you can keep this stuff away from production. Now, one more thing here. We want to make it easier for GitHub enterprise customers to take advantage of all of these copilot features. So starting today, GitHub enterprise customers can use all the copilot features without a separate subscription.

41:29 So this means that every enterprise developer can use the GitHub copilot app code review automations, and much, much more. And you just pay for the AI credits. Okay, so across these three demos, you’ve seen several of the building blocks that you can use to ship completed software work, and you can do it quickly, efficiently, and cost effectively. Now there’s a lot more to come. In general, here we are shipping features and improvements faster than we’ve ever done before, and it’s

42:01 across the entire platform. Now, of course, to do all of this, you need a super strong foundation, an infrastructure that is performant and reliable. Now, there are times this year when we struggled with these things, but a lot of that was due to the growth and scale that you saw earlier. That’s not meant to be an excuse though. We will and we must do better. The good news here is

42:32 that we’re doing a lot of work, and the first thing that we’ve done is added a ton of capacity. This year, we’ve added 4 million CPU cores so far, 160PB of high speed storage, and we’ve added 50 terabits, a second of network capacity. And the year isn’t over. We’re also making steady progress on our migration to a multi-region deployment in Azure, one of the

43:03 most powerful hyperscale infrastructures in the world. Now we’re doing that while continuing to serve every developer in the world. And this is a massive engineering challenge, but the payoff is going to be really significant. And we expect the migration to be complete early next year. This is good progress, but on its own, it’s not enough. And in my experience, every time your load increases this

43:35 significantly, you need to rethink all of your assumptions in terms of what you build and how you operate it. And that’s exactly what we’re doing. We’re evolving our infrastructure for this gigantic era, starting with new primitives that will ensure we can provide a responsive and reliable service to every developer on the platform, no matter what the scale. One example of this next big evolution is our git architecture. We’ve been

44:06 scaling git steadily over the years as activity has increased, but I’m really excited about our recent work here. Our new architecture is designed to provide the highest throughput and reliability possible. To accomplish that, we’ve simplified the system’s primitives. We’ve decoupled storage from compute, and we’ve minimized coordination. In testing, we found 5000 of the angriest coding agents, and we

44:37 sent them after a monorepo. And this one repo sustained 7200 writes per second. And we have more improvements coming. So we’ll take up this limit. Now, another way to give context to this scale is we took 24 hours of the busiest open source repo on GitHub, took 24 hours of traffic. We compressed it down to one minute and the new stack

45:09 didn’t break a sweat. So let’s welcome April to the stage for a deeper dive in the new git infrastructure. Thanks, Jay. You just saw what one developer can do with a fleet of agents. Now imagine that across every

45:40 developer and every repo, every agent session creates branches, reads history, and pushes is often all at the same time. And all of that land is on at this scale. Start to hit bottlenecks. Now, the other day my agent said about the traffic, I had to tell them, you’re not in traffic, you are traffic. And we’re already seeing it over the past year. Pushes and commits just keep growing. In

46:13 September alone, developers and agents made more than 7 billion hits September alone. Most repositories comfortably within today’s limits. But the busiest repositories are. And as agents scale, more will follow. So we have been rebuilding the foundation underneath git First, we removed the immediate bottleneck physical hosting. Over the past year, we moved nearly every repository on git

46:46 into Azure, but for roughly 100 of the busiest repositories, even 25 milliseconds between data centers mattered. So we changed how git coordinates writes. Instead of locking an entire repository for every write, we lock only the branch being updated. Agents working on different branches can now move in parallel, delivering 3 to 4 times more. Okay, so that raised the limit, but we set

47:16 out to remove the ceiling. We designed the new architecture in deep collaboration with storage team. Rethink it for a world of agents and three principles. Simplify the primitives, decouple storage from compute coordination. So your code lives durably in Azure blob storage. Source of truth. The server is responding to cache that data for speed, but they’re ephemeral. So we can add capacity as demand grows. And then we minimized

47:48 coordination. Only the small reference transaction stays on the critical path handled by a specialized replicated log service optimized for speed. And the result. Is the old architecture topped out at a dozens of pushes a second on a single repository. This one is designed for thousands. And as Jay noted earlier, we pointed 5000 agents at one repository and we sustained an incredible 7200 record. That’s 180 times

48:20 our current throughput. And on reads, our own load testing harness hit its own limits before the new architecture did. But look, benchmarks only take you so far, so we wanted real traffic. We partnered with Open Core, one of the busiest open source projects on GitHub, and we caught up with Peter Steinberg, the creator of Open Core, right before he took off for his Ted talk. And here’s what he had to say. GitHub change how the git objects are

48:50 stored, and it’ll affect us in a way that our agents will be able to operate much, much faster. I’m even more excited. Excited about all we can. Once this change landed. Many times our agents do silly things like the polling. Sigh. And this is new infrastructure. New changes like GitHub is being able to tell us when you’re building the foundation for that, right? And that will solve pretty much existing problems. Thank you

49:21 April. Really impressive work. And also thank you to Peter for taking an early look at the new system. We love working with Peter and his team. Everyone should be migrated to the new architecture by early next. So this is just one example of the work we’re doing to scale the platform. Other projects include the work that we’re doing on GitHub’s API gateway, which today processes trillions into tokens. We’ve done a lot of work here to optimize the

49:52 gateway prompt caching, minimize latency, and improve the harness performance. Now, actions is an area that focused on actions, handles billions of minutes every month, and we’re adding more capacity. We’re hardening the controller, and we’re simplifying coordination to ensure that the system keeps moving your work forward. And on network work, we’re adding more edge sites. We’ve pulled the backhaul between the GitHub legacy data centers and Azure,

50:24 and we’ve done optimizations in things like TLS to keep all of your agent traffic flowing. Now, we will continue to get better here. We’ll see and feel the difference. We’ve shown you a lot this morning, and we’ve shown you how we’re evolving every layer of the GitHub stack for this agentic era. We’ve shown you how it comes to life in our new git architecture and in new tools like copilot

50:56 fusion and the continuity across all the surfaces you use, like VSCode to the CLI, to the new GitHub copilot app, the way we build software is changing, but developers have never been more important because the hardest part of building has never been just writing code. It’s understanding a problem, imagining something better, and

51:26 having the ability and the drive to make the work. Make it work in the real world. The best parts is that here on GitHub, nobody has to build alone. Someone shares an idea, someone else makes it better. A project becomes a building block for something its creator never imagined. Creativity feels collaboration. Collaboration unlocks

51:56 creativity. And that’s the power of this community. I believe that we’re still scratching the surface, though. 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. Think about that for a second. But more software isn’t the goal the impact that software will have on the world? I can’t wait

52:27 to see what you build. Thank you and have an awesome universe.