You've probably already used GitHub Copilot to write code, maybe every day this week. GH-600 doesn't test that skill, though, because it isn't about writing better prompts. It's about proving you can run and supervise the agents that write, review and sometimes ship that code for you.
That's a bigger job than it sounds. Coding agents don't just suggest a line anymore: they open pull requests, run tests, and on some teams they merge code with almost no human review. That's a real shift in how software gets built, and it's opened a genuine gap. Someone on the team needs to know how to supervise these agents properly, and right now not everyone does.
GH-600 was built to prove you're one of the people who can. It's aimed at developers who already trust agents with real work, not people who've tried autocomplete a handful of times. GH-600 covers a lot of ground, so here's what the exam tests, who it's really for, and how to prepare for it.
GH-600 at a glance
The quick facts before the detail:
- Certification: GitHub Certified: Agentic AI Developer
- Exam: GH-600 (provided by Microsoft, maintained by GitHub)
- Level: intermediate
- Length: 120 minutes, proctored, scheduled through Pearson VUE
- Passing score: 700
- Prerequisite: none required
- Domains: six (weightings below)
- Languages: English
- Fee: varies by country, so check Microsoft's page before booking
What makes GH-600 different
GH-600 stands for GitHub Certified: Agentic AI Developer. Microsoft runs the exam, but GitHub owns the certification and the syllabus behind it, according to Microsoft's own GH-600 certification page. That's worth knowing, because it means GitHub decides what counts as expertise here, not Microsoft's usual certification team.
The exam is rated intermediate. It runs for 120 minutes, and you sit it through Pearson VUE, the same as most Microsoft-administered exams. You need a score of 700 or higher to pass.
Six roles are named as the target audience:
- AI engineer
- App maker
- Data engineer
- Developer
- DevOps engineer
- Solution architect
The common thread isn't the job title, it's the work. You're expected to already operate, integrate and govern AI agents inside a real software development lifecycle, not experiment with them in a sandbox. That real-world expectation shows up directly in what the exam tests.
What does GH-600 actually test?
GH-600 splits its content into six skills domains, according to Microsoft's GH-600 study guide. That's more domains than most certification exams use, and it tells you something on its own: this exam wants the full lifecycle of running an agent, not one slice of it.
- Prepare agent architecture and SDLC processes: 15 to 20%
- Implement tool use and environment interaction: 20 to 25%
- Manage memory, state and execution: 10 to 15%
- Perform evaluation, error analysis and tuning: 15 to 20%
- Orchestrate multi-agent coordination: 15 to 20%
- Implement guardrails and accountability: 10 to 15%
Tool use and environment interaction carries the most weight, and it's also where MCP servers live. MCP stands for Model Context Protocol: it's what lets an agent reach outside its own conversation and actually touch your tools, your repos and your environment. If you've only used Copilot for inline suggestions, this is the domain where you'll need real hands-on practice rather than reading.
The other five domains are lighter individually, but together they cover the parts people skip. Teams get excited about what agents can do; they're less excited about governing them. That governance is the real content here: holding memory and state across a long task, evaluating whether an agent's output is actually good, coordinating several agents at once, and building in the guardrails that stop any of it running unsupervised. It's a lot of ground, which makes it fair to ask who's actually expected to know all of it.
Who this exam is really for
There's no formal prerequisite certification for GH-600. You don't need to pass another exam first. That doesn't mean no experience is needed, though, and Microsoft's own guidance is clear about what you should already know.
You should be comfortable with the software development lifecycle. You should know GitHub's workflows and controls well. You should already care about code quality, security and proper review, not only shipping fast. And you should have real, hands-on time with coding agents already, including GitHub Copilot, MCP servers and agent customisation: custom instructions, custom agents, tools, the whole setup.
If that list feels mostly familiar, you're in the right place. If GitHub Copilot is still new to you, our GitHub Copilot (GH-300) course is the honest place to start. It won't get you certified on GH-600 by itself, but it builds the foundation this exam assumes you already have. Once that foundation's in place, real preparation looks a little different from what you'd expect.
How to prepare for GH-600
Before you book, spend two minutes on pricing: Microsoft occasionally posts a discount code for newer exams on the Microsoft Learn blog, so it's worth a quick check in case one applies. Then the study path is straightforward.
Start with Microsoft's GH-600 study guide above, which maps every domain to what you're expected to know. GitHub also runs an exam sandbox so you can see the real question format before test day, worth doing once you've covered the material rather than as your first step.
The gap most people underestimate isn't knowledge, it's practice time: actually running agents against real repositories, configuring MCP servers, watching an agent fail a task and working out why, and building in the guardrails that stop it doing something you didn't ask for. Reading about this gets you partway. Doing it is what the exam actually tests.
If GH-600 is one certification among several your team is building towards this year, Unlimited AI and Copilot Training covers the wider Copilot and AI stack instead of booking each course separately.
GH-600 is new enough that being early still counts for something. Get comfortable with the fundamentals in our GH-300 course if you need to, put in real hours with agents on real code, and then sit the exam knowing you can actually supervise what you built, not just switch it on.
