JetBrains IDEs get Claude agent preview and enhanced GitHub Copilot features

enabling productivity: exploring GitHub Copilot JetBrains new features and Claude agent integration

Every quarter, an IDE upgrades and claims to change your workflow. Most don’t. This one does. With the June 2026 release, GitHub Copilot ships a dense slate of upgrades for JetBrains IDEs—wrapping core AI agent power, team-wide governance, and true multitasking in a set of features you can actually use now. “GitHub Copilot JetBrains new features” is not a tagline; it’s organizational agents, Claude as an agent provider, per-turn credits, queuable CLI, and a more tunable model picker—shipped. For teams scaling AI productivity, this is the step where sandboxes become workflow.

This is what real “AI-integrated workflow” looks like. Here’s the hardest parts of the delivery, the new surface enables, and concrete, no-fluff steps for every announced feature, straight from the changelog.

What are the new GitHub Copilot JetBrains features introduced in 2024?

The latest GitHub Copilot JetBrains features include organization- and enterprise-level agents, multi-step CLI messaging, summarized debug logs, Claude as agent provider (public preview), model picker improvements, and a per-turn AI credits indicator. Each upgrade addresses a specific developer or team pain.

• Organization and enterprise agents: Teams can now ship standardized, internal-use Copilot agents—controlling availability and default behaviors centrally.
• CLI queue and steer: Developers can enqueue or override agent requests directly in long-running Copilot CLI sessions without cancelling or idling.
• Agent debug logs summary: One-click session logs provide aggregate agent activity, helping with troubleshooting and cross-session comparison.
• Claude as agent provider: Anthropic’s Claude enters public preview as a first-class provider inside JetBrains Copilot, expanding model quality and flexibility.
• Model picker upgrades: Directly choose between available AI models per task; user-facing transparency on what’s running.
• Per-turn AI credits indicator: See resource use at the granularity of each interaction—an explicit step toward predictability and budgeting.
• Cloud agent GA: The GitHub Cloud agent is now generally available, enabling more stable and scalable integrations.

These features are available as of the June 22, 2026 update, per the GitHub changelog. Some are in public preview (Claude); others apply to all users right now.

What’s notable: this isn’t just a batch of toggles. Each is a specific answer to a real breakdown (CLI interactions blocking, agent debugging scattered, team standardization missing). For once, the changelog maps to known pain.

How does GitHub Copilot support organization and enterprise agents in JetBrains IDEs?

GitHub Copilot now allows admins to publish and curate organization-level or enterprise-level agents, making them instantly available to all members inside JetBrains IDEs. This means agents are no longer personal sandboxes—teams can finally standardize workflows, enforce best practices, and ensure compliance from the center.

Admins define custom agents at the org or enterprise level. Those agents—“curated” with domain knowledge, access scopes, and guardrails—are instantly discoverable for every developer using Copilot in JetBrains. No more “copy this YAML” by hand, no more fragile shell scripts or hidden sidecar processes.

Benefits:

• Team-wide consistency: Teams work with the same set of tools and conventions.
• Centralized governance: Security, workflows, and capabilities can be monitored and updated in one place.
• Instant sharing: Adding or upgrading an agent distributes to every IDE with no per-user setup.

How to use:

• Organization or enterprise admins create and publish agents in the GitHub admin UI.
• From JetBrains IDE, users see these agents natively in their agent list—no manual configuration or plugin drift.
• See Preparing to use custom agents in your organization for details. (Guidance as per changelog, direct link for setup steps.)

With this, orgs can finally impose—by default—agents tuned for their repos, preferred frameworks, and compliance requirements. The effect: new hires and contractors are on-ramp to team conventions, not open playgrounds.

How do you queue and send follow-up messages during Copilot CLI sessions?

The new Copilot CLI session update lets developers queue, steer, or immediately send follow-up messages while a prior agent request is in progress. Previously, you would either wait passively (“request running…”) or cancel the agent’s action to give new input—wasting time and breaking flow. Now, the process is unblocked.

When a CLI request is running, the Send button exposes three precise options:

• Add to Queue: The message will be held until the current agent response ends, then dispatched. This is pure queuing—no cancel or interrupt.
• Steer with Message: Mid-execution, tells the agent to process your message immediately after the current tool finishes, so you can redirect the workflow without killing the current computation.
• Stop and Send: Cancels the current agent turn and sends your new input instantly—necessary when the agent veers far off course.

Example flow:

# Start a Copilot CLI session in JetBrains
copilot-cli session

# While agent is running a long task...
# Send additional input using the dropdown:
#   - Add to Queue (press ↓ on Send)
#   - Steer with Message
#   - Stop and Send

Where this enables value:

