GitHub Copilot for JetBrains Adds Model Controls and MCP Settings

GitHub Copilot is becoming more than a code-completion assistant. Developers can use it to understand unfamiliar code, investigate errors, generate tests, and coordinate tasks through AI agents. However, the usefulness of these capabilities depends on more than the quality of the AI model. Developers also need control over which model is used, which tools the assistant can access, and how those tools behave inside the IDE.

GitHub's October 10 update for Copilot in JetBrains IDEs introduces additional controls for default models and Model Context Protocol (MCP) servers. It also improves diagnostic fixes, chat navigation, account controls, and reliability across agent sessions.

These changes are relevant to developers using IntelliJ IDEA, PyCharm, WebStorm, Rider, and other supported JetBrains IDEs. They also give development teams more ways to manage AI-assisted coding workflows.

What Changed in GitHub Copilot for JetBrains?

The update focuses on giving developers and administrators greater control over AI-assisted development.

Feature	What it changes	Who benefits
Managed default models	Administrators can select the default agent model for new conversations	Enterprise teams
MCP server controls	Developers can manage when configured MCP servers start	Developers and administrators
Diagnostic fixes	Opens inline chat to help repair reported issues	Developers
Chat navigation	Improves navigation through longer conversations	Developers
Account controls	Improves account-related workflows	Users managing Copilot access
Agent reliability	Improves behavior across agent sessions, customizations, and worktrees	Teams using agent workflows

The important distinction is that a default model is not necessarily a permanently fixed model. Developers can still make an explicit selection through the model picker, subject to the models available to their accounts and organizational policies.

Understanding Model Controls in GitHub Copilot

Different coding tasks require different levels of reasoning. Generating a simple data-transfer object is not the same as investigating a race condition or reviewing a complicated authentication flow.

A model that responds quickly to straightforward prompts may not be the best choice for a task involving multiple files, dependencies, and architectural decisions.

How Managed Default Models Work

Enterprise administrators can configure an available Copilot agent model as the default for new conversations. This helps teams establish a consistent starting point for AI-assisted development.

For example, a development team might prefer a model that performs well on code analysis and multi-step programming tasks. Setting that model as the default reduces the need for individual developers to select it every time they begin a conversation.

However, a default model does not automatically guarantee identical results across all tasks. Output quality still depends on the prompt, repository context, available tools, and complexity of the problem.

Choosing a Model for the Task

Developers should consider the following factors when selecting a model:

Code generation: Use a suitable model for routine implementations and repetitive coding tasks.
Debugging: Prefer stronger reasoning capabilities when investigating complex failures.
Code review: Evaluate whether the model can identify security problems, incorrect assumptions, and missing edge cases.
Large changes: Consider context handling and the model's ability to follow instructions across multiple files.
Response time: Account for how long the task can reasonably wait for an answer.

For organizations, model selection should also account for subscription availability, administrator restrictions, and any applicable data-handling requirements.

What Is MCP, and Why Does It Matter?

The Model Context Protocol, commonly called MCP, provides a standardized way for AI applications to communicate with external tools and context providers.

Without external tools, an AI coding assistant primarily works with the information available in its conversation and development environment. MCP can extend that workflow by allowing the assistant to interact with configured services, subject to their permissions.

For example, an MCP server might provide tools for:

Searching repository issues and pull requests.
Retrieving relevant project information.
Accessing approved documentation.
Querying development resources.
Performing supported operations through external services.

The available capabilities depend on the particular MCP server and the permissions granted to it.

Why MCP Configuration Needs Attention

Connecting an MCP server introduces a new consideration: the assistant may gain access to information or operations beyond the currently open source file.

A server configured for repository access could expose issue details, pull-request information, or other resources. A server with write capabilities might also allow changes to external systems.

Therefore, enabling MCP is not simply a convenience setting. It is part of the development environment's access-control boundary.

Configuring an MCP Server for GitHub Copilot

The exact setup depends on the server and the JetBrains IDE configuration. The following example illustrates the general structure of a remote GitHub MCP server configuration.

Step 1: Check the Prerequisites

Before configuring a server, confirm that:

The GitHub Copilot plugin is installed and enabled in your JetBrains IDE.
You are signed in to the correct GitHub account.
Your subscription and organization policies permit the required capabilities.
The MCP server is approved for use in your development environment.

For Copilot Business and Enterprise users, organizational policies may need to permit MCP usage.

Step 2: Define the MCP Server

An MCP configuration can use a JSON structure similar to the following for a remote server:

{
  "servers": {
    "github": {
      "url": "https://api.githubcopilot.com/mcp/"
    }
  }
}

This example identifies the remote server endpoint. It is an illustrative configuration, not a complete authentication policy for every environment.

Use the authentication mechanism supported by your client and organization. Depending on the setup, authentication may involve an OAuth authorization flow or a suitably scoped personal access token.

Avoid placing access tokens directly in source-controlled configuration files.

Step 3: Verify Authentication and Permissions

After configuring the server, complete any required authentication prompts and confirm that the expected tools are available.

Test a read-only operation first, such as searching for a repository issue. Verify that the returned information matches the intended repository and account.

