GitHub Changelog

We have deprecated GPT-4.1 across all GitHub Copilot experiences (including Copilot Chat, inline edits, ask and agent modes, and code completions), June 1, 2026.

Model

Deprecation date

Suggested alternative

GPT-4.1

2026-06-01

GPT-5.5

Please update your workflows and integrations to use supported model. Copilot Enterprise administrators may need to enable access to the alternative model through their model policies in Copilot settings. As an administrator, you can verify availability by checking your individual Copilot settings and confirming that the policy is enabled for the specific model. Once enabled, you’ll see the model in the Copilot Chat model selector in VS Code and on github.com. No action is required to remove the deprecated model.

GitHub Enterprise customers with questions or concerns are encouraged to reach out to their account manager for further assistance.

Share your feedback

To learn more about the models available in Copilot, see our documentation on models and get started with Copilot today.

Join the GitHub Community to share your feedback.

The post GPT-4.1 deprecated appeared first on The GitHub Blog.

The GitHub Copilot app technical preview is now available to all existing Copilot Pro, Pro+, Business, and Enterprise customers. Download the Copilot app for Windows, macOS, or Linux to get started.

Copilot Free users and customers not yet on Copilot can join the waitlist to be notified when broader access becomes available. Existing Pro+ customers can upgrade to the new Copilot Max plan for greater included usage.

This release is also where the app’s center of gravity shifts. As agents do more per session, the work that falls to you changes into managing their output: reading chat transcripts, hunting for the diff that matters, and repeating yourself to course-correct. The headline addition in this release, canvases, is our answer to that shift. Canvases give agent work a place to take shape, become visible, and get verified. All this happens alongside the chat where you steer it.

A quick recap

The Copilot app is the desktop home for agent-native software development on GitHub. In one app you can:

• Start a session from an issue, pull request, prompt, or prior session, across all your connected repositories from a single My work view.
• Run parallel agent sessions, each on its own git worktree and branch, with isolated files, conversation, and task state.
• Start from any local folder, not just a git repository, and use it as context for new agent sessions, prototypes, explorations, or workflows.
• Review the plan and diff, then validate behavior in an integrated terminal and browser.
• Open a pull request that uses your team’s existing reviews, checks, and merge requirements, and let Agent Merge address review comments, fix failing checks, and merge when your conditions are met.
• Choose the model behind each session, connect external tools via MCP servers, and package recurring work as reusable skills and scheduled automations.

What’s new in this release

🎨 Canvases

Canvases are bidirectional work surfaces for humans and agents. The agent updates the canvas as it works, and you can edit, reorder, approve, or redirect work directly on that same surface.

This is the beginning of agent experience (AX) in the Copilot app: interfaces designed not only for people to use, but for people and agents to operate together. The agent session remains where you instruct, discuss, and reason through ambiguity. Canvases are where that intent becomes visible work you can inspect, steer, and verify.

A canvas is a structured, interactive surface over a work object. That work object might be a plan, pull request, browser session, terminal, release checklist, migration board, incident, spreadsheet, dashboard, cloud console, or workflow state. The canvas does not replace the conversation. It gives the conversation somewhere to land.

Three participants share a canvas:

• Users inspect state, steer direction, make edits, and verify progress.
• Agents read canvas state, take structured actions, update the surface, and use it as evidence of completion.
• The app connects the canvas to the underlying artifact or runtime and enforces what actions are allowed.

That loop makes agentic work more grounded, more steerable, more inspectable, and more continuous. Progress is no longer buried in a transcript. It is visible as changes to the work object itself.

More in this release

• Voice conversations: Talk to Copilot using on-device speech-to-text, so no audio leaves your machine. This is the same approach we shipped in Copilot CLI.
• Cloud sessions: Run an agent session in the cloud directly from the app, the same capability behind copilot --cloud, now in the app UI.
• Cloud automations: Schedule an automation to run in the cloud, so recurring work doesn’t depend on your machine being awake.
• Copilot CLI sessions in the app: Sessions started in Copilot CLI now appear in your My work view, so both surfaces share one source of truth.
• Agentic browsing: The agent can now drive the integrated browser (e.g., click, type, take screenshots) to verify its own UI changes end to end.
• Rubber duck: A built-in skill that talks through a problem with you before you commit to an approach. Useful for the moments when the issue is your thinking, not your code.
• /chronicle: Query data from any of your Copilot agent sessions, including ones you started outside the app. Useful when you need something from a session that isn’t in front of you.

Get started today

Download the Copilot app to start your first agent session.

Read the docs to get started quickly.

Join the discussion within GitHub Community.

The post Expanded technical preview availability for the GitHub Copilot app appeared first on The GitHub Blog.

The GitHub Copilot SDK is now generally available. You can embed GitHub Copilot’s agentic engine into your own applications, services, and developer tools with a stable API and production-ready support.

The Copilot SDK gives you direct, programmatic access to the same agent runtime behind GitHub Copilot—planning, tool invocation, file edits, streaming, and multi-turn sessions, so you don’t have to build your own orchestration layer.

Since entering public preview, the SDK has been used to build everything from CI/CD assistants and internal developer tools to customer-facing AI features.

Available in six languages

