Weekly GitHub Copilot Roundup: New Models and IDE Agent Updates

GitHub Copilot adds Claude Fable 5.2, Gemini 4 Carbon, and Gemini 4 Hydrogen as six model retirements approach on December 14, making replacement access, usage-based pricing, and data-retention policies immediate decisions for teams. Visual Studio 18.12 makes SDK-powered Copilot Chat the default and brings Bring Your Own Model to general availability, allowing hosted or local models in Agent Mode without GitHub sign-in. Copilot for Xcode gains stable Custom Agents, Subagents, and Plan Mode, while GitHub Enterprise Server support becomes generally available in the Copilot app and enterprise GitHub Apps gain seat-management APIs. Across modernization guidance and agent-assisted engineering examples, the shared emphasis is on explicit permissions, isolated execution, and independent validation rather than treating agent output as proof that a change is safe.

This Week's Overview

Planning Java and .NET upgrades with Copilot

Copilot modernization guidance pairs upgrade automation with support deadlines, review checkpoints, and isolation. The practical work includes assessing breaking changes, keeping build and production settings aligned, and deciding where developers must take control.

Java support milestones require runtime planning

Azure App Service and Azure Functions support for Java 8, 11, and 17 ends September 1, 2027. Applications will continue running afterward, but those Java versions will no longer receive security updates, improvements, or related customer support. Microsoft Build of OpenJDK separately lists September 2027 as the earliest support end for Java 11 and 17, with possible extensions.

Modernize CLI supports upgrade assessment, planning, and execution, and requires both a GitHub Copilot subscription and GitHub CLI. The guide recommends aligning Maven settings, GitHub Actions, and production runtimes rather than treating the source upgrade as the whole migration. Staging validation and prepared rollback paths remain part of the deployment work.

Reviewing an agent-assisted .NET migration

An end-to-end .NET migration demonstration shows how agentic modernization assesses potential breaking changes before upgrading and prepares the resulting change for team review. It distinguishes the work the agent performs from the points where developers regain control. Custom skills can extend the workflow when a codebase does not fit the default migration path.

Containing modernization agent risks

A companion session examines isolation options for Copilot CLI modernization plugins, including protection against accidental file deletion and access to unintended resources. Its distinction is useful: sandboxing contains the consequences of agent behavior rather than eliminating that behavior.

Copilot model choices expand ahead of December retirements

New model availability comes with different subscription eligibility, access policies, and data-handling requirements. Teams should review those differences alongside the December deprecation schedule rather than treating every model as an interchangeable option.

Claude Fable 5.2 adds an explicit policy decision

Claude Fable 5.2 is rolling out gradually to Copilot Pro+, Max, Business, and Enterprise subscribers, with usage-based billing at provider list pricing. Business and Enterprise administrators must enable its policy, which is off by default. Availability therefore depends on both the rollout and organizational approval.

Anthropic retains prompts and outputs for safety classifiers but does not use that retained data to train its models. Eligible enterprises can use Fable 5, 5.1, and 5.2 with zero data retention through 2026. Continuing that arrangement afterward requires Enterprise Frontier Safeguards, making retention requirements part of the adoption decision.

Gemini 4 Carbon targets complex coding work

Gemini 4 Carbon is generally available for Copilot Pro+, Max, Business, and Enterprise users, with gradual availability across supported editors, applications, and GitHub surfaces. It targets complex coding, agentic, reasoning, and security-focused tasks. Billing follows provider list pricing under Copilot's usage-based model.

Business and Enterprise administrators can manage access through Copilot settings and default model enablement policies. Developers evaluating Carbon should check their organization's policy and the availability in their preferred interface before building a workflow around it.

Gemini 4 Hydrogen reaches Copilot Pro and higher plans

Gemini 4 Hydrogen is generally available to Copilot Pro, Pro+, Max, Business, and Enterprise subscribers, with improved instruction following over Gemini 3.8 Flash. Its gradual rollout includes Visual Studio Code, Visual Studio, Copilot CLI, and GitHub Copilot coding agent. Like Carbon, it uses usage-based billing at provider list pricing.

