Name: GitHub Introduces SWE Agents
Uploaded: 2025-06-26T19:16:10.859Z
Duration: 53 min 43 s
Description: GitHub Introduces SWE Agents

Transcript for "GitHub Introduces SWE Agents": Alright. I think we're three minutes, three minutes into the session, so we can get started. Welcome again everybody for, and thank you for joining us today. Today, we're gonna be discussing, a specific, set of features from GitHub Copilot. You probably have seen our change log. GitHub introduces, SW software engineer agents. We call it the agent awakens. Earlier this year, we recently announced some of the features that we're gonna be discussing today, like the Copilot coding agent, Copilot code review. And in the session, you're gonna learn more about how you can use these agents across the GitHub platform and how they're gonna, really, make you productive in your day to day as you start using them more in your workflow. Today, I'm joined by my colleague, Tanvi, who's gonna be co presenting with me in the session. So I'll let her introduce some herself. Thanks, Louis. Hey, everyone. Good to meet you all. I'm Tanvi Tiaghi. I'm a solutions engineer at GitHub. And me and Louis, we work closely with customers, to enable them on co GitHub, Copilot included, and basically just have great conversations. So we're looking forward to, telling you more about what we have going on at Copilot and the GitHub world in general, and looking forward to your feedback and questions at the end of it. Yeah. Thank you so much for that. And, as Sandy shared, my name is Luis Pujols. I'm a senior customer success architect here at GitHub, also working with our enterprise, customers, helping them drive adoption, of all the different features, I'm really excited to be here with you all. If you join really early in the session, you might have heard I'm originally from Dominican Republic. So if you have, like, a favorite American dish that you like, feel free to share it in the chat. I'm a foodie, so always love hearing about other people, preferences with food and everything. So, alright. So let's get right in. 2025 for us and Gerhard is is what we call the year of the software engineer agent. And you probably have seen this in a lot of our announcements where we truly believe that agents are gonna change the AI landscape. And you might ask, like, what is a software engineer agent? That's a great question because, actually, there was not a definition for it in the field. So everybody has their own definition of what a software engineer agent. This is ours. So for GitHub, a software engineer agent is an AI system that out augments software engineers by allowing you to automate coding, testing, debugging, and documentation tasks while also providing, and while also allowing you, providing you guidance on architecture, performance, and best practices. So all of these tasks that you normally do besides coding, you can also, use the to assist you, throughout that. They serve as a pair or peer and peer programmer, handling handling routine work that you normally have to have to do, to provide you more more time to focus on what you really want to do, which is your creative problem solving. So if you've been seeing the landscape the last few months, you're gonna realize that for, the last tape of AI, we were in what we recognized as the phase one and phase two. Phase one was our initial launch of the ROCO pilot where, we had the auto complete experience. We had the chat experience, your Copilot chat. And if you notice in phase one, we were really, focused on being single model. It was based on conversational coding, and it was more AI infused into your workflow because it was, you would enable these capabilities to an extension that you enable in your IDE. Right? Single model because if you're using, let's say, Copilot auto if you were using our Copilot auto complete, you would be tied to the specific model that is in that experience. But that also applied for for chat back then where even if you're having the natural language conversation, you were tied to the language, I mean, to the model that your provider was was, giving you. Right? Now in phase two, where where is the present, where we are, we have moved into, a world where we are multi model because we learn, as an industry that each model is best at different set of task. So if you're trying to do something like, let's let's do a brainstorming session, let's start planning, how to implement, this new refactor on the project, then you probably want a model that is a recent model, which is really good at complex task and takes its time to break down the solution into into different chunks and and works towards the the final suggestion. Right? Keeps revisiting itself. But if you're doing if you're doing autocomplete or, like, if you're if you want a quick code suggestion, based off of, like, a predefined, implementation plan, then you probably want a model that's more performant and responds faster, model. And you'll see that the the the benefits you get from from that model, it's really accurate at at generating code, at following the implementation plan, and responds pretty quickly. So now we have model choice, which is amazing. So always make sure you're picking there the right model to use. We're also moving into the world of AI agent, which is what we're gonna be talking about today in our session, where now you have now you have the option of some of these tasks you can just, upload to the AI agent. In this car in this case, Copilot coding agent. Have it go and take the issue, make up make a plan, come up with the implementation, steps, implement the work, create a PR, and actually bring you back in the loop once it's finished, what is what is job to actually get you to review the work that's been done and continue collaborating with the agent. Right? And we're also in AI in an AI native world now where you'll find your Copilot fully integrated throughout your whole software development life cycle, Not only, when you're coding, which is 27 to 30% of your time. It's also in the other percent of your time, when you're working, where you might be doing planning work, you're creating new issues, you're documenting bugs, you're, creating a, like, an enhancement issue where you're writing down the user story, putting the acceptance criteria. Now you have getocalparadigm.com and it can actually help you generate, your whole implementation plan. Right? But it doesn't stop there. It can also help you implement the changes with the coding agent. Right? And once you have your PR, you also have Copilot available in the in the in the pool request. So really exciting time where we are in, where you have a lot of options, to gain value out of GetYourCopilot. And depending the type of use case or the the stage you are in in your, SDLC, you'll want to use the right tool for the job. And with that, I wanted to to discuss a little bit more about our coding agent and what is it. Right? I keep mentioning coding agent. It came out recently. But, Louis, what really is it? Right? So coding agent is our our AI agent that's now throughout the GitHub platform, GitHub. And basically, it allows you to upload some of these, routine tasks that you have to do and how do you engage with it? So it lives in your issue. As soon as you have an issue created with the documentation for, like, if it's a bug, how to what is the bug that's occurring, how to how the actual behavior should be. You can just simply, under the list of assignees, select Copilot and Copilot will be able to view the issue, spin up a a development environment where it has the code of the repository as well. Based on the of the information on the issue and the tasks that are there, it's going to create, its own environment where it's gonna work with the code and start creating a plan to address the the task from the issue, implement the changes. It's gonna have a feedback loop where it's gonna build the code, make sure it passed all the tests so it leaves the code, in a in a healthy state state as it found it. You're able to track the progress of the coding agent to what we call the coding agent session, and we'll see more about it in in the demo with our with my colleague at Tanvi. But once, the coding agent is done with its work, it actually is, so it's creating a PR where it's actually committing all the changes as it's working. So once it's done with the PR and it has it in a state where the new changes are implemented, so from your idea, it build up it, developed and it added code to the project, put it in a PR. Once it's ready for review, then it's gonna tag you in the on the pull request, and it's gonna say, hey, Luis. I'm done with the changes. Could you go ahead and review them now? Right? So what are the entry points? How can you assign Copilot to to your issues? Well, it's kind of pick your own adventure. If you're in GitHub already in the repository and working with the issue, then you can just open the issue and assign it there. If you're in GitHub and you're in GitHub mobile, same, same behavior there. You open your issue, assign Copilot as an assignee, and he'll and and it will get to work. You also can do it from the CLI and also even from the, from your IDE and Copilot chat. You can actually ask the the agent, hey, could you assign, could you take let's say I've made the implementation plan in my Versus code and I can say using agent mode with MCP, the GitHub remote MCP, I can say, hey, agent, just can you go ahead and take this implementation plan that we've been working on, create an issue for it, document what I what we wanna do and assign Copilot to it. And it will actually use the MCP server to go ahead and do all of that for you. So by you continue in your flow, you continue working on your other feature, that you were working on the IDE while this issue is already created. You didn't have to open GitHub.com. It just created it for you through the MCP. By the time you finish the the feature that you were working on initially and you come back main ripple, now you have both, your current issue and the one that you created, and brainstorm it with to work on later already, being worked on by GetRocopilot, coding agent. So with that, I wanna open it up to to Tammy so we can actually see this in action. Thanks, Lewis. Let me share my screen. Alright. So can you see my repo here? Yes. We can see it. Cool. So real quick before I get started and kinda show how Coding Agent works, I just wanna call out how coding agent might be different from agent mode. Many of you might be familiar with, the IDE part of agent mode and using it, within the chat interface already. And, may have attended our previous sessions where we went in-depth on, agent mode, how it works, how it interacts with MCP and the and the IDE itself. Coding agent is is a bit different from that. It's not within the Copilot chat. It's actually going to be working as an individual software engineer. It's going to actually function as that. So when you're interacting with it, you can actually, add it as you would an assignee in your team or yourself. So what I can do here is, let's say I have this this repo, you know, basic front end app that I created for Octocat Supply, you know, simple node app, and I want to make some enhancements to it. For example, I have a products page, but I'm not able to add to cart. And that's a very basic functionality that's missing from my application. I also would like to have, a cart icon on the top. You know, I'm used to that in in front end applications, just to have that checkout flow. So there's some things missing from my application. Me noticing that I could, you know, do the work myself, or I can have Copilot kinda get involved and give me some assistance here. So starting off, what I'm gonna do is give a title to my issue. So I'm gonna say, create or actually update my app to, add a cart icon and add checkout. Woah. So when I'm asking Copilot to perform these changes, I can get, you know, very detailed. I can be very general. There's, you know, different things that I can have here. Typically, I would have, you know, more in detail requirements. Even as a developer myself, I would look towards, you know, breaking down, the the actual logic itself, you know, what kind of, font I'm using, you know, having screenshots of the actual front end app. So all of that data and description, you can provide here for Copilot itself to follow, you know, specific instructions. So I'm gonna ask it to, use this icon font. I'm gonna ask it to, make sure that it's working on mobile devices, follow the existing scheme, and also add the documentation. So I'm gonna create this issue, and first thing I'm gonna do is assign it to actually Copilot. And what you'll see happens here now is I've assigned Copilot, and it'll view the issue. So it'll add a little eye emoji here, saying that the automation part has started. And you'll see what happened here is it created, an actual work in progress PR where you can track what's going on and what Copilot is working on. So it's gonna create first that draft PR, and it's gonna respond to your, assigning of the issue and say thanks for assigning to me. This is what I'm gonna do. And this is the plan that it's gonna kinda create based on the requirements you gave it. At this point, don't make any, additions to the issue itself because the context that Copilot has has kind of been locked in. So if you want to iterate, you have to do it within the PR. So you can add comments here and say, oh, instead of this change, I want you to do this, or I want you to do add initial, additional test cases. Whatever it is, you need to do it within the PR because at this stage, Copilot is no longer looking at the initial issue, and it's kind of locked its scope in, within the PR. So any of that collaboration needs to happen here, at that point. So what happened now is it started this development flow. So as an engineer would, right, very different from agent mode where you would have to prompt it, accept it, continue that kind of flow and process alongside Copilot, I could just leave this open, go have some coffee, have some lunch, and come back and see what Copilot's developed. Right? So that's kind of the benefit of having Copilot work as a software developer itself. It's it's taking in the requirements. It's, it's creating the code, And then it's still gonna look for that human interaction and feedback and before it actually merges that PR. So let's say I wanna track what's going on, right now. You can actually get a breakdown of what Copilot is actually doing. And what it's doing in the background is all powered by actions. So it's running on GitHub hosted runners and and performing all the operations and automation that it would need to do in order to comply with your initial issue. So you can always track this kind of session that it creates where Copilot is working in this in this isolated way to, perform those changes. And it's creating the code. It's testing it. It's, you know, running any troubleshooting that it needs to. It's it's gathering all of the context and information from your repository. All of this is happening, in the background. So you don't need to follow along with this, but you can always check your session logs and everything, in case there's any issues that Copilot comes across. As you also see here, you're gonna see premium requests used by Copilot within the session. So, you can actually get an estimate of, like, overall, what type of tasks does Copilot use more premium requests in. So let's say this is a very complex case, not as as simple as mine. It might use a lot more premium requests, but you'll be able to kinda see that total, counter on the top here. So as I'm kinda scrolling down, I'm seeing what it's doing in the background. It's it's performing a build, and it's gonna continue to kinda work in the state. What we can do is actually come back to this in a bit, and I can show you what more context Copilot is gonna pull as it, does this development. So one of the places that Copilot's gonna look for is within your dotGitHub, it's gonna look at this Copilot instructions. So if you have, like, custom, build steps that you need to for your application, Everything can be specified in this, instructions doc. You can also, preload any sort of prompts, saying maybe you want it to have, updated its images, have a specific design implemented, you know, define the full architecture, and give it success criteria as it's implementing all of these changes. This can be done at the repo already so that, you don't have to do it for each different issue that you create. It can just be kinda standardized across the board. So you're gonna you're gonna be able to kind of give it all of this context. Another thing, that it will look for in context is actually, MCP, and we'll talk about this in a little bit. But let's go back and check what progress it's made. If you see here, actually, it's taking all of the requirements that I gave and creating a plan, and it is check boxing each of those as it completes them. So you'll be able to see when it actually is done. It'll have all those check all those boxes checked off, and you'll be able to, see what exactly it's committed. So the initial commit it's created is the plan, and we'll come back and check on the code. But I'm gonna pass it back to Lewis and let kind of Copilot work in the background till then. Alright. Thank you so much, Tanvi. Amazing demo. Really love how it all comes together in the .com experience and, how you can track the session as well. So with that, that's a perfect segue to our next, part of our of our talk. Let me just share my screen again here. Alright. Thumbs up in the chat. We can see the screen. Yeah. Perfect. Alright. So, Candi covered a lot of great, parts of the experience of coding agent, also the difference between agent mode and and how you should frame, which surface of Copilot would you use depending your, your needs. Right? So this is a great, matrix that we have, that you can use, which summarizes a lot of the a lot of the distinctions here. You can think about it in in terms of, like, scope of the change that you're trying to make. And this also applies to, like, not only agent mode, but, like, once you are in the IDE and you have the different modes of the chat, how do you know which one you want to use? Right? So depending on the scope of change, if it's just the next few lines, you probably wanna use GitHub Copilot, GitHub Copilot, code completion, which you're in the flow, you're writing code. It does a really good job of collecting collecting the context automatically based on your open tabs, your your rows above and below your cursor, and it suggests you the next few lines of code. And the experience there, it's really quick. Like, in a in a few milliseconds, you'll see the suggestion, show up magically. Right? Now that's more in your inner loop where you're actively coding. But you also know, based on our recent sessions, about agent mode in the different modes of chat that you also have Copilot, chat edits, multifile edits mode. Right? And in multifile edits mode, it's a really good case to use it if you wanna modify multiple areas of the project, without having to go to each file and do it one by one. So you would use edit for there. And then agent mode in the IDE, it's it's more when you're trying to complete, like, a a task end to end in the current issue that you're working on. You can use the agent mode in Get Out Copilot chat. It normally takes a little bit longer because you have the option of using, more complex models, to do tasks like, brainstorming and implementation plan. So maybe you use a reasoning model, and those models take a little bit longer to respond. So you'll you'll notice that your interaction there takes a little bit a little bit more because you you're doing something more complex. Right? Now with Copilot coding agent, the really amazing benefit is that as you're working in your inner loop and with the different surfaces of Copilot and working in your current issue, if maybe I was implementing a new endpoint for the back end and I noticed, oh, I should actually have another one for, like, searching for for books. Let's say my back end is a book inventory service. I'm building an endpoint to, like, search by author. It would be amazing if I could have an endpoint to search by the titles of the book as well. I know in my project, we need to properly document, create an issue, go through the sprint planning, and then assign the job. But now that I have agent mode, MCP, and Copilot coding agent, I can just as I come up with the new fee, the new enhancement that needs to be documented, I just use the ask mode, come up with the plan, create the issue, assign Copilot to it, the Copilot coding agent. I know that I'm already uploading that work there. I continue in my current task. And once I I go to the web experience then I've progressed in in two issues in the same amount of time, a lot faster. Right? So it just potentiates your productivity that much more. I really liked also, seeing the how Copilot coding agent considers your custom instructions. So you already have custom instructions in your projects because, it helps it it's a really it's a really great tool to basically provide guidance on on the different surfaces of Copilot of how you want your suggestions generated and what to consider. Copilot coding agent plugs into that, so any custom instruction that you have there is already being considered. Right? You get that out of the box. We also talked a little bit about MCP. Yes. Your coding agent also has access to MCP. What is MCP? It's the motor complex protocol, the standard protocol that has been released recently. It's really, it's really popular right now. It's the standard that we have settled in and it allows your agent to execute actions on your behalf across the different other systems that you have either to acquire more context to do the task at hand or to modify something in that service. Good example, GitHub remote MCP server to create issues or to interact with the repository. So with that, I'm gonna hand it back to Tammy so we can see a little bit more, the demo of coding agent and where are the settings of MCP live, so you can get started with that as well. Thanks, Luis. Alright. So while our Copilot is still completing those tasks, let's go into Copilot settings. So this is the repo settings that I'm in here. And within this lives the Copilot coding agent settings. So here, actually, I can define different MCP servers, that I'm opening up for context for Copilot coding agent. So this is gonna be a little different from your agent mode view because it's gonna be, more of copilot coding agent executing upon those rather than you. So it's gonna auto infer which tools and services are available for it in order to complete the task that you are doing. So within, you know, agent mode, in the editor when you're interacting with MCP, you might be able to call out, you know, specific tools and refer to them in the chat and and continue that conversation there. But here, what Copilot coding agent is doing is actually making sure that it has these servers available, it has this context, and then it's going to use those for your different end result, which is actually your issue itself. We've also built in the, MCP for, GitHub itself within our interactions with chat. So if you want to do something like, let's say I want to go through the flow I had done before of creating an issue. I can go back to the repo. I can chat with Copilot. It's going to add that repo as that context, and I can say, create an issue to, you know, similar to before, add the card icon to my front end app. So because we have that connection within GitHub itself, you know, we can run the GitHub tools and, for example, creating an issue, assigning an issue, and having Copilot in that interaction again. So if you see here, it actually opened it up in this window. I don't have to go anywhere else or or click on a link, and I can iterate upon this. So I can ask it to add more details and get specific because it seems like the description is very general. So, I can kinda continue to interact with Copilot in this in this, view because I have those tools available to me through the GitHub MCP server. You'll also see, I can show you an example of when Copilot is completing its logs, it's going to look where your MCPs are available and call to those and actually pull out all the different MCP servers, from multiple sources, whether it's the one in the settings page, here, or if it's the one that's actually in the repo itself. So you can actually have an MCP JSON file in dot b s code, and it can refer to these to know which, MCP servers are available, for the coding agent to interact with it. So let's go back and see, our status for our PR. It looks like it's ready. It's no longer a work in progress. And Copilot has now asked, the developer who actually initiated the issue for a review. So you can perform this review. You can ask, you know, someone else in your team, a manager or a peer to perform the review as well. You could also even ask Copilot to do that review, which which might be a little weird that it's reviewing its own code, but you never know what it could miss. So you can ask it to do that review as well. I can see all of the, description and conversation has changed changed now because it's showing what's it's implemented. It's broken down by the UX, the design, the actual files it modified. It also did some testing on its own, and it also provided me screenshots of the fixed change. So this is, of course, on, it does not be pull pushed to the main branch yet because it's still in PR state. So if I do merge this, we can see that change. But, basically, it's changed into that review state now for me, so it's it's nice and ready. What I can also do is, you know, add my review, add any comments. If you see in the files changed, if you have any other changes that you wanted to make, you can review those. You can approve it or maybe say, hey, Copilot. Go back and fix this. You missed you missed this step. And if you go into the commits, you can get more specific on what changes it made to each, each file. So, yeah, overall, Copilot did a great job in just adding this functionality. I didn't have to yell at it or or stop it from, doing its thing. And we can also get an overall time estimate of how long it took. It took ten minutes fifty seven seconds, and it consumed 40 premium requests for this. So as, you know, we get more and more complex, you might use more, or you might use less for, you know, some really basic implementation that you're having, Copilot perform. Alright. I'm gonna pass it back to Lewis here. Alright. Well, thank you so much for that, Tammy. Really great seeing where the settings live and how you can configure it and how it actually recognizes the other MCPs there. So just, a lot of benefits overall of, like, having a really good initial setup of of Copilot with the different features that you have available. You'll see that as we continue adding, newer and better features, we're tapping into the existing platform, the existing solutions that are there to make it easier to everything to work together. Right? So I'm gonna share my screen again here. Mm-mm. So we can, segue into the next agent because, yeah, there's more. So, Copilot coding agent helps you go from idea into into, actually implementing the idea and having code and creating that pull request. Right? Getting you there to start the conversation. But you also have another agent available in the platform, which is the Copilot code review. Right? It's able to once we assign it to the code review, it's able to take an initial pass of the changes that are there on the on the diff of the pull request. And if you're a tech lead or your your main job is to review the new changes that are in the project, this is really helpful because as you get more and more PRs, you can start assigning the Copilot code review. It will follow your coding guidelines so you can configure, what are the coding guidelines and best practices for this project, things that you normally are looking for, in the PRs to review. And then the Copilot coding engine code Copilot code review will take those in consideration, and you'll notice that the the reviews that it's, it's calling out, like, the the issues that it's calling out, it's aligning to your best practices. So, the last demo we have here for for the session before we open up, to our q and a, it will be just looking at, Copilot code review with Tanvi, where the settings live for the, coding guidelines. And then we probably will maybe assign Copilot, coreview to the same PR for the coding agent, which is it's it it sounds like weird. Right? But, imagine it's, another another team member that you have that submitted a PR. And, yeah, I'll hand it back to Tanvi. Thank you. Okay. So what I have for you is actually a different PR that I created yesterday. Just for time's sake, so I'm not gonna have Copilot run the review. But it took about, like, a minute and a half, two minutes for it to do a full review, and this granted wasn't that large a commit. But, I've seen it take around a couple minutes for something like, let's say I when I in included, like, 8,000 line change or or something like that. So, what actually you're gonna see in the PR is, a summary of the changes that it reviewed. It will show summary for file. And then it also might suppress some comp comments due to low confidence. So it wants you to concentrate and focus on the major, suggestions and has during the review process. So if you see here, for example, it's, recommending, this is Java code, by the way. So it's recommending I, wrap this listener in order to avoid memory leaks, which, you know, could be one of the, custom instructions or guidelines I've given Copilot in order to, make sure that anyone who is, you know, developing in, let's say, Java or Python or JavaScript is following certain best practices, and not introducing, you know, memory leak as a bug or or, you know, some other things that they're including in their code. So, there's also the suggestion to match the back end rec route. So it's actually taking the logic from the entire application and making sure that any of these bugs are are resolved, that could potentially cause breaking code or have my, app not running. I actually when I had this, piece of code in my in my app, my front end was not loading at all. So I wasn't able to route to the correct, endpoint at all. It's going to do as much of a breakdown as it can within your code and understand it, And it's a little bit more powerful than the experience that you might have in the IDE. So, let's say you're asking Copilot in chat in your IDE to look at your code and review it. It might just do some basic best practices. It might not get as specific as it is because of the code review agent itself that lives in, GitHub is is a little bit more powerful than that experience. So you might have also used the code review, shortcut within the editor where you can have it, in Versus Code, go in and do review comments similar to this, that is also, like, one step below this whole, code of reagent mode that you'll see here. So what I can do from here is actually commit all the changes that it suggested. Maybe I don't like this comment, but I appreciate the comment to avoid memory leaks. Whatever I I want, I can go through that and iterate. There's also if you want to see it line by line and go through your code, you're also gonna see the same kind of view here. You'll also see it call out things that that it's nitpicking on, you know, so hard coding a jar. It's it's not, like, the best review comment, but it's fine. It's it's it's getting a little nitpicky here. So it's actually gonna call out things like that. So if I create a PR, all I have to do to actually trigger this is add Copilot as a reviewer. You can actually mandate that every PR created, within this or this repo has to be reviewed by Copilot initially and then has to be reviewed by another human or whatever your normal review process might look like. So, as a best practice, you can kind of have it there. So last night, I was playing around with Copilot and Code Review, and they've made some changes. And we're shipping fast, so, you know, the GitHub team is constantly thinking broader and how can we get to, you know, a better enterprise ready state. Right? So, initially, we had code coding guidelines here, and now we've kind of expanded to have custom instructions, apply broader to Copilot, whether it's in the repo or actually at the org level as well. So, instead, what I can do is have these, best practices within my Copilot instructions markdown file here that I have in my repo. And I can add any of the, like, let's say, avoid memory leaks or always add comments or use tags. Any of the, like, guidelines that I want for code review, I can include them in this instructions file. But that is now going to also be explored at the, broader org level as well. And I can show you kinda how that setting looks like. So we're continuing to update that kind of path, but you can have coding guidelines and standards and, you know, standard frameworks built out in this, view at the org level as well. Cool. I think that's all we had for the demo piece. I think we can open up for questions. Yeah. Thank you so much, Tanvi. Amazing to see, code review in action. Before we close out, we've we want to leave you with a few resources here. Make sure you're checking out the change log. Here, you're gonna see all the changes as they're coming live. As you can see, we updated the experience, so now you can filter by Copilot. You can, filter by new release improvements. So here you'll see all the improvements that have gone out in the recent days. We also have our public road map. So there you can stay up to date with the latest that's coming. And with that, thank you so much, and we're happy to answer any any questions. And I think we have Javier here, who will intro himself as well. Yeah. Hey, everyone. I'm Javier. I'm also a customer success architect here at GitHub. And, yeah, I have some questions prepared that I saw popping up. Firstly, how do you audit or use guardrails for tools that are exposed to the agent when working with MCP? Right. So, currently, within coding agent, MCP is still in preview. So it's more on the onus of the of customer to, you know, kind of filter out which of these MCPs. Are they from, like, a approved provider? Are they the the first party, servers? Are they coming from, you know, a malicious source? It's it's sort of up to, the customer right now. With the GitHub MCP server, you know, there's there's guardrails we have in place to make sure that, you know, when you're interacting with with, GitHub itself, creating issues and things like that, you're not doing any English activity, but that's because we are we are more in control of that and we're, you know, our development team is making sure that there's there's nothing which is there. So it's kind of on you to check, you know, is this an approved one from, like, Atlassian, provider, and and make sure that that that it's secure. And, also, use best practices with, like, tokens and everything. So if if you have, like, OAuth available, like, we have OAuth, use use that instead of using, like, a a access token that has access to, you know, a wide scope of repos. So so make sure that your authentication is is secure. Yeah. And I would add as well that MCP is as a protocol is has been released in the last few months. It's it's an effort that's across the whole industry. They're working on fully, defining the standard and getting it enterprise ready as well. There is an open, open source PR already for, like, the authentication layer of how it should be implemented in the standard. So, stay close to the developments with MCP. It's gonna be where everybody what, like, the whole industry is gonna go. So as that new things come out, like the o auth and the new improved security for when you're building your MCPs, you wanna make sure that you're vetting servers created by providers or by others that they're following the spec and the latest version of it as well, giving to all the best practices. Awesome. Thank you. Another question, is can Copilot, coding agent be configured to use different models? If what is the default model? Yeah. So right now, I believe the default model is called Sonic four. We currently don't have the ability to pick your model. Ideally, I think the state we wanna get to is that Copilot coding agent will automatically pick model based on the complexity of the task that you've given it. There's discussions there from product, and there's also a discussion maybe eventually to have it. We pick, but currently, we're kind of locked in with SONNET four. Awesome. Awesome. Another great question was, when you're using Copilot coding agent, how are the actual repository permissions acknowledged? Does it matter who assigns the PR to Copilot? Yes. So you have to have, right access to that repo, in order to add Copilot, because it's going to look for, like, your review and your collaboration within that. When it actually performs the coding change, it's not just saying it's assigned to Copilot. It's gonna say it's assigned to the developer who created it as well as, Copilot. And, also, I think it uses someone could confirm this, but the premium request used for the the person, who created the issue so that that individual developer. Yes. And then in the PR level, normally, it's always good practice to have, a review and that review like, enforcing rules that's where that review should not be from the same developer. In this case, because the code review is created by your coding agent, tags you automatically, the developer that kicked off the coding agent won't be able to just say, oh, yeah. This looks good to me. Just merge, into main. Right? So as a review from, someone else from the team as well, you can enforce that by using our rule sets, best practices there, our feature set there. So yeah. Yeah. Exactly. Awesome. And then kind of a theme that I noticed throughout the questions was, how do you use Copilot instructions when it comes to the GitHub coding agent? How can you kinda guide it, and make sure that it has certain guidelines to work with? Yeah. So, maybe if you could expand, Harvey, what do you mean, like, it's like an example of of how you could use it? Or what was your sentiment? Or on, I guess, custom instructions for coding agent, and how people can use them. Yeah. I would say if you're already using custom instructions in agent mode today in the IDE, take a similar approach. Apply those same instructions to the coding agent as well. You would create them the same way you do now with that markdown file and push it to your repo because that's where, coding agent's gonna look for first is that dot GitHub kind of flow, within that. So you can follow that file structure, make sure it's marked down, and just add more and more information, for that within your repo as possible, and kinda test out how Copilot's interaction with it. But similar to how you would with agent move today. Awesome. And just a follow-up that popped up in the chat right now was, can custom instructions be scaled to an org instead of just one repo? Yeah. That's exactly what, I kind of alluded to the at the end was that we're we're working on, having this org wide, for coding agents so that you're not having to distribute individual, custom instructions per repo. You wanna scale that. Awesome. Can you also share a little bit of insight on how premium requests get used by the agent? How are, the premium request, you know, counted when it comes to coding, reviewing, building, etcetera? Yeah. So it's going to use, one premium request per kind of task it has to execute. So if you saw, there was a lot lot of things that within the workflow it had to perform. So it took around 30 to 40 because, first, it had to pull the information. It had to make the changes. It had to test it. So each kind of, breakdown within the session itself consumed a premium request. So I know this can sound like a lot just because, you know, each interaction is using maybe 30% of your your monthly allowance. But we're hoping that, you know, we can scale this number down eventually and get to more, stage where you're using, less, and it's automatically kind of cleaning up some of the other tasks that it has to perform. Awesome. And then just one last question on general availability. Is Copilot Coding Agent available in enterprise? So just as of this week, Copilot Coding Agent became available to Copilot for business users. So as long as you have a Copilot Business or Copilot Enterprise or even Pro Plus or Pro. As long as you have a license there, you can use, coding agent. For general availability, we're not exactly sure on timeline, I believe, later this year, but we should know more around our GitHub universe, which is October. Yeah. And I did see, another question kinda related to release of the coding agent. It lives in GitHub.com. I I know that question was a little bit related to, like, Visual Studio and and where we are there. This will live in in GitHub.com. You do have Copilot agent mode since, May, where we hosted build. Now Copilot agent mode and MCPs are supported across all our, IDEs. It's in it's in GA for Versus Code. It's in GA for Visual Studio. It's in preview for JetBrains, Xcode, and Eclipse. So you already have, the agent mode and MCP server functionality and and all our ITs there. Awesome. Think that wraps up everything that I've seen. Thank you for the fantastic session. This is really informative. Yeah. Yeah. Thank you so much. We had a great time. Thank you everybody for tuning in and staying the whole the whole one hour with us. I'll let Tammy say her goodbye. But from my side, really grateful for having you all here and amazing questions. Yeah. No. Really appreciate everyone, all the interaction, and all the great questions. I think we have a lot of follow ups and and information that we can share as well with with customers and continue to have these conversations. But, hope everyone had a good time using CodingAgent, and happy coding everyone. Thank you all