• Node.js / TypeScript: npm install @github/copilot-sdk
• Python: pip install github-copilot-sdk
• Go: go get github.com/github/copilot-sdk/go
• .NET: dotnet add package GitHub.Copilot.SDK
• Rust: cargo add github-copilot-sdk — new at General Availability
• Java: Available via Maven and Gradle. — new at General Availability

Key capabilities

• Custom tools and MCP: Register tools the agent can invoke autonomously, connect to Model Context Protocol (MCP) servers, or override built-in tools like grep and edit_file.
• Fine-grained system prompt customization: Edit individual sections of the Copilot system prompt (e.g., identity, tone, tool instructions, and safety rules) without rewriting it from scratch.
• OpenTelemetry tracing: W3C trace context propagation across CLI startup, JSON-RPC calls, session operations, and tool execution.
• Flexible authentication: GitHub OAuth, GitHub Apps, environment tokens, and BYOK for OpenAI, Microsoft Foundry, Anthropic, and other providers.
• Cloud and remote sessions: Create cloud-backed sessions with repository metadata or enable remote session URLs on demand.
• Hook system: Intercept agent behavior at pre/post tool use, session start, MCP tool calls, and permission requests.

What’s new since public preview

• A new Rust SDK that bundles the Copilot CLI binary by default.
• The SDK now offers better support for multi-client workflows, so different clients can contribute tools and permissions to the same session.
• Slash commands and interactive input prompts are now available across all SDKs.
• The API surface is now stable and production-ready after coordinated cleanup based on preview feedback.
• Improved diagnostics for debugging slow or failing connections.

Pricing and availability

The GitHub Copilot SDK is available to all existing GitHub Copilot subscribers, including Copilot Free for personal use, and to non-Copilot users via BYOK.

Get started

• Read the Getting Started Guide to build your first Copilot-powered app.
• Browse the cookbook for practical recipes across all languages.
• Explore the documentation for setup, authentication, and feature walkthroughs.

The post Copilot SDK is now generally available appeared first on The GitHub Blog.

GitHub Copilot CLI is getting a major refresh at Microsoft Build 2026. Rubber duck, prompt scheduling, and voice input are generally available today, and a new experimental terminal interface—including tabs for working with issues, pull requests, and gists—is available to try via /experimental.

A new terminal experience (experimental)

We’re previewing a redesigned terminal interface for Copilot CLI. You get a cleaner layout, theme-aware semantic colors, and responsive components that adapt to narrow terminals without truncating the things you need to read.

The biggest visible change is the introduction of tabs. When you use the CLI in a GitHub repository, you can press Tab to switch between the default Session view, tabs for the repository’s Issues and Pull requests, and a tab for your personal Gists. This lets you view issues, pull requests, and gists without leaving Copilot CLI.

The redesign also makes Copilot CLI more accessible:

• Pick from new color modes (e.g., default, github, dim, high-contrast, and colorblind) to match your terminal and your eyes.
• Screen reader support is on by default when a screen reader is detected, with labeled icons and animations that automatically disable.
• Dialogs, tables, lists, and headings render consistently across every screen in the CLI.

The new terminal experience is available in /experimental mode. Run /experimental on to opt in. The new experience is still evolving, and we’d love your feedback as we move toward general availability.

Get a second opinion with rubber duck

Rubber duck is a built-in CLI agent that acts as a constructive critic. While working on a task, the main CLI agent for a session can pass its current plan, design, implementation, or tests over to the rubber duck agent for review. The rubber duck agent looks for blind spots, design flaws, and substantive issues, and reports back with concrete, actionable feedback. Copilot then takes that critique into account before continuing.

For some tasks, two heads are better than one, and the CLI decides when getting a second opinion may be beneficial.

Read more about rubber duck.

Schedule prompts with /every and /after

The new /every and /after slash commands let you schedule a prompt or skill within the current CLI session.

Use /every to schedule a prompt to run repeatedly at the specified interval:

• /every 30m run the frontend tests
• /every 1h how many tokens have I used during the past hour

Use /after to schedule a prompt to run just once, after the specified interval:

• /after 2h /example-skills:docx create a new file summarizing recent changes to this repo

Run /every or /after with no arguments to open the schedule manager, where you can see active schedules and delete any you no longer want to run.

Talk to Copilot

Video

Copilot CLI now includes hands-free dictation. Hold the space bar on your keyboard and talk to input a prompt. Alternatively, press Ctrl+X followed by V to start recording, speak your prompt, then press any key to stop recording and insert the transcription.

Voice input runs locally, so all audio you record stays on your machine. The first time you enable voice input, the CLI guides you through downloading the runtime and picking a speech-to-text model.

Update and share feedback

Update GitHub Copilot CLI by running copilot update in your terminal. We’d love to hear what you think—share feedback with the /feedback command in a CLI session or open an issue in our public repository.

The post Copilot CLI: Improved UI, rubber duck, prompt scheduling, and voice input appeared first on The GitHub Blog.

GitHub Copilot can now run inside secure, isolated sandboxes, both locally on your machine and in the cloud. Sandboxed Copilot experiences provide isolated environments for Copilot’s tool execution locally as well as fully isolated cloud sandboxes hosted by GitHub.