Business and Enterprise administrators can control access through model policy. Default model enablement automatically enables new models unless disabled, so organizations should check whether Hydrogen becomes available automatically under their current settings.

Six model retirements are scheduled for December

GitHub Copilot will deprecate six models across all experiences on December 14, 2026. Suggested replacements include Claude Fable 5.1, Claude Haiku 5.5, Gemini 4 Hydrogen, Gemini 4 Carbon, and Grok 4.7, while a replacement for Kimi K3 has not been announced. Claude Haiku 4.5 remains available to individual subscribers on annual plans.

For Business and Enterprise customers, suggested alternatives are automatically enabled under default model enablement unless administrators disable the global default or specific models. Teams should check replacement access before the retirement date, particularly where model-specific policies prevent automatic availability.

Local coding model results need hardware context

MAI-Code-1.1-Flash, a 137.9-billion-parameter mixture-of-experts model, has a released 53.0 GiB mixed-precision checkpoint available through Microsoft Foundry and as the local model in GitHub Copilot. At 120K input tokens on RTX Spark, speculative decoding increased median throughput from 25.81 to 51.12 tokens per second. Sliding-window attention reduced reserved draft-KV memory at 262K context from 5,120 MiB to 1,156 MiB without retraining.

These measurements used RTX Spark with 128 GB unified memory and a 64 GB GPU allocation. They describe that serving configuration, not expected performance on other Windows PCs.

Visual Studio changes its agent experience and model configuration

Visual Studio 18.12 brings both a default SDK-powered Copilot Chat experience and generally available Bring Your Own Model support. The changes address how agents execute work and how developers choose the models behind them.

SDK-powered Copilot Chat becomes the default

The new Copilot Chat experience is enabled by default in Visual Studio 2026 version 18.12. In an evaluation of 157 real C# tasks using GPT-5.6 Sol, it resolved 124 tasks, compared with 103 for the previous experience. Developers can submit instructions while tasks run, inspect step outputs, and follow delegated subagents through individual cards.

Agent skills can work without modification across Visual Studio, VS Code, Copilot CLI, and the GitHub Copilot app. Plan mode and chat exports are still being brought over, so the new experience does not yet include every previous capability. Developers who need to switch back can disable it in settings and restart Visual Studio.

A related video examines the Copilot SDK-powered agent harness, expanded model and provider access, and configuration controls in .NET workflows. It provides a broader walkthrough of the direction behind the updated experience.

Bring Your Own Model reaches general availability

Bring Your Own Model is generally available in Visual Studio 18.12, allowing developers to use hosted or local models in Agent Mode without GitHub sign-in. A single provider can have multiple configurations with separate connection details and models. Custom models support OpenAI-compatible Completions and Responses formats and Anthropic-compatible Messages.

Provider connections and Agent Mode use Visual Studio's resolved proxy configuration. Administrators can enable or disable Bring Your Own Model through organizational policy, giving teams a control point for custom model access alongside the developer-facing configuration options.

JetBrains integration requires choosing an experience and a supported IDE

The JetBrains material distinguishes Air's built-in Copilot access from plugin capabilities, while separate notices raise upcoming minimum IDE requirements. The older AI Assistant integration article now explicitly directs readers to Air.

Air provides default agent access without a separate plugin

GitHub Copilot appears in JetBrains Air's default agent picker through Agent Client Protocol, without requiring a separate Copilot plugin installation. Air's Cloud Run experience added Copilot support starting November 3 alongside Local Run. These experiences require a Copilot subscription and support agentic coding, parallel sessions, project context, and model selection.

JetBrains IDEs version 2026.2.4 and later can use Copilot as a provider for native Next Edit Suggestions. The Copilot plugin remains a separate choice for enterprise controls, Local Sandbox, inline chat, code review, and commit message generation that Air does not include. Teams should choose based on those workflow and control requirements, not only the presence of Copilot in the agent picker.

The original AI Assistant article described automatic discovery with a valid subscription and required credentials. Its November 4, 2026 editor's note says that experience is outdated and points to Copilot in JetBrains Air, so it should not be read as a separate new integration.