If the operation fails, check the authentication state, server configuration, network access, and applicable organizational policies before changing permissions.

Step 4: Review Server Startup Behavior

The updated Copilot experience provides additional control over MCP server startup. This is useful when developers want to avoid activating every configured integration automatically.

Review which servers are needed for a particular workflow. A repository investigation may require GitHub tools, while a local code explanation may not need external integrations.

The goal is to make tool access intentional rather than enabling unnecessary capabilities for every conversation.

Using the New Diagnostic Fix Workflow

The update also introduces a Fix action in diagnostic intention menus. This lets developers move from a reported issue to an AI-assisted repair without manually recreating the problem in a separate chat.

For example, imagine an ASP.NET Core application contains a nullable-reference warning:

public string GetDisplayName(string? name)
{
    return name.Trim();
}

The method can throw a NullReferenceException when name is null. A developer can use the diagnostic workflow to ask Copilot to propose a correction.

One possible implementation is:

public string GetDisplayName(string? name)
{
    return string.IsNullOrWhiteSpace(name)
        ? "Unknown"
        : name.Trim();
}

This example illustrates the type of issue that an AI-assisted fix might address; it does not guarantee that Copilot will generate this exact implementation.

The update allows the Fix action to open inline chat and request a repair. Agent mode is used when available; otherwise, the workflow falls back to ask mode.

Developers should still review the proposed change, particularly when the diagnostic involves authentication, authorization, data validation, or business rules.

Practical Comparison: Before and After the Update

Workflow	Earlier approach	Updated experience
Starting a conversation	Select an appropriate model when needed	Enterprise administrators can define a default for new conversations
Using MCP integrations	Configure the required servers and permissions	Additional control over server startup behavior
Addressing diagnostics	Investigate the issue and initiate a separate AI interaction	Open inline chat through the diagnostic Fix action
Reviewing long conversations	Navigate through the chat history	Improved chat navigation
Managing Copilot access	Use existing account controls	Improved account-related workflows

These changes reduce friction in common workflows, but they do not remove the need for code review, testing, or access-control management.

Advantages and Disadvantages

Advantages

More consistent model selection: Enterprise teams can establish a preferred starting model for new conversations.

More deliberate tool access: MCP startup controls help developers decide when integrations should become active.

Faster diagnostic investigation: Developers can move directly from a reported issue to an AI-assisted repair workflow.

Improved chat usability: Navigation improvements make extended coding conversations easier to manage.

Disadvantages and Limitations

Model defaults are not a quality guarantee: Developers must still evaluate generated code and select appropriate models for complex work.

MCP introduces additional security considerations: External tools may expose sensitive information or perform operations, depending on their permissions.

Configuration can vary: Server authentication, availability, and organizational policies may prevent a configuration from working identically across environments.

AI-generated fixes require validation: A proposed correction can remove a warning without addressing the underlying business requirement or introducing the right edge-case behavior.

Best Practices for Production Development Teams

1. Standardize Defaults, but Preserve Developer Judgment

Choose a default model based on common development tasks. Document when developers should switch models for complex debugging, security reviews, or architectural work.

2. Apply Least Privilege to MCP Servers

Grant each server only the access required for its purpose. Prefer read-only permissions when write access is unnecessary, and review authorization scopes before connecting external services.

3. Keep Credentials Out of Source Control

Never commit personal access tokens, API keys, or other secrets in MCP configuration files. Use approved credential storage and rotate credentials according to organizational policy.

4. Test AI-Generated Changes

For application code, run the relevant unit tests, integration tests, static analysis, and security checks. Review changes manually before merging them into a shared branch.

5. Establish Clear Review Boundaries

Treat AI-generated code as a proposed change, not an approved change. Require additional scrutiny for database migrations, permission checks, payment processing, and other high-impact operations.

6. Document the Team's MCP Configuration

Maintain an approved list of MCP servers, their owners, their permissions, and their intended use. This makes troubleshooting and security reviews more straightforward.

Common Problems and Troubleshooting

Problem	What to check
The expected model is unavailable	Confirm subscription eligibility, administrator policies, and the available model list
MCP tools do not appear	Verify server configuration, startup state, authentication, and client support
An MCP request is denied	Check authorization scopes, repository access, and organization policies
A diagnostic fix is unsuitable	Review the surrounding code, clarify the prompt, and run tests
Agent behavior differs between projects	Check project instructions, worktree context, configured tools, and model selection

Avoid resolving every problem by granting broader permissions. First identify whether the failure comes from configuration, authentication, availability, or an actual access restriction.

Summary

GitHub Copilot for JetBrains adds useful controls for model defaults and MCP server startup, alongside improvements to diagnostics, chat navigation, account management, and agent reliability.

For individual developers, the changes can make AI-assisted coding more convenient. For teams, they provide additional ways to standardize model selection and manage integrations.

The biggest benefit comes from combining these capabilities with disciplined engineering practices. Choose models according to task complexity, limit MCP permissions, protect credentials, and validate generated code through testing and review. These steps help teams use AI assistance without weakening the reliability or security of their development process.