GitHub Copilot Modernization Agent Reaches GA, Scaling Legacy Upgrades Across Entire Portfolios

GitHub Copilot Modernization Agent Is Now Generally Available

Microsoft has announced general availability (GA) of the GitHub Copilot modernization agent, an AI-powered orchestration tool that handles application assessment, upgrade planning, and code-level remediation across entire portfolios. Instead of modernizing one repo at a time, teams can now run coordinated, repeatable modernization workflows across Java, .NET, C++, and JavaScript/TypeScript projects from a single CLI. [1]

What the Modernization Agent Actually Does

The agent operates through the Modernize CLI and follows an Assess. Plan. Execute. model. Here is the breakdown of its capabilities:

• Multi-repo assessment. It scans multiple applications and repositories simultaneously, identifies modernization opportunities, maps dependencies, and produces cloud readiness scores. [2]
• Framework upgrades and language migrations. It handles runtime upgrades (for example, Java version bumps, .NET Framework to .NET 10), SDK-style conversions, Newtonsoft.Json to System.Text.Json swaps, and Azure Functions isolated worker model upgrades. [3]
• Customizable skills. Teams can encode organization-specific migration patterns, internal library replacements, and coding standards as reusable “skills” so that every repo follows the same rules. [4]
• Structured planning with traceability. It generates reviewable plans with ordered tasks, success criteria, and version-controlled tracking at each step.
• Autonomous execution. It applies code transformations, dependency updates, and validation checks automatically. Every change is committed and traceable.
• Batch operations and CI/CD. Run workflows across multiple apps in non-interactive mode. Plugs into existing pipelines for scheduled or on-demand modernization at scale. [5]

The agent works across Visual Studio, VS Code, GitHub Copilot CLI, and GitHub.com. Prereqs are a GitHub Copilot subscription (Free through Enterprise) and GitHub CLI v2.45.0 or later. [6]

How to Get Started

1. Install the Modernize CLI. On Windows: winget install GitHub.Copilot.modernization.agent. On Linux or macOS, use the corresponding install script for your platform. [6]
2. Authenticate. Run copilot auth login to connect your GitHub Copilot subscription.
3. Run an assessment. Navigate to your project root and run the appropriate scenario command, for example modernize plan create "upgrade to .NET 10" --source /path/to/project --language dotnet. [7]
4. Review the plan. The agent generates a task list with success criteria. Check it before approving any execution step.
5. Execute and validate. Let the agent apply changes, then run your normal build and test pipeline to verify the output.
6. Batch across the portfolio. Use the batch assessment and batch upgrade commands to process many repos consistently. [5]

If the agent misidentifies your project or fails to discover scenarios, Microsoft recommends that you have a .sln, .csproj, or .vbproj in the workspace root. [8]

Pain Points and Practical Workarounds

“The agent produces changes I did not expect.” The modernization agent is non-deterministic, meaning results will vary between runs. Always review the generated plan before approving execution. Microsoft explicitly recommends running assessments in read-only mode first, generating reports in a separate sandboxed branch, and validating build and test pass rates before merging to main. [9]

“I have internal libraries and proprietary patterns.” Use custom skills to encode your own migration rules. The quickstart for custom skills shows how to define organizational knowledge for internal library upgrades, configuration updates, and coding standards. [10]

“I need this in CI/CD, not just my laptop.” The CLI supports non-interactive batch mode. Microsoft has published a full walkthrough of wiring it into scheduled pipelines for recurring assessments and upgrades across many repos. [11]

What This Means

Application modernization has always been a two-speed problem: the assessment side (spreadsheets, consultants, months of analysis) and the code side (manual find-and-refactor, one repo at a time). By connecting portfolio-level infrastructure assessment directly to code-level remediation in one governed workflow, Microsoft is betting that the bottleneck for cloud migration is no longer technical complexity, it is coordination overhead. The GA signal means this is no longer experimental. For teams sitting on legacy Java or .NET Framework estates and wondering how to start without hiring a modernization consultancy, there is now a repeatable, version-controlled, internally customizable path forward. The tool will still get things wrong. It still needs human review. But it changes the conversation from “which app do we start with” to “how do we run this across everything, consistently.”