Last week, Visual Studio shipped its April update (18.5), and the theme is clear: the IDE is evolving from a text editor with AI suggestions into an agent orchestrator. Cloud agents now launch directly from the IDE, custom agents travel with you across projects, and IntelliSense finally stops fighting Copilot for screen space. If you’ve been waiting for Visual Studio to feel less like “Copilot bolted on” and more like “AI-first tooling,” this is the update that changes the trajectory.
Cloud Agents: Offload Work Without Leaving the IDE
The headline feature is cloud agent integration. Previously, if you wanted to use GitHub’s cloud coding agent, you opened a browser, navigated to your repo, and started a session. Now you do it directly from Visual Studio.
Here’s the workflow: Open Copilot Chat, select Cloud from the agent picker, and describe the task. The cloud agent asks permission to create a GitHub issue, then spins up a remote session on GitHub’s infrastructure to implement the fix and open a pull request. You can close Visual Studio entirely and come back later—when the PR is ready, you get a notification with options to view or open in browser.
From the April update announcement:
Cloud agents run on remote infrastructure for scalable, isolated execution, and you can now start new sessions directly from Visual Studio. This is a different way of working that frees you up to focus on the parts of your project that need your full attention.
Why this matters: Cloud agents are expensive to run. They require compute, sandboxing, and orchestration. By integrating them directly into Visual Studio, Microsoft is betting that developers want to delegate lower-value tasks (bug fixes, boilerplate, dependency updates) while staying focused on architecture and complex features. This is the future of agentic development—not replacing developers, but letting them focus on the work that actually requires human judgment.
The current implementation is powered by Copilot’s coding agent and requires a GitHub repo with permissions to create issues. It’s early, but the direction is right. I’m watching to see how this evolves when multiple cloud agents compete for the same task, or when agents need to coordinate across repos.
User-Level Custom Agents: Your Workflow, Every Project
Last month, Visual Studio introduced custom agents via .agent.md files in your repository. This update extends that with user-level agents stored in %USERPROFILE%/.github/agents/ by default. These agents travel with you across all projects.
Why this is a big deal: Repository-level agents are great for team conventions—“run our linter,” “follow our API guidelines,” “query our internal docs.” But user-level agents are for your workflow. Maybe you always want a “security review” agent that checks for credential leaks. Or a “migration helper” that converts legacy patterns to modern equivalents. Or a “performance profiler” that suggests optimizations based on your coding patterns.
The GitHub Changelog confirms:
User-level agents are stored in
%USERPROFILE%/.github/agents/by default. You can change this location in Tools > Options > GitHub > Copilot > Copilot Chat > Custom agents user directory.
Creating new agents is easier now too—click the + button in the agent picker and follow the prompts. Everything you could do with repository-based agents still works: workspace awareness, code understanding, tools, model selection, and MCP connections to external knowledge sources like internal documentation, APIs, and databases.
The community is already sharing agent configurations on the awesome-copilot repository. I expect we’ll see a marketplace for custom agents within six months—something like VS Code extensions, but for agentic workflows.
IntelliSense vs. Copilot: The Priority Fight Is Over
If you’ve used Visual Studio with Copilot, you’ve experienced this: IntelliSense pops up with a completion list, Copilot shows a multi-line suggestion, and suddenly you’re trying to parse two overlapping UIs. It’s cognitively noisy, and it slows you down.
The April update fixes this. When IntelliSense is active, Visual Studio temporarily suppresses Copilot completions. After you dismiss or commit the IntelliSense selection, Copilot resumes automatically. This behavior is enabled by default—just update and code as you normally do.
From the Visual Studio blog:
When IntelliSense is active, Visual Studio temporarily suppresses Copilot completions so you can focus on your current selection.
This seems obvious in hindsight, but it took Microsoft 18+ months to ship. The reason? IntelliSense and Copilot run in different subsystems. IntelliSense is fast, synchronous, and language-server-backed. Copilot is async, model-driven, and latency-sensitive. Coordinating them without breaking either experience required real engineering work.
The result is subtle but meaningful. Your editor feels less like two tools competing for attention and more like one integrated experience. This is the kind of polish that doesn’t show up in release notes but compounds over time.
C++ Gets Language-Aware Agent Tools (GA)
For C++ developers, the April update brings C++ Code Editing Tools for GitHub Copilot agent mode to general availability by default. These tools give Copilot language-aware navigation of your C++ codebase, including:
get_symbol_call_hierarchy— trace function calls across translation unitsget_symbol_class_hierarchy— map class inheritance and usage relationships
Previously, when you asked Copilot to refactor a C++ function, it guessed from text patterns. Now it sees your class hierarchy and call graph. The difference is like asking someone to reorganize a warehouse by looking at photos versus giving them a floor plan and inventory system.
This only works with AI models that support tool-calling (check the model comparison page for compatibility). If you work with large C++ codebases, these tools make a real difference—especially for cross-file refactors that span multiple headers and implementation files.
Customizable Copilot Keyboard Shortcuts
Finally, a quality-of-life improvement that power users will appreciate: you can now customize the keyboard shortcuts for accepting Copilot inline suggestions. Want to change the key for accepting a full suggestion, the next word, or the next line? It’s all configurable in Tools > Options > Environment > Keyboard.
The relevant commands are:
Edit.AcceptSuggestion— accept the full suggestionEdit.AcceptNextWordInSuggestion— accept just the next wordEdit.AcceptNextLineInSuggestion— accept just the next line
Your new shortcut appears throughout the editor hint bar, so you always know which key to press. Small detail, but this is the kind of flexibility that makes tools feel like yours instead of someone else’s.
The Bottom Line
Visual Studio’s April update is about infrastructure for agentic workflows. Cloud agents handle background tasks on remote infrastructure. User-level custom agents codify your personal workflow. IntelliSense and Copilot coordinate instead of competing. C++ agents have semantic understanding, not just text matching.
None of these features are revolutionary on their own. But together, they signal a shift: Visual Studio is becoming a platform for orchestrating multiple AI agents—some running locally, some in the cloud, some built by Microsoft, some built by you. That’s the future of IDEs. Not one AI assistant. An ecosystem of specialized agents, each doing what it’s good at, all coordinated through a single interface.
If you’re still on Visual Studio 2022 stable, consider trying Visual Studio 2026 to experience these features. The pace of AI integration is accelerating, and the monthly release cadence Microsoft announced in the 17.14 launch is starting to show results. The gap between “AI suggestions” and “AI orchestration” is closing fast.