This gives Copilot a safe place to interact with your code, tools, filesystem, and network, all within the policies you define, so developers and enterprises can adopt agentic workflows without giving up isolation or control.

Why it matters for agentic development

Copilot is evolving from an in-editor assistant into an agentic coding partner that runs tools, executes commands, and modifies files on a developer’s behalf. As Copilot takes more actions, developers and enterprises need stronger guarantees around security, isolation, and control.

Agentic development is interactive, stateful, and parallel, and it needs an execution layer built for that reality. Cloud and local sandboxes for GitHub Copilot provide that layer natively, with consistent identity, governance, and policy controls built in. As AI agents become a larger part of the software development lifecycle, secure execution environments become foundational infrastructure, and sandboxes provide that layer for Copilot.

Local sandboxes for GitHub Copilot

Inside any Copilot session, enable sandboxing with /sandbox enable. Shell command execution initiated by Copilot for that session runs with restricted access to your filesystem, network, and system capabilities, so you can experiment with agentic workflows while staying in control of what Copilot can touch on your machine. Local sandboxing is built on Microsoft MXC technology for a consistent isolation experience across macOS, Linux, and Windows. Enterprise teams can also centrally configure and enforce local sandbox policies through Microsoft Intune and other MDM platforms. Local sandboxes are included in the standard GitHub Copilot seat.

This release focuses on isolating shell command execution initiated by Copilot, laying the foundation for broader CLI-level isolation as agentic workflows mature.

Key use cases developers and teams can unlock

• Safely run agent-generated code on your machine through isolated tool execution, without giving Copilot unrestricted access to the filesystem, network, or system.
• Standardize isolation across macOS, Linux, and Windows with a consistent sandboxing experience built on Microsoft MXC.
• Apply enterprise policy to local Copilot execution by centrally configuring and enforcing sandbox policies through Microsoft Intune and other MDM platforms.

Cloud sandboxes for GitHub Copilot

Launch a fully isolated, ephemeral Linux sandbox hosted by GitHub directly from Copilot with copilot --cloud. Each session inherits your existing Copilot cloud agent policies, so the security controls your org already trusts apply on day one with no additional setup.

Key use cases developers and teams can unlock

• Run Copilot tasks in fully isolated cloud environments for stronger security boundaries around agent execution.
• Continue Copilot sessions across devices, picking up where they left off regardless of where a session was started.
• Offload compute-intensive workflows and run multiple Copilot tasks in parallel without consuming local resources.

Get started

To get started, read the docs for sandboxes for GitHub Copilot in local environments and cloud environments, see pricing for sandboxes for GitHub Copilot in cloud environments, or join the discussion in the GitHub Community. Learn more at our Microsoft Build demo session.

The post Cloud and local sandboxes for GitHub Copilot now in public preview appeared first on The GitHub Blog.

Copilot code review adapts to your team’s tools and standards and scales its depth to the complexity of each change. Today we’re shipping two public previews:

• Agent skills and MCP support that bring your organization’s context into every review
• A new medium analysis tier that routes complex pull requests to a higher-reasoning model

Bring your tools and standards into every review with skills and MCP

A lot of what reviewers need to know lives in other tools, not in the diff itself. Agent skills and MCP bring that context into Copilot’s reviews, ensuring that reviews don’t stall on questions already answered elsewhere. This means senior engineers stop being the bottleneck for consistency across repositories.

• Custom agent skills invoke your team’s internal tools and standards during a review, extending Copilot beyond its built-in analysis.
• MCP server connections, once configured, pull context directly into the review from the third-party platforms and internal systems your team already uses, including issue tracking, documentation, service catalogs, and incident tooling.
• Configurable Actions workflows give you control over the compute and environment Copilot uses for review.
• Shared configuration across review and cloud agent means platform teams invest once and get consistent behavior across both agents.

Match review depth to complexity with the new medium analysis tier

Review depth should scale with the complexity of the change. The new Medium tier routes pull requests to a higher-reasoning model purpose-built for deeper analysis of complex logic, security-sensitive code, and cross-service changes. Low remains a fast, cost-efficient default for straightforward work like docs and small repositories. This enables you to invest compute where it matters most and conserve it everywhere else.

• Admins set Low or Medium per repository to align review intensity with code complexity and business value.
• Medium delivers more actionable comments with fewer false positives and catches subtle bugs lighter reviews miss.
• Medium consumes more AI Credits than Low, with clear cost signals so admins can manage spend under usage-based billing.

Getting started

These features are available in public preview for existing Copilot Pro, Pro+, Business, and Enterprise users. Copilot code review can also be enabled for non-Copilot users via Direct Org Billing.

Setting up MCP servers for Copilot code review

1. Add your desired JSON MCP configuration under repository settings → Copilot → MCP servers.
2. Store your token required for MCP authentication under repository settings → Secrets and variables → Agents.

Note: Any existing MCP configurations for Copilot cloud agent will now apply to Copilot code review automatically.

Read the docs to find examples of common MCP configurations you can get started with.

Setting up agent skills for Copilot code review

1. If one does not exist within your repository, create a .github/skills directory.
2. Under .github/skills, create a code-review or similarly named directory to ensure that Copilot code review will read and utilize the skill.
3. Create a SKILL.md file containing the relevant context and instructions you want Copilot code review to utilize.