Support notices cover both 2025.1.x and 2025.2.x

One notice ends Copilot support for all JetBrains 2025.1.x patch releases in the next few months, setting a minimum of 2025.2.x and recommending 2026.1 or later. A separate notice covers 2025.2.x, platform build 252, with a coming minimum of 2025.3.x and a recommendation to upgrade to 2026.2 or later. Microsoft's stated general principle is to support approximately one year of JetBrains IDE releases.

Existing plugins are expected to keep working and will not be immediately disabled when support ends. Affected IDE versions will stop receiving new features, bug fixes, and performance improvements, and future plugin updates may be incompatible. Developers should upgrade the IDE, update Copilot through Settings > Plugins, and restart if prompted rather than relying on continued operation of an unsupported installation.

Xcode gains configurable agents and additional models

The stable Copilot for Xcode release expands both agent workflows and model selection. The capabilities require a valid Copilot license.

Custom Agents, Subagents, and Plan Mode

Copilot for Xcode now includes Custom Agents, Subagents, and Plan Mode. Custom Agents let developers define workflow-specific instructions, constraints, and tools. Subagents run in isolated contexts and are invoked automatically in Agent Mode when appropriate, separating delegated work from the main agent context.

GPT-5.1 model availability

GPT-5.1 models, including GPT-5.1-Codex and Codex-Mini, are now available in Copilot for Xcode. These additions accompany the stable agent capabilities rather than requiring a separate preview experience.

VS Code demonstrations cover orchestration, sessions, and Python workflows

The VS Code material spans recent Copilot demonstrations, guided Azure application development, and an explicitly older Python release reference. Feature availability in the release videos can vary with enterprise policy or pricing plan.

Model orchestration and local automation

The Visual Studio Code 1.144 and 1.145 video demonstrates selected Copilot features, including Fusion model routing and orchestration. It also shows computer use, which lets agents interact with desktop applications, and local automations based on cron schedules and custom agents. These demonstrations cover selected capabilities rather than a promise that every viewer's plan or policy enables them.

Session management and CLI handoffs

The Visual Studio Code 1.146 walkthrough covers Inbox mode for sessions, inline actions in the session list, chat windows, and model comparison improvements. It also discusses the Copilot harness and deprecation of the Local harness, computer sharing configuration, and continuing a Copilot CLI session in VS Code.

A separate release recap presents demonstrations of VS Code and Copilot updates from the past month. Together, the videos provide walkthroughs for developers evaluating changes to their session workflow, with the 1.146 video explicitly covering selected features rather than the entire release.

Guided Azure app development adds Python

Python projects now have full support in the guided Copilot experience for building Azure applications in VS Code, joining the initial JavaScript and TypeScript support. Developers review and approve a proposed architecture before code generation, then review deployment tools, Azure resources, and estimated costs before deployment. To start, install the Azure Tools extension pack and open an empty folder in VS Code.

Earlier Python tooling provides documentation and import helpers

The supplied November 2025 Python release article is an older reference, not a November 2026 update. It describes inserting Copilot Hover Summaries as formatted docstrings with Add as docstring and having Pylance summaries respect the VS Code display language. Other changes include converting wildcard imports to explicit imports while preserving aliases and supporting project-specific debugger interpreters when python.useEnvironmentsExtension is enabled.

Enterprise access expands in the Copilot app and management APIs

Enterprise updates address two different access needs: connecting the Copilot app to server-hosted work and automating license assignment. Each has its own setup requirements.

GitHub Enterprise Server support becomes generally available

GitHub Enterprise Server support in the Copilot app is generally available after an opt-in preview. In app version 1.2.0 and later, users can add a server account to work with remote repositories, issues, and pull requests. Cloud sessions are not available for GitHub Enterprise Server.

Users must first sign in with a GitHub.com or GHE.com account. They can then add the server account through Settings > Accounts > Add account, so server support does not replace the initial sign-in requirement.

GitHub Apps can manage enterprise Copilot seats

