ReSharper 2026.2 Brings Any AI Agent to Visual Studio via ACP

TL;DR

• ReSharper 2026.2 EAP introduces ACP (Agent Client Protocol) support to break vendor lock-in in Visual Studio
• Junie is the first agent proving the concept — autonomous coding, refactoring, terminal ops, and VCS control
• Coming soon: ACP Agent Registry lets you discover, install, and switch between any compatible AI agent
• .NET developers stuck in Visual Studio finally get the multi-agent freedom that other IDEs already have

The Big Picture

JetBrains just made a bold move: ReSharper 2026.2 EAP is ditching the single-agent model entirely. Instead of forcing you into one AI assistant, they're building an open ecosystem where you choose which agents run inside Visual Studio. The mechanism? ACP (Agent Client Protocol), an open standard that lets any compatible agent plug into ReSharper without custom integrations.

This matters because Visual Studio developers have been stuck. GitHub Copilot dominates the space, but if you want a different agent — one that's better at refactoring, or trained on your company's codebase, or just cheaper — you're out of luck. ReSharper's ACP integration changes that. Once the Agent Registry launches, you'll browse agents like VS Code extensions: local tools, remote services, in-house agents. Install what you need. Switch when requirements change.

The first agent proving this works is Junie, JetBrains' own AI coding agent. It's not just a chatbot — it writes code, executes terminal commands, manages Git operations, and performs autonomous refactorings across your entire solution. This EAP is the plumbing test. If it works, ReSharper becomes the first major .NET IDE where you control the AI stack.

How It Works

ACP is a protocol, not a product. Think of it like LSP (Language Server Protocol) but for AI agents instead of language servers. Any agent that implements ACP can connect to any IDE that supports it. ReSharper 2026.2 is JetBrains' first implementation of ACP in Visual Studio, and Junie is the reference agent proving the connection works.

The architecture is straightforward: ReSharper exposes an ACP endpoint. Agents connect to that endpoint and get access to your solution context — files, project structure, terminal, version control. The agent processes your prompts using whatever LLM backend it's configured for (Junie supports multiple models including GPT-4 and Claude), then executes actions through the ACP interface. ReSharper handles the IDE integration — syntax highlighting, file updates, terminal output — while the agent handles the reasoning.

What makes this different from existing AI assistants is the separation of concerns. GitHub Copilot is tightly coupled to GitHub's infrastructure and OpenAI's models. Cursor is its own IDE. Junie in ReSharper is just one agent in what will become a registry of options. You're not locked into JetBrains' agent or their model choices. If a competitor builds a better ACP agent tomorrow, you can swap it in without changing your IDE.

The current implementation has limitations because it's an early preview. Junie gets solution-wide context automatically — you can't manually select which files it sees yet. Deep integration with ReSharper's refactoring engine isn't live. The UI is functional but basic. These are plumbing tests, not polish. JetBrains is validating that ACP works in Visual Studio before they open the floodgates to third-party agents.

Under the hood, Junie operates autonomously. You give it a task like "refactor this 800-line class into separate services" and it doesn't just suggest changes — it writes the new files, updates imports, moves methods, and commits the result to Git if you want. It can execute terminal commands directly: create directories, run build scripts, initialize repos. For .NET developers used to manual refactoring or basic autocomplete, this is a workflow shift. The agent does the grunt work. You review and approve.

What This Changes For Developers

If you're a .NET developer in Visual Studio, you've had exactly one real AI coding option: GitHub Copilot. It's good at autocomplete, decent at generating boilerplate, weak at large refactorings. ReSharper's ACP support breaks that monopoly. Once the Agent Registry launches, you'll have choices: agents optimized for specific frameworks, agents trained on your company's patterns, agents that cost less or run locally.

The immediate workflow change with Junie is autonomy. Instead of writing code yourself with AI suggestions, you describe what you want and the agent builds it. Need to split a monolithic controller into clean service classes? Prompt Junie. Want to add logging to every method in a namespace? Junie handles it. Need to rename a concept across 50 files and update all the tests? Done. This isn't pair programming — it's delegation.

The Git integration is underrated. Junie can stage changes, write commit messages, create branches, and push to remote. If you're doing feature work that touches multiple files, you can prompt "commit these changes with a descriptive message" and move on. No context switching to the terminal. No manually staging files. The agent understands what changed and why because it made the changes.

The real shift happens when the Agent Registry goes live. Imagine you're working on a legacy .NET Framework project that Copilot struggles with. You find an agent in the registry that's specifically trained on pre-.NET Core patterns. Install it, switch to it for that project, switch back to Junie for modern work. Or your company builds an in-house agent trained on your architecture standards. Deploy it to the team through ACP. Everyone gets consistent AI assistance that actually understands your codebase conventions.

Try It Yourself

Download the EAP from JetBrains' ReSharper page. Installation is free. Using Junie requires either a JetBrains AI subscription or activating the free trial (requires a card for fraud prevention, but you won't be charged).

Once installed, click "Try Junie" in the IDE to open the AI Assistant tool window. Your first prompt triggers a component download — adds a few seconds. After that, you're live. Try these prompts to see what autonomous agents can do:

• "Refactor this class to use dependency injection instead of static methods"
• "Add XML documentation comments to all public methods in this file"
• "Create a new feature branch called 'add-logging' and add structured logging to these services"
• "Explain what this LINQ query does and suggest a more readable version"

Switch models in Extensions → ReSharper → Options → AI Assistant → Junie. Different models have different strengths — GPT-4 for complex reasoning, Claude for large context windows. Test which works best for your tasks.

The Bottom Line

Use this if you're a .NET developer tired of being locked into GitHub Copilot, or if you want an AI agent that actually refactors code instead of just suggesting completions. The ACP integration is early but functional. Junie proves the concept works. When the Agent Registry launches, ReSharper becomes the only major .NET IDE where you control which AI agents run.

Skip it if you're happy with Copilot's autocomplete model and don't need autonomous refactoring or multi-agent flexibility. This EAP is rough around the edges — solution-wide context only, basic UI, no deep ReSharper integration yet. If you need polish, wait for the next preview.

The real opportunity here isn't Junie — it's the ACP ecosystem JetBrains is building. Once third-party agents can plug into ReSharper through a standard protocol, the AI coding landscape in Visual Studio changes completely. No more vendor lock-in. No more waiting for your IDE vendor to support the model you want. Just install the agent that solves your problem and get back to shipping code. That's worth paying attention to.

Source: Junie