Note: Existing agent skills within the .github/skills directory will automatically be available to use by Copilot code review if relevant to the review.

For more information, read our docs on agent skills.

View and change your review tier

1. Navigate to repository settings → Copilot → Code review → Review effort level.
2. Select your desired review depth in the dropdown.

For more details, read our docs on medium tier reviews.

Join the discussion within GitHub Community.

The post Shape Copilot code review around your team appeared first on The GitHub Blog.

GitHub Copilot code review for Azure Repos is now available in technical preview, bringing on demand pull request reviews directly into your Azure DevOps workflow.

How it works

Once enabled at both the organization and repository level, users can request a Copilot code review directly from a pull request in Azure Repos. Copilot adds review comments inline with the code changes, suggests improvements when appropriate, and helps identify potential issues earlier in the development process—all without leaving Azure DevOps.

Who can use this feature

Copilot code review for Azure Repos is available to all Azure DevOps customers who sign up for the technical preview. No GitHub Copilot license is required to use the feature.

Billing

• Usage bills as GitHub AI credits
• Usage doesn’t draw down included AI credits from existing GitHub Copilot plans
• Billing starts on June 2, 2026
• This is preview billing and pricing may change at general availability

Key benefits

• Catch issues earlier with on demand pull request reviews inside Azure Repos
• Keep your team in their existing Azure DevOps workflow
• Get started without provisioning GitHub Copilot licenses for your developers
• Pay only for what you use through GitHub AI credits

Learn more about Copilot code reviews.

The post GitHub Copilot code review for Azure Repos is now in technical preview appeared first on The GitHub Blog.

Agent apps are AI agents from GitHub partners, installable from the GitHub Marketplace, and integrated directly into GitHub.

You install an agent app just like any other GitHub App from the Marketplace. Once it’s installed and enabled by an administrator, the agent becomes available inside your GitHub workflows, with three entry points:

• Assign an issue to the agent
• @mention the agent in a pull request comment
• Select the agent in the Agents UI and give it a prompt

The first wave of agent apps is available today from:

• Amplitude
• Bright Security
• Endor Labs
• LaunchDarkly
• Miro
• Sonar
• PagerDuty
• Packfiles
• Octopus Deploy

Over the coming months, we’ll open up access to allow anyone to build agent apps, whether you’re a developer tools provider or just building an internal tool for your team.

If you’re a partner interested in building your own agent app, you can join the waitlist to get access.

To learn more, see “About agent apps” in the GitHub Docs.

Join the discussion within GitHub Community.

The post Extend GitHub with agent apps appeared first on The GitHub Blog.

With Copilot CLI now available in GitHub Copilot for JetBrains IDEs, this update centers on new capabilities for Copilot CLI sessions, while also delivering a broader set of agentic improvements. For Copilot CLI sessions, that includes agent picker support, new slash commands, and the agent debug panel in public preview, along with the beginning of a phased transition to Copilot CLI agent as the default experience.

In parallel, this release also integrates Coding Agent into the unified sessions view, adds configurable thinking effort for supported models, introduces the agent customizations editor, adds Google and Apple sign-in options, and includes additional user experience and reliability improvements.

New features

Agent picker support for Copilot CLI sessions

Copilot CLI agent now includes an agent picker that lets you flexibly choose between different operating modes to suit your workflow:

• Agent mode (default): Full agentic experience with autonomous task execution.
• Ask mode: Get quick answers and assistance.
• Custom agents: Use personalized agents tailored to your specific needs.
• Plan mode: Collaborate on planning before implementation, where Copilot analyzes your request and builds a structured implementation plan for your review.

New slash commands for Copilot CLI sessions

/remote

The /remote command lets you remotely control a Copilot CLI session from github.com or the GitHub Mobile app. With remote control, you can monitor and steer your ongoing Copilot CLI sessions from anywhere, giving you more flexibility to keep work moving without being tied to your machine.

Enable it from Settings > Tools > GitHub Copilot > Chat > Enable Copilot CLI Remote.

/compact

The /compact command lets you manually compress the Copilot CLI session context at any time, keeping long-running sessions more manageable.

/chronicle

The /chronicle command lets you review and analyze session history and provide personalized tips and improvements, helping you use Copilot more effectively.

You can enter the following commands in an interactive Copilot CLI session:

• /chronicle standup: Generates a short report summarizing what you worked on in your recent CLI sessions.
• /chronicle tips: Provides personalized tips for using Copilot CLI more effectively.
• /chronicle improve: Analyzes your session history to identify patterns where Copilot may have misunderstood your intent or where there was a lot of back-and-forth. It uses this analysis to generate custom instructions to help Copilot better understand you in the future.
• /chronicle search: Search sessions for ones that match your query.

Agent debug panel in public preview

The Agent Debug Log panel shows a chronological event log of agent interactions during a Copilot CLI session, making it especially useful when debugging custom agents and orchestrated sub-agent workflows.

To use it, first select Copilot CLI from the agent picker in the Copilot Chat panel, then click the settings icon in the top-right and select Agent Debug Panel. For full support across current and historical sessions, also enable Settings > Tools > GitHub Copilot > Chat > Enable Agent debug File Logging.