Enterprise GitHub Apps can now assign Copilot seats to users and enterprise teams through enterprise-level seat management APIs. Access requires the new Enterprise Copilot license management fine-grained permission for Apps, which administrators must account for when configuring license-management automation.

Agent-assisted engineering puts verification into the workflow

The engineering examples show reusable instructions, repository-wide automation, and isolated execution environments. They also expose a recurring limitation: an agent's apparent confidence or a dependency's version label does not establish that a change is safe.

Portable skills still depend on their host

An agent skill is a versioned directory centered on SKILL.md, while the host supplies the tools, credentials, and permissions required to execute it. The Data Forge example separates project configuration into a manifest and assigns defined responsibilities to skills. Its support-desk workflow has seven phases, each with a human checkpoint.

Proof Agent performs static diff review without running code or tests and returns PASS, FAIL, or PARTIAL with evidence. That boundary matters when interpreting its result: static review is not test execution. A packaging script generates client-specific files for Claude Code, Cursor, and GitHub Copilot from shared skill instructions.

Aspire rollout uses deterministic repository checks

By May 2026, more than 50 microservice repositories had adopted Aspire, up from approximately 15 reported in the previous post. The MARS rollout system combines Aspire, Microsoft Agent Framework, and GitHub Copilot SDK in a check, plan, fix, validate, and learn loop. Deterministic C# metrics define repository health, while cloud checks use Azure DevOps pull request and build snapshots.

The team estimates that agentic onboarding removes 4-8 hours of manual setup per repository. The rollout system's end-to-end suite contains over 700 tests and runs on every pull request against the system, providing a validation mechanism alongside the onboarding automation.

Governance automation spans repository remediation

Jeff Doolittle's session describes building an automated governance system with Copilot in four days without manually writing code, addressing a compliance backlog across 436 repositories. The approach combines GitHub Actions and custom Copilot prompts to enforce remediation lifecycles. The session covers reversible enforcement, self-service remediation, and achieving 100% repository compliance.

Cosmos DB task isolation separates data, not agent trust

An agentic continuous integration and delivery sample gives each coding task its own Git worktree, Azure Cosmos DB emulator, versioned fixtures, and task-specific artifacts. Its isolation proof checks independent writes with identical document identities and verifies that removing one emulator leaves the other readable. An observed GitHub Actions run completed three genuine Copilot tasks and passed 75 combined tests against a fresh emulator.

The real-agent job uses GITHUB_TOKEN rather than a stored personal access token and caps usage at 150 AI credits across five possible sessions. The emulator containers do not sandbox untrusted agents. Passing emulator tests also does not validate live-account authentication, authorization, throughput, or production performance.

Semantic version labels influence agent scrutiny

Researchers used Microsoft's Vally evaluation tool and Copilot CLI to test identical dependency-update code under different semantic versioning labels. In the first experiment, Claude Sonnet 5.5 checked 2 of 10 patch upgrades and all 10 major upgrades. A larger review experiment covered 540 runs across six models, six scenarios, and patch, minor, and major labels.

Claude Haiku 5.5 merged updates unchecked in 37% of patch runs, compared with 7% of major runs. Four breaking-update merges left main broken, all involving patch or minor labels. These results support checking dependency changes independently of the version label rather than letting that label determine the depth of validation.

MCP tools connect agents to application and operational context

Model Context Protocol (MCP) integrations provide structured information that agents can query while working. The Spring and Azure Monitor examples differ in setup and permissions, but both make the boundaries of tool access explicit.

Spring Tools exposes project diagnostics in Eclipse

Spring Tools for Eclipse 2.0 or later can connect its experimental embedded MCP server to the GitHub Copilot plugin when a Spring Boot project is open. Developers must explicitly enable the server in Eclipse preferences. Spring Tools then registers it in Copilot's Eclipse configuration and keeps the port configuration current.

The tools run in Copilot Agent mode, not standard chat mode. Demonstrations retrieve registered beans and Spring-specific diagnostics with issue locations, severity, and validation messages, giving the agent structured project information to work from.

Azure Monitor dashboard tools retain user permissions

