Claude Lands in JetBrains as an Agent Provider
On June 22, 2026, GitHub shipped a Copilot update for JetBrains IDEs that adds Claude as an agent provider in public preview. This is the headline feature, and it follows the same move GitHub made earlier in VS Code: rather than treating its assistant as a single fixed model, Copilot is increasingly a host for multiple agent providers that developers can choose between. For JetBrains users, who have often felt a step behind the VS Code experience, this brings the multi-provider model into the IDEs where a large share of professional backend and enterprise development actually happens.
There is a practical dependency worth flagging. Using Claude as a provider requires the Claude Code CLI to be installed and configured in the IDE settings, which means this is not a one-click toggle so much as a bridge between Copilot's interface and a locally available agent runtime. We read that as a deliberate architectural choice rather than a limitation. By delegating to an installed CLI, GitHub keeps Copilot's surface provider-agnostic while letting the underlying agent run with its own tooling and credentials. It is a pattern that scales to additional providers without GitHub having to reimplement each one inside the IDE.
Organization and Enterprise Custom Agents
The feature we think engineering leaders should study most closely is the new ability for organizations and enterprises to publish custom agents to all team members. Until now, custom agent configuration has largely been an individual-developer concern, with each engineer assembling their own prompts, tools, and behaviors. Allowing admins to publish a vetted agent across an organization changes the unit of standardization from the person to the team. That is the difference between a collection of personal experiments and a governed, shared capability that an entire engineering org operates against.
This matters because coding agents are quickly becoming part of the toolchain that platform and developer-experience teams are expected to own. An admin-published agent can encode an organization's conventions, its preferred libraries, its review expectations, and its guardrails, then deliver that consistently to every developer rather than hoping each one configures things correctly. Our view is that this published-agents capability is exactly how enterprises will move from ad hoc agent usage toward something governable. The companies that treat agent configuration as shared infrastructure, versioned and centrally managed, will get more predictable results than those that leave every engineer to roll their own.
Usage Metering Becomes Visible
Tucked into the release is a change that is easy to overlook and important to take seriously: the per-turn AI Credits indicator now spans local, CLI, and Claude agent sessions. In other words, the credit cost of each interaction is now surfaced consistently across every way a developer might invoke an agent, not just inside one mode. As Copilot moves toward usage-based billing, this kind of at-the-point-of-work visibility is what turns an abstract bill into something teams can actually reason about and manage.
We would argue the metering story is the quiet but consequential part of this update. Provider choice and published agents get the attention, but the economics of agent usage are what engineering leaders will be answering for when the invoice arrives. A per-turn indicator that follows the developer across local, CLI, and Claude sessions gives organizations the raw signal they need to understand consumption patterns, attribute cost, and set expectations before usage runs ahead of budget. The teams that pair powerful agents with clear, real-time metering will adopt these tools with their eyes open. The teams that ignore the meter will learn its lessons the expensive way.
Copilot CLI Gains Follow-Up Messaging
The command-line experience picked up a useful piece of interaction design. Copilot CLI follow-up messaging now offers three options while an agent is working: Add to Queue, Steer with Message, and Stop and Send. These map cleanly onto how people actually collaborate with a running agent. Sometimes you want to line up the next instruction without interrupting, sometimes you want to nudge the agent mid-task, and sometimes you want to halt what it is doing and redirect entirely. Giving each of those intents an explicit control is a small but meaningful improvement over the all-or-nothing interruption models that earlier agent CLIs shipped with.
Alongside this, the release adds an agent debug-logs summary panel, which addresses one of the persistent frustrations with agentic tools: understanding what the agent actually did and why. When an agent takes a surprising action, a readable summary of its execution is the difference between trusting the tool and quietly abandoning it. We see both of these CLI improvements as signs of a tooling category maturing past the demo phase. The hard problems in agent UX are not about raw capability anymore; they are about steerability and observability, and this update moves on both.
Model Selection and Context Windows
The update also introduces a new slash command for models, giving developers larger context-window selection and a recently-used models section. The context-window control is the more substantive of the two. As tasks grow to span larger codebases and longer agent runs, the ability to deliberately select a bigger context window is the difference between an agent that can hold the relevant code in view and one that loses the thread halfway through. Putting that choice directly in the developer's hands, rather than hiding it behind defaults, respects how varied real engineering tasks are.
The recently-used models section is a smaller convenience, but it reflects an accurate read of how developers work. People settle into a handful of models they trust for particular kinds of work and switch between them frequently. Surfacing recent choices reduces the friction of that switching and acknowledges that model selection is now a routine part of the development loop rather than a one-time setup decision. Together these additions treat model choice as a first-class, frequently-exercised control, which is the right instinct as the number of available models and their distinct strengths continue to multiply.
Cloud Agent Reaches General Availability
Rounding out the release, Cloud Agent has graduated from preview to general availability. The move out of preview is GitHub signaling that it considers background, cloud-hosted agent execution stable enough to stand behind without the implicit disclaimers that accompany preview features. For organizations that have been waiting for a GA stamp before committing to a workflow, that label carries real weight. It changes Cloud Agent from something to pilot into something teams can reasonably build process around.
Taken as a whole, this update tells a consistent story about where GitHub is steering Copilot. Provider-agnostic agent tooling, now extended into JetBrains, combined with admin-published agents and pervasive usage metering, is the shape of how enterprises will standardize and govern coding agents. Our view is that the individual features matter less than the direction they collectively point. GitHub is building the controls that engineering leaders need to deploy agents across teams responsibly: choice of provider, central configuration, and visibility into cost. The capability has been impressive for a while. This release is about making it manageable.