If you are a Copilot Business or Copilot Enterprise subscriber, an administrator will have to enable the Editor preview features policy before you can use this feature.

Cloud agent integrated into the unified sessions view

Cloud agent sessions are now surfaced directly in the unified sessions view in the chat panel. This makes it easier to manage and monitor all your agent sessions from one place, whether they’re local, CLI, or cloud. You can filter by agent type or status to find the session you’re looking for.

To use cloud agent, enable it from Settings > Tools > GitHub Copilot > Chat > Enable Coding Agent.

If you are a Copilot Business or Copilot Enterprise subscriber, an administrator will have to enable the Editor preview features policy before you can use this feature.

Configure thinking effort for supported models

For reasoning models that support configurable thinking effort, you can now control how much reasoning the model applies to each request, directly from the model picker. Use a higher effort level for complex tasks like architectural decisions or multi-step debugging, and a lower level for straightforward code generation or simple questions.

To configure thinking effort, open the model picker in the chat input field, select a reasoning model, and then select an effort level from the “Thinking Effort” submenu. Nonreasoning models, such as GPT-4o, will not show the thinking effort submenu.

Agent customizations editor

The Agent Customizations editor provides a centralized UI for creating and managing all your agent customizations in one place. You can configure workspace customizations for the entire team, or create personal ones that follow you across projects.

This includes viewing and editing existing custom agents, reusable skills, instructions, and prompts. To open the Agent Customizations editor, open the Copilot Chat panel and click the settings in the top-right, then select Customizations.

More sign-in choices with Google and Apple

You can now sign in to GitHub Copilot in JetBrains IDEs using Continue with Google and Continue with Apple in addition to existing sign-in options. This gives you more flexibility to authenticate with the account they already use, while keeping existing GitHub and enterprise sign-in flows available.

User experience and reliability improvements

We’ve also made several refinements to improve day-to-day workflows, stability, and responsiveness across JetBrains IDEs:

• Smooth NES experience with better trigger strategy and detection logic.
• Improved the unified session persistence and state management.
• Improved overall UI freeze handling and stability.

Availability updates

The following capabilities are now either generally available or available without the Editor Preview feature flag:

• Agent skills are generally available
• Agent hooks are generally available
• Prompt files are generally available
• Anthropic Thinking is generally available
• BYOK is available without the Editor Preview feature flag, and availability for Copilot Business and Enterprise is controlled by GitHub policy

Copilot CLI agent as default

We’re rolling out a phased transition to make Copilot CLI agent (currently in public preview) the default. It offers a more powerful and consistent agentic experience, with support for multiple isolation modes, live session progress, and tool call visibility.

To select Copilot CLI agent, open the agent picker in chat and choose Copilot CLI. Copilot Business and Enterprise subscribers will need their administrator to enable the editor preview features policy first.

Try it out

We encourage you to try out the latest version of the GitHub Copilot plugin and share your feedback. Your input is invaluable in helping us refine and improve the product.

Share your feedback

Your feedback drives improvements. We’d love to hear about your experience in the following channels:

• In-product feedback: Use the feedback options within your IDE.
• Community feedback: Share your thoughts in the GitHub Copilot for JetBrains IDEs issues, or take our short survey.

The post Introducing Copilot CLI and agentic capabilities enhancements in JetBrains IDEs appeared first on The GitHub Blog.

Two Gemini models are now available across additional GitHub Copilot surfaces. Gemini 3.1 Pro (Preview) and Gemini 3.5 Flash can now be used in:

• Copilot CLI
• Copilot cloud agent
• GitHub Copilot app (technical preview)
• Copilot SDK

Gemini 3.1 Pro (Preview) is available for Copilot Student, Copilot Pro, Copilot Pro+, Copilot Business, and Copilot Enterprise subscribers.

Gemini 3.5 Flash is available for Copilot Pro, Copilot Pro+, Copilot Business, and Copilot Enterprise subscribers.

Enabling access

Copilot Business and Enterprise administrators must opt in by enabling the relevant Gemini model policy in Copilot settings. Once enabled, users in that organization will see the models available across Copilot surfaces.

To learn more about the models available in Copilot, see our documentation on Gemini models in Copilot and choosing the right AI model for your task.

The post Gemini models in Copilot CLI, cloud agent, and the Copilot app appeared first on The GitHub Blog.

This release of GitHub Copilot in Eclipse packs a lot: a refreshed chat experience, deeper visibility into your session context, BYOK for Business and Enterprise, better ABAP support, and brand new support for skills and prompt files. Read on for the highlights.

✨ What’s new

Refreshed chat view with a new combo picker

We’ve refreshed the chat view with a brand new combo picker for selecting chat modes and models, surfacing more information for each model right where you make the choice.

Session context window usage at a glance

Ever wonder how much of the conversation’s context window has been consumed? The chat view now shows a context size donut indicator alongside the input area, with a popup that breaks down token usage for the current session.

Custom models (BYOK) for Copilot Business and Enterprise

Bring Your Own Key (BYOK) is now available to individual users as well as GitHub Copilot Business and Enterprise users when enabled by their organization. Once your organization turns it on, you can configure your own API keys for supported providers and use the custom models directly in Copilot chat in Eclipse.