The global Azure Monitor dashboards with Grafana MCP endpoint requires no Azure Managed Grafana resource, MCP server deployment, or Grafana data source configuration. It offers 21 tools across five groups: 20 read-only tools and one for updating existing saved dashboards. Every call uses the signed-in user's Microsoft Entra ID token and existing permissions, so signing in grants no additional access.

Dashboard updates support validation without saving and version checks to prevent overwriting intervening edits. The endpoint supports user sign-in only and cannot create dashboards or access Grafana alerting, Loki, SQL, or ClickHouse tools.

Copilot-assisted physical projects depend on measurements and device feedback

The physical-project examples extend Copilot work into generated geometry, lights, desktop companions, and badge applications. Their useful details are the instructions, checks, and feedback mechanisms around the generated code and models.

Building and checking printable models

A 3D modeling workflow uses Python for measured geometry and Blender for organic shapes, with Copilot editing generators, scenes, model files, and documentation. Its dragon reference records 25 extracted video frames and uses a 25.75 mm coin diameter to estimate scale. The model separates five parts across four single-color plates, and documented collision checks found no intersections across 25 positions along each insert's assembly path.

A companion article separates reusable engine tools from a model catalog containing sources, measurements, outputs, and verification evidence. Both repositories were created and maintained through Copilot app sessions, while the author supplied requirements and corrections and reviewed generated results and physical prints. Instruction files, skills, scripts, tests, and documentation preserve decisions between sessions.

The author also reports a matched-input case in which Claude Code declined a copyrighted-character reconstruction while Copilot proceeded, explicitly not a general benchmark. A separate microphone-stand demonstration shows a narrower use: adding GitHub platform icons across a DJI stand's handle to change its texture and appearance rather than its underlying function.

CLI hooks turn a lamp into a task indicator

Copilot CLI lifecycle hooks update an Octolamp through the WLED API, using breathing green for work, white for idle, and blinking red for errors. Gandica's demonstration covers hook configuration, network fallbacks, and race conditions when multiple lifecycle events control the same device.

A custom MCP server connects a desktop companion to hardware

Yunika Liu built Coco, a pixel-art golden retriever displayed in a desktop window and on an LED display, in one week using Copilot and MCP support. The custom server handles WebSocket synchronization, animation triggers, music composition, and connections between AI coding agents and custom hardware.

Badge instructions support a gaming prototype

The GitHub Universe badge uses graphics as capacitive touch controls, and its official repository includes Copilot instructions for MicroPython and serial connections. Woodward describes generating, testing, and deploying a badge application from a single prompt in the Copilot app.

Other GitHub Copilot News

GitHub's October availability report records an October 28 incident in which an invalid upstream-provider credential caused about one in ten requests to affected Copilot models to fail. The broader infrastructure report says that, as of November 9, 140 of 151 production services and 32 of 50 MySQL primaries were running in Azure Central US.

A public-preview Foundry experiment replaces four hosted Microsoft Agent Framework wrappers with one Foundry-managed Copilot harness agent, using the signed-in user's context for Fabric and a project managed identity for Foundry IQ. Early tests returned correct sales figures without the requested explanatory document, and clarified instructions produced one successful retrieval from both sources, but the demonstration does not establish production readiness, feature parity, or better quality, latency, or cost.

The Microsoft C++ Language Server now bundles an MSBuild compile commands extractor and invokes it automatically when a project opens, removing a separate configuration skill step and reducing setup token use. CMake and custom build systems still need a supplied compile_commands.json or a configuration skill, and installation requires accepting the EULA and holding an active Copilot subscription.

The Microsoft SQL roundup includes generally available Copilot Agent Mode in SQL Server Management Studio (SSMS) 22.10.2. That release also includes the Database DevOps workload, Schema Compare, and SQL Formatter.

An October releases recap explains Copilot Automations for self-learning issue triage, Copilot Projects for multi-repository work without local cloning, and Copilot Fusion for routing tasks across frontier models. It also discusses routine pipeline automation and software factories, serving as a retrospective rather than a new release announcement.

Also relevant this week

Dates to know

Deadlines