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. To see where Copilot's agent mode sits against the wider field, see our best AI coding agents comparison.

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.

Feature Availability at a Glance (Source Matrix)

This table maps each JetBrains capability to its maturity and the exact changelog entry that announced it, so you can verify every row yourself before enabling it for a team. "GA" means daily-usable; "Preview" means functional but not production-hardened.

Capability	Maturity	Landed	Primary source
Chat and completion improvements, early MCP	Shipped	Feb 13, 2026	Feb 13 changelog
Custom agents, sub-agents, plan mode, MCP	GA	Mar 11, 2026	Mar 11 changelog
Inline agent mode, Next Edit previews, global auto-approve	Preview	Apr 24, 2026	Apr 24 changelog
Copilot CLI agent, unified sessions view	Preview	May 13, 2026	May 13 changelog
Claude as agent provider in JetBrains	Preview	Jun 22, 2026	Jun 22 changelog

The takeaway from the matrix: only the March 11 row is GA. Everything shipped after it is still a preview at the time of writing. Plan your rollout around the GA row and treat the rest as opt-in experiments.

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.

Feature	Inline Agent Mode	CLI Agent	Chat Panel Agent
Entry point	Shift+Cmd+I in editor	Agent picker → Copilot CLI	Chat panel sidebar
Task scope	Focused, in-context edits	Long-running, multi-step	General multi-file tasks
Isolation	Direct edits	Worktree or workspace	Direct edits
Session visibility	Per-edit session	Unified sessions view	Chat history
Best for	Quick in-file tasks	Complex delegated work	Exploratory / planning

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 in JetBrains Agent Mode

Copilot in JetBrains is not tied to a single model. The agent picker includes model selection, and the 2026 lineup spans GPT-4o, Gemini, and Anthropic's Claude models, among others. Claude reached JetBrains as an agent provider in a June 22, 2026 preview, so confirm current model availability against your own plan before you standardize a team on a specific one.

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, there's a dedicated thinking panel showing the model's reasoning process with configurable thinking budgets. This gives you visibility into why the agent made specific decisions — useful for debugging unexpected agent behavior.

Cost and Billing

GitHub moved Copilot to usage-based AI Credits billing on June 1, 2026, replacing the earlier fixed "premium request" allocations (GitHub announcement). Code completions and Next Edit Suggestions stay included and do not consume credits; agentic workflows and code review draw down credits by token usage. On the published plans, Copilot Pro is $10/month and Copilot Pro+ is $39/month, each bundling a monthly credit balance. Because agent runs are now metered by tokens, a heavy day of CLI-agent delegation can consume credits faster than the old flat model implied — worth watching if you turn on auto-approve.

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. If you are also weighing terminal-first agents, see our terminal AI coding agents comparison.

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.

Strengths
<ul>
  <li>Custom agents with workspace and global scope — real project context without repeated prompting</li>
  <li>Worktree isolation makes CLI agent safe to use on active branches</li>
  <li>MCP support extends agent capabilities to internal data sources</li>
  <li>Plan mode reduces multi-step task failures significantly</li>
  <li>50% faster cold-start since March 2026 — agents feel much more responsive</li>
</ul>


Limitations
<ul>
  <li>Inline agent mode and CLI agent are still public previews — not production-hardened</li>
  <li>Premium model access draws from monthly request allocation</li>
  <li>MCP server quality varies; setup requires a working MCP server</li>
  <li>VS Code still leads by a few months on some cutting-edge features</li>
</ul>

When to Use It, When to Skip It

Copilot's JetBrains agent mode is not an all-or-nothing switch. Match the feature to the situation:

Use it when:

• Your team already pays for Copilot and lives in IntelliJ, PyCharm, GoLand, or Rider. The GA features cost you only setup time.
• You have repeatable project conventions worth encoding once in a .agent.md custom agent instead of re-explaining every session.
• You run multi-file refactors where plan mode's review-before-edit step prevents half-finished changes.
• You want to delegate a long task (add validation across endpoints, write the tests, update the spec) and keep working — that is the CLI agent with worktree isolation.

Skip it, or wait, when:

• You need production-hardened reliability today. Inline agent mode and the CLI agent are previews; treat them as early access, not core workflow.
• Your repo uses heavy Git submodules or custom hooks — worktree isolation can behave unexpectedly, so test on a throwaway branch first.
• You are on Copilot Free or an open-source/student budget. Agent features and the useful models require at least Pro, and agent runs now meter AI Credits by token usage.
• You are debating switching IDEs purely for Copilot. Parity with VS Code is now close enough that the switch rarely pays off on its own. For that comparison, see our best AI coding agents comparison and the Codex vs Claude Code comparison. If a spec-first workflow is what you actually want from agent mode, AWS Kiro's spec-driven IDE takes a different route worth weighing.

Adoption Checklist

Run this before you turn agent mode on for a team, not after:

• [ ] Plugin updated to a version that shows agent mode (1.5+ / March 2026 GA line or later).
• [ ] Every active member has at least Copilot Pro; confirm the AI Credits balance fits expected agent usage.
• [ ] A workspace .copilot/agents/project.md encodes conventions, off-limits paths, and the test framework.
• [ ] First CLI-agent runs use worktree isolation so nothing lands on a live branch unreviewed.
• [ ] Auto-approve stays off until you have watched a few sessions and trust the diffs.
• [ ] Any MCP server you wire in is one you control or trust — agent tools inherit its access.
• [ ] Rollout plan treats only the March 11 GA capabilities as daily-use; previews are opt-in experiments.

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 mid-2026, available models include GPT-4o, Anthropic's Claude models, Gemini, and others; Claude arrived as a JetBrains agent provider in a June 2026 preview. Model availability depends on your Copilot plan tier, and agent usage now draws from AI Credits metered by token consumption. 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.

What Effloow Added

GitHub ships these features across scattered changelog posts; nobody on the Copilot team writes the JetBrains-user's-eye view. We assembled it:

• A source matrix mapping each capability to its maturity and the exact changelog entry that announced it, so every claim in this guide is one click from its primary source.
• An adoption checklist and a when-to-use/when-to-skip split that turn the feature list into a rollout decision — GA capabilities for daily use, previews as opt-in experiments.
• Corrected cost framing reflecting the June 1, 2026 move to usage-based AI Credits (Pro $10, Pro+ $39), instead of the retired flat premium-request model.

The value is the JetBrains-specific, GA-vs-preview reality with sourced maturity and a rollout decision, not a reprint of the changelog.

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.

Bottom Line

GitHub Copilot's JetBrains agent mode is now genuinely competitive with VS Code. The GA features — custom agents, plan mode, sub-agents, MCP — are stable and worth using today. The preview features (inline agent, CLI agent with worktree isolation) are promising but treat them as early access. If you're on a JetBrains shop already paying for Copilot, there's no reason to wait.