Note: If you don’t see custom models enabled, reach out to your organization’s administrator to turn the feature on.

Better ABAP support

This release brings improved support for ABAP development in Eclipse. Copilot now provides more accurate and context-aware chat responses for ABAP projects. It can also read directories and search within the locally cached files.

Custom instructions loading preference

A new Copilot preference lets you control how a chat’s custom instructions are loaded. Tailor when and how your project-specific or personal instructions are picked up by Copilot, giving you finer control over the context that shapes each conversation.

• All projects (default): Load custom instructions from every project in your Eclipse workspace.
• Referenced projects: Only load instructions from projects whose files or folders are referenced in the current chat.

Skills and prompt files

Copilot for Eclipse now supports skills and prompt files. Define reusable prompts and skills to streamline your workflows. Invoke them on demand to apply consistent instructions and patterns across your chats.

• Persist skill files under /.github/skills/ (e.g., .github/skills/my-skill/SKILL.md).
• Persist prompt files under /.github/prompts/ (e.g., my-prompt.prompt.md).

To trigger a skill or prompt in chat, type / in the chat input box to open the slash command picker.

Thinking blocks in chat view

For models that support reasoning, the chat view now displays thinking blocks so you can follow Copilot’s reasoning process alongside its final response. Expand or collapse the blocks to dive into the details or keep the view focused on results.

Selectable thinking effort

You can now choose the thinking effort level for supported models. Dial the reasoning depth up for complex problems or keep it light for quick tasks. This gives you control over the trade-off between latency and answer quality.

🛠 Try it out

1. Prerequisites: Ensure you have an active GitHub Copilot subscription. For BYOK, your organization administrator must enable Custom Models for Copilot Business or Enterprise.
2. Update your IDE: Install or update the GitHub Copilot for Eclipse plugin from the Eclipse Marketplace (Help → Eclipse Marketplace → search for “GitHub Copilot”).
3. Open the chat view: Launch Copilot Chat and try the new combo picker to switch chat modes and models.
4. Watch your context: Keep an eye on the context size donut next to the input area, and click it to see a per-session token breakdown.
5. Configure custom instructions: In Eclipse preferences, open GitHub Copilot → Custom Instructions and pick All projects or Referenced projects to match your workflow.
6. Add a skill or prompt: Drop a file at /.github/skills//SKILL.md or /.github/prompts/.prompt.md, then type / in chat to invoke it.
7. Tune reasoning: For supported models, expand the thinking blocks to follow Copilot’s reasoning and adjust the thinking effort to match the task at hand.

💬 Share your feedback

Your feedback drives improvements. Let us know what you think using the in-product feedback option, or share your thoughts in the GitHub Copilot for Eclipse issues.

The post GitHub Copilot in Eclipse: BYOK, skills, and chat updates appeared first on The GitHub Blog.

GitHub Copilot offers access to evaluation models for individual non-enterprise users, and these models may be served in Copilot auto model selection.

To disable use of evaluation models through Copilot auto model selection, visit your GitHub Copilot settings. Learn more in our documentation about evaluation models.

The post Evaluation models in auto for individual plans appeared first on The GitHub Blog.

As announced in our recent blog post, usage-based billing for GitHub Copilot is now live for all users and Copilot code review consumes GitHub Actions minutes, in addition to GitHub AI Credits.

As part of this release, we’re also launching new user-level budget controls and enabling upgrades to Copilot Max.

Usage-based billing is active for all Copilot plans

As of June 1, all Copilot plans bill based on GitHub AI Credits consumed. Each plan comes with monthly included usage. To find more details about what’s included in each plan, please review the documentation for usage-based billing for individuals and usage-based billing for organizations and enterprises.

After you consume your included AI Credits, you can continue to spend additional AI Credits and be billed at the end of the month by setting an additional spending budget. For individual plans, we may limit your total additional AI Credits based on your usage patterns, billing history, and verification status for your user account. To continue spending AI Credits, we recommend upgrading to the next plan for more included and additional usage limits.

Configure a default Actions runner for Copilot code review

As of June 1, Copilot code review consumes Actions minutes, in addition to GitHub AI Credits. By default, Copilot code review will use a standard GitHub-hosted runner, but organization admins can now set a default runner to be used automatically across all repositories, without requiring each repository to be individually configured. To learn more, see Configure runners at the organization level.

Control spending with user-level budgets

For customers needing more granular spend controls, user-level budgets are now generally available for organizations and enterprises. Admins can now set a universal budget for users or override for specific sets of users. As users approach their budgets, admins will receive email notifications and can adjust budgets anytime from their billing settings. For AI credits, user-level budgets control total usage, not just additional spend. See our budget management documentation for more details.

Copilot Max: optimized for power users

Copilot Max is available today as an upgrade for existing Student, Pro, and Pro+ subscribers, with higher included usage and higher spending limits to support more intensive workflows. New user sign-ups will open in the coming weeks.

New sign-ups remain paused

New user sign-ups remain paused for Copilot Student, Pro, Pro+, and Max plans. We’ll reopen sign-ups in the coming weeks.

Join the discussion within GitHub Community.

The post Updates to GitHub Copilot billing and plans appeared first on The GitHub Blog.

