GitHub Copilot Agent Mode in JetBrains IDEs: 2026 Guide

GitHub Copilot's agent capabilities in JetBrains IDEs have moved fast in 2026. What started as basic completions has grown into a full agentic environment — custom agents, sub-agents, a CLI-backed long-running task runner, inline agent access, worktree-safe isolation, and MCP server integration, all without leaving IntelliJ, PyCharm, or WebStorm.

This guide covers what shipped, how each feature works, and how to wire it into a real JetBrains workflow today.

Why JetBrains Matters in the Copilot Story

VS Code got agent mode first. That's still true. But a significant portion of the professional developer market — particularly Java, Kotlin, Python, and Go shops — runs JetBrains IDEs as a non-negotiable. The Copilot team has spent the first half of 2026 closing that gap aggressively.

Between February and May 2026, GitHub shipped four major JetBrains-specific changelog entries. That is not gradual improvement. That is a coordinated catch-up. The result: JetBrains users now have access to nearly the same agentic surface area as VS Code users, with some JetBrains-specific UX decisions that are worth understanding on their own terms.

The 2026 JetBrains Copilot Release Timeline

Understanding what landed when helps you plan which features to actually enable in your team's setup.

February 2026 brought foundational improvements: better completions, early MCP support in preview, and quality-of-life fixes for the chat panel.

March 11, 2026 was the GA release of core agentic capabilities. Custom agents, sub-agents, and plan mode all reached general availability in the same changelog entry. Cold-start time was cut in half via semantic indexing and session-level caching — something that had made large-codebase agents feel sluggish since their preview launch in 2025.

April 24, 2026 introduced inline agent mode in public preview. This brought the full agent experience into the inline chat popup (Shift+Ctrl+I on Windows/Linux, Shift+Cmd+I on Mac) rather than requiring the separate chat panel.

May 13, 2026 added the Copilot CLI agent for JetBrains in public preview, plus a unified sessions view in the chat window.

The pattern here is layered rollout: GA the core, preview the surfaces. The core (custom agents, plan mode, sub-agents) is stable enough for daily use. The newer surfaces (inline agent mode, CLI agent) are previews, so expect rough edges.

Core Agentic Capabilities (GA as of March 2026)

Custom Agents

Custom agents let you define how Copilot behaves in a specific codebase or workflow. You write a .agent.md file and Copilot reads it as an instruction layer on top of whatever model you're using.

There are two scopes for the .agent.md file:

• Workspace-level: .copilot/agents/your-agent.md in your project root. Applies only to this repo.
• Global-level: ~/.copilot/agents/your-agent.md. Available across all workspaces.

A typical .agent.md might specify the project's coding conventions, which files are off-limits, which testing framework to use, or domain-specific language the model should understand. Think of it as a persistent system prompt for your development context.

In JetBrains, you select a custom agent from the agent picker dropdown in the chat panel before starting a session.

Sub-Agents

Sub-agents are Copilot's answer to context pollution. When you run a complex task — say, refactoring authentication, fixing test failures, then updating documentation — a monolithic agent session accumulates context noise that hurts accuracy over time.

Sub-agents run each subtask in a clean, isolated context. You get more accurate reasoning per step, because the model for each step starts without the baggage of everything that came before. GitHub describes this as "isolated subagents" that "deliver more accurate reasoning, whether you're fixing tests, refactoring code, or generating documentation."

In practice, you invoke sub-agents through plan mode or manually by selecting "Run as subagent" in a session.

Plan Mode

Plan mode changes how Copilot handles ambiguous or multi-step requests. Instead of immediately starting to edit files, it first produces a sequential plan: step 1 do this, step 2 do that, validation gate here. You can review and edit the plan before execution begins.

This is useful for tasks that span many files or require specific ordering. "Refactor the user service to async/await, update all callers, and fix the tests" is the kind of thing that without a plan ends up as a mess of partial edits. Plan mode forces the agent to think sequentially rather than diving into the first thing it sees.

Performance Improvements

Cold-start time dropped by 50% in March 2026. This came from three changes: pre-indexing, parallel context loading, and session-level caching. For large enterprise codebases, the previous agent initialization time was a real friction point. A 50% reduction in cold-start changes the calculus on whether to spin up a new agent session for small tasks.

Semantic search also replaced the previous keyword-matching approach for code navigation. Agents now find relevant code by meaning, not just by text matching.

Inline Agent Mode (Preview — April 2026)

The inline chat in JetBrains has existed for a while, but it used to be limited to single-turn edits. With inline agent mode, it becomes a full agent surface.

