GitHub Release Notes

VS Code continues with weekly stable releases. This changelog covers releases v1.120 through v1.123, the releases we shipped throughout May and early June 2026.

In May, we made the Agents window available in VS Code Stable as a preview, giving users an agent-first experience focused on completing tasks rather than editing code. We also improved support for remotely controlling longer-running, more complex agent sessions.

VS Code supports bring-your-own-key (BYOK) models, letting you use your own language model API keys. This month, we expanded BYOK to air-gapped environments and added controls to specify which models handle utility tasks like commit message generation.

Agents window

• Agents window in Stable (preview): Work agent-first across multiple projects with a dedicated surface for faster navigation and change review.
• Remote agents (preview): Run sessions on remote machines over SSH or Dev Tunnels, with sessions continuing even when the client disconnects.
• Agent Host Protocol (AHP): Continued investment in an open protocol for synchronizing agent session state across multiple clients.
• Session preferences persist in new sessions: New sessions keep your recent choices, including agent harness and isolation mode.
• Sessions and Git flow improvements: New sessions can pull base branch updates before the agent starts edits, the Agents window refreshes Git state automatically after commits, syncs, and related operations, and agents can trigger tasks on remote machines.
• Session sync: Chat sessions now sync automatically to your GitHub account, giving you a searchable history of your work across machines and workspaces.
• Chronicle: Use /chronicle commands to query past sessions, generate standup reports, and get personalized productivity tips.
• Multiple sessions side-by-side: Open more than one agent session at the same time in the Agents window. Drag, Alt-click, or use Open to the Side to compare or review work in parallel.
• Retry network-dependent commands in sandbox: Terminal commands that require network access are automatically retried with broader network permissions, while keeping filesystem protections in place.

Language models and BYOK

• Air-gapped BYOK: Bring-your-own-key models can run in isolated environments without GitHub authentication.
• Custom Endpoint provider: Add endpoints compatible with chat completions, responses, or messages from one provider flow.
• Model picker by provider: Find and switch models more easily in multi-provider environments.
• BYOK token visibility: The context window now reports real token usage for bring-your-own-key models.
• Reasoning effort controls: Configure thinking effort directly from the model picker to balance quality, latency, and cost.
• Configurable utility models: Choose which models handle titles, summaries, rename suggestions, commit messages, and intent detection.

Terminal safety and efficiency

• Expanded terminal output compression: More verbose output patterns from tests, builds, linters, Docker, and package managers are compressed before reaching the model to optimize token usage and help reduce costs.
• Command risk assessment (experimental): Terminal confirmations include AI-generated risk levels and short safety explanations.
• Sensitive prompts stay in terminal: Passwords, passphrases, PINs, and verification codes are entered directly in the terminal and are not shared with the LLM.
• Better background command UX: There are now clearer running-state indicators in chat, plus automatic cleanup of completed background agent terminals to help save resources on your machine and keep things more manageable.
• Agent-aware terminal commands: The VSCODE_AGENT environment variable lets CLIs adapt behavior for agent-initiated commands.

Also new

• Integrated browser: Adds device emulation to test your website’s responsiveness. New screenshot options let you capture the viewport, a selected area, or the full page and attach any of them as chat context to help reproduce and explain UI issues. You can also save favorite pages for quick access alongside open tabs.
• HTML file preview: Preview local HTML files directly in the integrated browser without installing an extension. Right-click a file in the Explorer or editor tab and select Open in Integrated Browser.
• Search only in changed files: There’s a new search panel toggle that can scope results to locally modified, uncommitted files.
• Markdown preview improvements: Mermaid diagram rendering and YAML front matter display are now built in, without requiring separate extensions. You can also view Markdown diffs as rendered preview instead of raw source when opening files from Source Control.
• Quick suggestions default tuning: Experience reduced noise when inline completions are available.
• Issue reporter wizard: New issue filing flow with support for screenshots and video recordings.
• Accessibility and UX updates: Ongoing improvements across editor surfaces.

Happy coding!

Join the discussion within GitHub Community.

The post GitHub Copilot in Visual Studio Code, May releases appeared first on The GitHub Blog.

Original source

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.

Original source

The GitHub Copilot SDK is now generally available

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.

Original source

A new terminal experience (experimental)

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.

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.

You can also invoke rubber duck with /rubber-duck. 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

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.

Original source

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.

Original source

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.

Original source

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

Add your desired JSON MCP configuration under repository settings → Copilot → MCP servers.

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

If one does not exist within your repository, create a .github/skills directory.

Under .github/skills, create a code-review or similarly named directory to ensure that Copilot code review will read and utilize the skill.

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

Navigate to repository settings → Copilot → Code review → Review effort level.

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.

Original source

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.

Original source

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.

Original source

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.

Original source

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.

Original source

2026-06-01

• Actionable error message shown when GitHub API rate limit is hit during copilot update
• Plugin slash commands (/plugin install, uninstall, update, marketplace add/remove/browse) now show immediate feedback while the operation is in progress
• Canceling a running shell command (Ctrl+C on a !command, or aborting an agent command — including in sandboxed and background-promoted shells) now terminates the whole process tree instead of leaving orphaned processes running
• Canvas providers can return file:// URLs in open results for local file previews
• Symlinked directories appear in /cwd completion suggestions
• In Azure DevOps-only repositories, the built-in GitHub MCP server now exposes only the web_search tool instead of being fully disabled
• Quota footer shows remaining requests as a rounded percentage
• /lsp show, /lsp test, and /lsp reload correctly discover project LSP config when the CLI is launched from a subdirectory
• MCP server timeout configuration is preserved after tools list changes
• /skills add and /skills remove correctly handle paths wrapped in quotes (e.g., from Windows Explorer "Copy as path")
• Running copilot with an unquoted multi-word prompt now shows a helpful "quote your prompt" hint instead of a raw commander error
• Default networking transport is now HTTP/1.1, improving reliability on some network paths. Opt into HTTP/2 with COPILOT_ENABLE_HTTP2=1.
• Plugins auto-installed from repository settings no longer leak into user global config
• Grep tool correctly handles tsx and jsx as file type filters
• COPILOT_HOME is honored for the server discovery registry directory
• Click a diff line with the mouse to select it in diff mode
• Ctrl+C and other modified keys work correctly inside tmux
• @-mention file search matches files regardless of query letter casing
• copilot plugin marketplace list now honors repo-level extraKnownMarketplaces settings from .github/copilot/settings.json
• Queued prompts in the footer are capped to a single line, preventing them from pushing session messages off screen
• MCP servers configured with npx --registry are no longer incorrectly blocked by policy
• Session no longer hangs indefinitely after an error occurs during internal event processing
• Installed plugins no longer include the .git directory from the plugin source repository
• New reasoning after tool calls appears at the bottom of the timeline instead of above earlier output
• Pasting text copied from a browser, editor, or terminal no longer leaves a stray empty line, broken box-drawing lines, or a misplaced cursor in the prompt
• preToolUse hook errors now deny the tool call instead of silently allowing execution
• Session resume works correctly after a crash that left partial data in the session log
• High-contrast diff backgrounds use darker colors to improve text readability
• Add showTipsOnStartup setting to control whether startup tips are shown
• Surface the underlying reason (e.g. GitHub API rate limit) when SDK auth-token validation fails, instead of the misleading "Session was not created with authentication info or custom provider" message.
• /diff defaults to branch diff when there are no unstaged changes

Original source