To help you tell a deeper Copilot adoption story—not just who is active, but how they’re using Copilot—the Copilot usage metrics API now classifies each engaged user into an AI adoption phase based on their Copilot product usage over a rolling 28-day window. A new ai_adoption_phase field is available on user-level reports, and a new totals_by_ai_adoption_phase array surfaces per-phase metrics on enterprise- and organization-level reports.

What’s new

Each engaged user is assigned to one of four phases based on the Copilot surfaces they’ve used on at least two days in the last 28-day window:

• Phase 0 — No cohort: User did not meet the engagement criteria for any phase.
• Phase 1 — Code first: User engaged with code completion and/or IDE agent mode.
• Phase 2 — Agent first: User engaged with a single GitHub-based agent surface (i.e., Copilot cloud agent, Copilot code review, or Copilot CLI).
• Phase 3 — Multi-agent: User engaged with two or more GitHub-based agent surfaces, or with the new GitHub Copilot app.

Each ai_adoption_phase value includes a version field (starting at v1) so the classification logic can evolve as Copilot’s product surface grows, without breaking historical context.

On the enterprise- and organization-level reports, the new totals_by_ai_adoption_phase array groups engagement and activity metrics by phase, including:

• Total engaged users (2-day-in-28 engagement window)
• User-initiated interaction average
• Code generation and acceptance activity averages
• Lines of code added and deleted averages
• Pull requests created, merged, and reviewed averages
• Median time-to-merge average

Aggregated metrics report the average per user within each phase rather than the sum.

Why this matters

• Tell the maturity story: Move beyond simple active-user counts and show which Copilot capabilities your developers are actually adopting.
• Track cohort progression: Watch users graduate from code-first usage into agent-first and multi-agent workflows over time.
• Target enablement: Focus training, documentation, and rollout programs on the phases where you see the biggest opportunity.

Important notes

• These metrics are available to enterprise administrators and organization owners who have access to Copilot usage metrics through the REST API.
• You can use this release in combination with the teams filter ship for greater granularity.

Join the discussion within GitHub Community.

The post Copilot usage metrics API adds cohorts for AI adoption appeared first on The GitHub Blog.

Enterprise administrators and billing managers can now set hard budget limits for GitHub Advanced Security (GHAS) SKUs, preventing teams from exceeding their allocated license budgets.

Previously, license-based products like GHAS only supported soft budgets. Admins could set a spending target and receive email notifications at 75%, 90%, and 100% thresholds, but the product did not enforce the limit. This could lead to accidental overspending, especially during user onboarding flows such as IdP group provisioning where licenses are automatically assigned.

With hard budget limits, once a GHAS budget threshold is reached, additional license usage is blocked, and GHAS won’t be enabled on new repositories until the budget is increased or licenses are freed. This gives enterprises precise control over their security spending at the organization level.

What’s new

• Enforceable license limits for GHAS: Set a hard budget in license count and GitHub will prevent new license assignments once the limit is met.
• License-to-cost transparency: When configuring a budget, a real-time estimate shows the dollar equivalent (e.g., X licenses ≈ ~$Y/month), so admins always know their remaining capacity, even for mid-month additions.
• Smart defaults for existing usage: If your enterprise already has active GHAS licenses, the new budget floor will be set to at least your current billable license count to avoid disruption.
• Continued alerting: Email notifications at 75%, 90%, and 100% thresholds remain active alongside hard limits, keeping admins informed as usage approaches the cap.
• Organization-level control: Enterprises can allocate license budgets scoped to a cost center and limit spending for the organizations assigned to the cost center. Organizations on the Team plan can also allocate license budgets for the organization to limit spending.

Getting started

Hard budget limits for GHAS can be configured in your enterprise billing settings under Budgets & alerts. Both new and existing customers can create hard budgets. Existing soft budgets can be migrated to the new license-based format through in-product flows.

To learn more, see Preventing overspending in the GitHub documentation.

Join the discussion within GitHub Community.

The post Hard budget limits now available for GitHub Advanced Security appeared first on The GitHub Blog.

CodeQL is the static analysis engine behind GitHub code scanning, which finds and remediates security issues in your code. We’ve recently released CodeQL 2.25.5, which includes accuracy improvements across C/C++, Java/Kotlin, and GitHub Actions queries.

Language and framework support

Java/Kotlin

• We’ve introduced a new sink kind, path-injection[read], for Models-as-Data rows that only read from a path (such as ClassLoader.getResource, FileInputStream, and FileReader). This helps queries distinguish read-only path sinks from more dangerous ones.

GitHub Actions

• We’ve extended the poisonable_steps modeling to detect additional sinks, including scripts executed via Python modules and go run in directories.

Query changes

C/C++

• The cpp/cleartext-transmission query no longer raises an alert on calls to fscanf (and variants) when the call reads from an input that isn’t a socket, reducing false positives.

Java/Kotlin

• The java/zipslip query no longer reports archive entry names that flow only to read-only path sinks such as ClassLoader.getResource, FileInputStream, and FileReader, reducing false positives.

GitHub Actions

• The actions/unpinned-tag query now analyzes composite action metadata (action.yml and action.yaml files) in addition to workflow files, providing more comprehensive detection.
• We’ve fixed the help file descriptions for the actions/untrusted-checkout/critical, actions/untrusted-checkout/high, and actions/untrusted-checkout/medium queries.
• We’ve renamed actions/untrusted-checkout/high to more clearly describe which parts of the scenario run in a privileged context.