How to access it:

• Default shortcut: Shift+Ctrl+I (Windows/Linux) or Shift+Cmd+I (Mac)
• Right-click in the editor → Open Inline Chat → switch to agent mode in the panel
• Click the gutter icon → Inline Chat

Once in agent mode, the inline chat can make multi-file edits, run terminal commands, and use tools — the same capabilities available in the full chat panel. The difference is proximity. You're working in the code, you spot something that needs fixing, and you can engage a full agent without context-switching to the sidebar.

Next Edit Suggestions also got an upgrade in the same April release. Proposed changes now show as inline previews in the editor before you accept them, rather than appearing only in a diff view after the fact.

Global Auto-Approve is also new in this release. You can set auto-approve thresholds for terminal commands and file edits if you trust the agent's judgment on certain operations. This is an opt-in setting — useful when you're running repetitive agent-assisted tasks and the confirmation dialogs become friction.

Copilot CLI Agent in JetBrains (Preview — May 2026)

This is the most architecturally interesting addition. The Copilot CLI agent runs outside the IDE process — it's a long-running, terminal-based agent that can handle tasks spanning minutes or hours. Until now, you had to switch to a terminal or use VS Code to delegate to it.

As of May 13, 2026, you can delegate to a locally running Copilot CLI agent directly from JetBrains, with your editor context already connected.

Isolation Modes

The CLI agent supports two isolation modes that control where its changes land:

Worktree isolation runs the agent in a separate Git worktree. The changes it makes exist in a parallel branch that doesn't touch your current working tree until you explicitly review and apply them. This is the right choice for tasks where you want to see the full diff before anything lands in your branch.

Workspace isolation applies changes directly to your current workspace. No separate worktree. Faster iteration, but changes are immediate. Better for tasks where you're actively supervising the agent and want to see results in real time.

To start a CLI agent session from JetBrains: open the chat panel, select "Copilot CLI" from the agent picker, choose a model, select an isolation mode, and send your prompt. The session shows live progress and tool calls as it runs, ending with a summary of changes and affected files.

The unified sessions view (also launched May 13) makes all of this manageable. The chat window now shows a list of all active and past sessions — CLI, inline, custom agent — with title, agent type, elapsed time, and status. You can filter by agent type or status.

MCP Support in JetBrains

Model Context Protocol support was already in preview in February 2026. By March, it was part of the GA agentic capabilities release. MCP lets Copilot's agent mode connect to external tool servers — databases, APIs, internal docs, custom data sources — and use them as tools during a session.

Setup in JetBrains:

1. Click the GitHub Copilot icon in the IDE toolbar
2. Select Edit settings
3. Find the MCP Servers section
4. Add your MCP server configuration

Once connected, agent mode can call MCP tools alongside its built-in code and terminal tools. This opens up scenarios like: "find the relevant database schema from our internal docs server, then write a migration matching our existing conventions."

The practical limit here is that MCP server quality varies. The protocol is solid, but you need MCP servers that actually expose useful tools for development workflows.

Model Selection: Claude Opus 4.7 and Others

Copilot in JetBrains is not tied to a single model. The agent picker includes model selection, and as of 2026, the lineup includes Claude Opus 4.7 (GitHub documentation lists 87.6% SWE-bench Verified), along with GPT-4o, Gemini, and others.

Auto model selection is generally available as of March 2026. Copilot picks the model based on task type when you leave selection on automatic. For agent tasks, it tends toward the reasoning-capable models.

For extended reasoning models like Codex, there's now a dedicated thinking panel showing the model's reasoning process with configurable Anthropic thinking budgets. This gives you visibility into why the agent made specific decisions — useful for debugging unexpected agent behavior.

Premium requests are consumed differently depending on the model. Claude Opus 4.7 is a premium model, so it draws from your monthly premium request allocation. If you're on Copilot Pro ($10/mo), you get a smaller allocation than Pro+ ($19/mo).

Practical Setup Guide

Here's a minimal setup sequence to get the main features working in IntelliJ IDEA or PyCharm.

1. Install the Plugin

Open your JetBrains IDE settings → Plugins → search "GitHub Copilot" → Install → Restart.

2. Sign In

File → Settings → GitHub Copilot → Sign in with GitHub. Requires an active Copilot subscription.

3. Enable Agent Mode

In the Copilot chat panel, switch to agent mode from the mode selector dropdown. If you don't see agent mode, check that you're on plugin version 1.5+ (released March 2026).