• Multistep CLI tasks: Queue “install deps” then “scan output” without babysitting progress.
• Real-time redirection: Nudge the agent without burning progress.
• Interruptible runs: Stop runaway scripts without hammering ctrl+C or losing history.

The operational shift is straightforward: Copilot CLI is now responsive to you—not the other way around.

What is Claude as an agent provider and how does it enhance Copilot in JetBrains?

Claude, the language model from Anthropic, enters public preview as an agent provider inside JetBrains Copilot. This means users can now select Claude to run their agent turns, alongside other supported providers.

Why does this matter? Claude consistently ranks near the top for reasoning, summarization, and code assistance tasks. With its addition:

• Accuracy and completeness: Different models excel at different types of code or conversations. Claude offers a meaningfully different answer style.
• Speed: Claude’s API delivers on short completion times for typical agent requests.
• Domain customization: Claude is known for better handling of in-domain prompts when tuned. With JetBrains support, it’s now a valid drop-in for Copilot users.

Integration details:

• Public preview means all Copilot JetBrains users can opt to use Claude for selected agent sessions.
• The model can be chosen from the agent model picker (see next section).
• No private beta process—access now if previous agent provider sufficed for your org.

Claude can run as the main engine for Copilot’s code suggestions or as a fallback if other providers are slow or unavailable. For agents with specific domain workflows, the flexibility to assign models per agent or session is a core enable.

For more, see the official changelog. Per the release, model quality and selection are now fully user-controllable for the first time in Copilot for JetBrains.

How does the new AI credits per-turn indicator and model picker improve user experience?

The new model picker gives developers direct, session-by-session control over which AI model powers their agent session. Got a task that works better on Claude? Pick it. Need the legacy default for compatibility? One click back.

This isn’t just about flexibility—it’s transparency. At each agent interaction, the per-turn AI credits indicator reveals resource/account consumption in real time. Developers see exactly how much of their AI usage quota an action consumed.

Why this matters:

• Informed choice: Pick a cheaper model for a batch script, a stronger one for a complex migration.
• Cost clarity: Credits per turn means no more guessing what a long session will burn—budgeting is possible and wasted capacity gets surfaced.
• Debugging: If a session suddenly costs more, you know which model or agent was responsible.

Using it:

• From the conversation or agent interface in JetBrains, select your model (Claude, default, etc) in the picker at session start or mid-run.
• After each turn, note the AI credits entry—tune further if the workflow can be optimized.

Transparent costs and real-time control are prerequisites for serious teams tracking budgets across hundreds of developers. Now both ship natively.

What reliability and usability improvements have been introduced in GitHub Copilot for JetBrains?

The June 2026 update rolls out several reliability and UI improvements—none headline-grabbing independently, but collectively vital for trust and day-to-day flow.

• Agent debug logs summary: Instead of trawling raw logs or manually correlating agent messages, a single view now shows session activity, aggregate stats, and error points. Jump to the summary by selecting your session—no more scattered log hunting.
• Cloud agent now GA: GitHub’s Cloud agent exits beta. General availability translates to better uptime, faster failover, and support for larger org deployments. This is foundational—agent-centric workflows need durable backend support.
• Bug fixes and UI tweaks: The changelog names “user experience and reliability improvements”—typically code for dozens of minor defects, layout alignments, and quality-of-life changes based on live feedback.

Each patch adds up. Developers churn less on errors, debug faster, and spend more time at the edge of what the workflow can do, not fixing its foundation.

What this enables for developer teams

“GitHub Copilot JetBrains new features” is more than incremental: organization-level governance brings large teams fully into the AI agent era, CLI queuing shaves minutes per task, and model/credits transparency enables budgeting at scale. Claude’s entry is more than model churn—it’s a genuinely differentiated agent that you can swap in per workflow.

To adopt now:

• Configure org/enterprise agents with admin privileges (GitHub UI).
• For CLI, upgrade, then use the Send dropdown during any long agent run.
• To test Claude, select it in the agent model picker—no private beta, just opt-in.
• Monitor workflow costs and tune with the per-turn credits indicator.
• For debugging, consult the Agent Debug panel’s new logs summary after any complex session.

The surface layer—teams using AI in JetBrains—will keep evolving. But the boundaries beneath (organization-driven governance, explicit credits, real multitasking) are the new table stakes. Build above this line and the next round of Copilot churn upgrades the machinery, not your entire stack.

For a deeper dive:

• Detailed guide on using GitHub Copilot extensions in JetBrains IDEs
• Overview of AI agent providers and comparisons (including Claude)
• Best practices for managing AI resources and credits in developer tools

The 2026 Copilot JetBrains release is what “AI-integrated development” should look like: opinionated defaults, team safety rails, and transparent control that scales. The next move is yours.