Github Copilot for Azure with Agent Mode now in GA!

By Ivana Tilca · June 26, 2025 · 4 min read

GitHub Copilot for Azure is officially GA — and it brings Agent Mode, which turns Copilot from an assistant that suggests code into one that executes full Azure workflows. Here's what's new, how Agent Mode works, and how to use it responsibly.

What started as an exciting preview at Ignite 2024 has now blossomed into a game-changing tool: GitHub Copilot for Azure is officially Generally Available (GA). If you build and operate things on Azure, this is one of those releases that quietly changes your day-to-day, because it moves Copilot from "autocomplete that knows code" to "assistant that knows your cloud." And with GA comes the piece I'm most excited about: Agent Mode.

What GitHub Copilot for Azure actually is

Let's be precise, because the name gets confused with regular Copilot. GitHub Copilot for Azure is an extension that brings Azure awareness directly into your editor. Instead of tab-switching between VS Code, the Azure Portal, and a dozen documentation pages, you ask questions and issue instructions about your Azure environment right where you're already working — and it answers with context about your actual resources.

What's new in the GA release

With GA, the tool is now enterprise-ready. The headline capabilities:

Visual Studio Code integration. You work in your comfort zone, with Copilot support built into the editor rather than bolted on.

Smart Azure context. Suggestions are grounded in your real Azure resources — your subscriptions, your resource groups, your deployments — not generic examples.

Agent Mode. Copilot now orchestrates full workflows, not just code snippets. This is the big leap, and it deserves its own section.

Security and compliance. Enterprise-grade protections are built in from the start, which is what makes this usable inside real organizations rather than just on personal projects.

Agent Mode: from suggestions to actions

Here's the mental shift. Regular Copilot is a brilliant assistant that hands you code and lets you do the rest. Agent Mode is more like a capable teammate who's always on: you give it a goal, and it breaks the work into steps, executes a multi-step workflow, and interacts directly with your Azure setup — with your approval at each meaningful step, of course.

Concretely, that means you can ask it to:

Generate Azure-friendly code that follows best practices, instead of the first thing that compiles.

Build and tweak infrastructure-as-code templates (Bicep, ARM) rather than hand-writing every line.

Deploy apps and troubleshoot in real time, in the same conversation.

Check resource health, certificates, and settings without leaving the editor.

The way I like to explain it: Copilot used to answer "how do I do X?" Agent Mode answers "please do X," and then walks through it with you.

Prompts that show the difference

The best way to feel the shift is to see the kind of natural-language requests that now just work:

"Show me all Azure storage accounts by region."

"Create a Bicep template for a storage account in West US."

"Update the template to move the account to East US and rename it cleanly."

"Deploy it using the Azure Developer CLI."

Notice how those chain together. You're not writing four disconnected snippets — you're having a conversation where each step builds on the last, and the agent keeps the context.

Getting started is genuinely easy

You don't need a complicated setup to try it:

Install GitHub Copilot for Azure from the VS Code Marketplace.

Open Copilot Chat and switch to Agent Mode.

Start typing Azure-related requests in plain language.

Let the agent handle the heavy lifting — reviewing each step it proposes.

That fourth point matters and is worth underlining: you approve access and you approve actions. Agent Mode is powerful precisely because it can do things, so keeping a human in the loop on anything that changes real infrastructure isn't a formality — it's the right way to use it.

Why this matters (and a note of caution)

The reason GA is a bigger deal than the preview is trust. A preview is something you experiment with; a GA release with enterprise security and compliance is something you can actually adopt in a team. That's the threshold where a tool stops being a novelty and starts changing how work gets done.

My honest advice: lean into Agent Mode for the repetitive, well-understood tasks — scaffolding templates, standing up standard resources, routine health checks — where it saves real time and the risk is low. Stay hands-on and review carefully when it touches production, security settings, or anything you can't easily undo. Used that way, it's less "the AI does my job" and more "the AI clears the busywork so I can focus on the decisions that actually need me."

The future of cloud development is agentic, and it's arriving faster than most of us expected. GitHub Copilot for Azure going GA with Agent Mode is a concrete, usable piece of that future — not a demo, but something you can install this afternoon and feel the difference by tomorrow.

Ready to rethink what's possible with DevOps? Let's build something brilliant.