4. Create a Custom Agent (Optional)

Create .copilot/agents/project.md in your project root:

# Project Agent

## Context
This is a Java Spring Boot application. Use Spring conventions.
Testing framework: JUnit 5 with Mockito.
Never modify files in src/main/generated — these are auto-generated.

## Style
Follow Google Java Style Guide.
Prefer explicit types over `var` for public API methods.

5. Set Up MCP (Optional)

Settings → GitHub Copilot → Edit settings → MCP Servers. Add a server entry in JSON format:

{
  "mcpServers": {
    "internal-docs": {
      "command": "npx",
      "args": ["-y", "@your-org/mcp-server-docs"]
    }
  }
}

6. Try the CLI Agent

In the chat panel, select "Copilot CLI" from the agent dropdown. Choose your isolation mode (worktree recommended for first-time use). Enter a task like: "Add input validation to all POST endpoints in the UserController, write unit tests, and update the OpenAPI spec."

Watch the session in the unified sessions view.

What's Still Missing

A few things are worth noting for teams evaluating this setup:

Preview features have rough edges. Both inline agent mode and the CLI agent are public previews as of May 2026. They work, but expect occasional failures and missing edge-case handling. The GA path is clear, but it's not there yet.

Worktree isolation has limits. Repos with complex submodule structures or custom Git hooks may have unexpected behavior in worktree mode. The feature relies on standard Git worktrees, so anything that doesn't play nicely with worktrees generally will show up here.

No free tier for agent features. Copilot Free exists, but agent mode and the premium models that make it useful require at least the Pro tier. The cost is $10/mo — not a blocker for most professional developers, but worth noting for students or open-source contributors.

Cross-IDE parity isn't total. VS Code has had some features for a few months longer. If you're evaluating whether to switch IDEs for Copilot reasons alone, the gap is now small enough that it's probably not worth it.

FAQ

Q: Does GitHub Copilot agent mode work with all JetBrains IDEs?

Yes. The Copilot plugin works across IntelliJ IDEA, PyCharm, WebStorm, GoLand, Rider, CLion, DataGrip, and other JetBrains IDEs. Feature availability depends on plugin version, not the specific IDE.

Q: What is the difference between worktree isolation and workspace isolation in the CLI agent?

Worktree isolation creates a separate Git worktree where the agent makes its changes. Those changes don't appear in your working branch until you review and explicitly merge them. Workspace isolation makes changes directly to your current workspace, faster but without the safety buffer of a separate branch. Use worktree for tasks you want to review before committing, workspace for tasks where you're actively supervising the agent.

Q: Can I use custom agents globally, not just per-project?

Yes. Place your .agent.md file at ~/.copilot/agents/your-agent.md and it will be available across all your workspaces. Project-level agents in .copilot/agents/ in the repo root take precedence when both exist.

Q: Does inline agent mode replace the chat panel?

No. Inline agent mode is a complement, not a replacement. It gives you agent capabilities from the inline chat popup (the same interface used for single-turn edits). The chat panel remains available for longer conversations, planning sessions, and CLI agent delegation. Think of inline agent mode as the "quick access" surface.

Q: Which models are available for agent mode in JetBrains?

As of May 2026, available models include GPT-4o, Claude Opus 4.7, Gemini, and others. Model availability depends on your Copilot plan tier — some premium models require Pro or Pro+ subscriptions. Auto model selection is GA and will pick an appropriate model for the task type if left on automatic.

Q: Is MCP support stable in JetBrains?

MCP support reached GA with the March 2026 release. The integration is stable, but MCP server quality varies. You need an MCP server that exposes useful tools for your workflow. The configuration UI is accessible via Settings → GitHub Copilot → Edit settings → MCP Servers.

Key Takeaways

GitHub Copilot's JetBrains integration has moved from "decent completions" to a real agentic environment in the first half of 2026. The March GA release of custom agents, sub-agents, and plan mode was the inflection point. The April inline agent preview and May CLI agent preview add two more surfaces for how you engage with the agent.

The most practically useful features right now are the ones that are GA: custom agents for encoding project conventions, plan mode for complex multi-file tasks, sub-agents for avoiding context pollution, and MCP for connecting to internal data sources. The preview features (inline agent, CLI agent) are worth enabling and experimenting with, but treat them as "coming soon to production" rather than "production-ready today."

If your team is already paying for Copilot and running JetBrains, the setup time to get custom agents and MCP working is under an hour and the productivity gain on complex tasks is measurable. That's the case for enabling it now, not waiting for the preview features to go GA.