For a full list of changes, please refer to the complete changelog for version 2.25.5. Every new version of CodeQL is automatically deployed to users of GitHub code scanning on github.com. The new functionality in CodeQL 2.25.5 will also be included in GitHub Enterprise Server (GHES) release 3.22. If you use an older version of GHES, you can manually upgrade your CodeQL version.

The post CodeQL 2.25.5 improves query accuracy for GitHub Actions appeared first on The GitHub Blog.

Claude Opus 4.8, Anthropic’s latest Opus model, is now available in GitHub Copilot. In our early testing, Opus 4.8 demonstrates a clear step forward in code understanding and generation across a range of real-world coding tasks. It also handles complex problem-solving and large-codebase navigation with notable improvement to previous versions.

This model is launching with a 15X premium request multiplier until Usage Based Billing launches on June 1, 2026.

Video

Availability in GitHub Copilot

Claude Opus 4.8 will be available to Copilot Pro+, Business, and Enterprise users.

You’ll be able to select the model in the model picker in:

• Visual Studio Code in all modes (i.e., chat, ask, edit, and agent)
• Visual Studio
• Copilot CLI
• GitHub Copilot cloud agent
• GitHub Copilot App
• github.com
• GitHub Mobile iOS and Android
• JetBrains
• Xcode
• Eclipse

Rollout will be gradual. Check back soon if you don’t see it yet.

Enabling access

Copilot Enterprise and Copilot Business plan administrators must enable the Claude Opus 4.8 policy in Copilot settings.

Learn more

To explore all models available in GitHub Copilot, see our documentation on models and get started with Copilot.

Share your feedback

Join the GitHub Community to share your feedback.

The post Claude Opus 4.8 is generally available for GitHub Copilot appeared first on The GitHub Blog.

Copilot Memory now includes improved memory deletion, adds a repository-level off switch, and brings further memory controls into the Copilot CLI. Copilot Memory is in public preview and available to all paid Copilot plans.

What’s changing

• Deletion guidance: When you ask Copilot to forget something, it now points you to the right place to remove the memory and down-votes the memory where voting is available.
• Repository-level off switch: Repository admins can now disable Copilot Memory for a repository from the existing Copilot feature controls in repository settings. Repository-level facts will no longer be stored or read. Preexisting facts are not deleted. User-level preferences are unaffected.
• /memory command in the Copilot CLI: Use /memory on to enable Copilot Memory, /memory off to disable it, and /memory show to check its current status. Your choice persists across sessions.
• Clearer scope at capture time: The store_memory permission prompt now explicitly states whether the entry will be a user-level preference (i.e., visible only to you, used in your sessions across repositories) or a repository-level fact (i.e., visible to all contributors on the repository).

Managing memories

• Your user-level preferences: Review or delete them in your personal Copilot Memory settings.
• Your repository’s facts: Repository owners can review, delete, or turn off Copilot Memory for the repository under Repository Settings > Copilot > Memory.

Learn more about managing stored memories.

Share your feedback

For more information, see About GitHub Copilot Memory.

We’re continuing to evolve Copilot Memory and plan to bring it to more features in the future. To share feedback or join the discussion, visit the GitHub Community.

The post Copilot Memory has more controls for deletion, scope, and the Copilot CLI appeared first on The GitHub Blog.

You can now programmatically enable and configure GitHub Code Quality on individual repositories using the new Repository Enablement API, available today in public preview.

Two new endpoints are now available:

• PATCH /repos/{owner}/{repo}/code-quality/setup: Enable or disable Code Quality default setup for a repository, configure the languages to analyze, and specify the runner type.
• GET /repos/{owner}/{repo}/code-quality/setup: Retrieve the current Code Quality configuration for a repository, including state, languages, runner type, and analysis schedule.

Supported languages include csharp, go, java-kotlin, javascript-typescript, python, and ruby.

This feature is available in public preview on github.com and is not available on Enterprise Server.

To learn more about GitHub Code Quality, check out the documentation for code quality.

The post GitHub Code Quality: Repository Enablement API appeared first on The GitHub Blog.

Enterprise owners now have granular control over which GitHub Copilot models are available to each organization. With targeted model rules, you can allow specific models for specific organizations instead of relying on a single enterprise-wide setting. This capability is now in public preview.

We’ve also refreshed the experience for managing default model availability across your enterprise, making it easier to see and configure which models are available to your organizations.

What’s new

Targeted model rules let you create rules that allow specific Copilot models for selected organizations, giving you fine-grained control beyond enterprise-wide defaults.

What’s improved

The default model availability experience has a refreshed interface. From a single page, you can:

• Choose which default Copilot models are available to organizations in your enterprise.
• Set each model’s availability to Enabled (automatically on for all organizations) or Optional (organizations decide whether to enable it).

Who can use this

Customers on Copilot Business and Copilot Enterprise plans can use targeted model rules.

To get started, see Managing availability of default models and Managing default models for your organization.

Join the discussion in GitHub Community.

The post Target Copilot models to organizations with model rules appeared first on The GitHub Blog.