Microsoft's latest Visual Studio Code release crosses a threshold that most developers haven't fully processed yet: the editor is no longer just a place where you write code. It's becoming the environment where autonomous agents write code while you supervise, redirect, and approve their work. VS Code 1.115 ships with a standalone companion application called VS Code Agents, and its existence reveals how quickly the assumptions underlying software development are shifting.
The new app isn't a plugin or an experimental feature tucked into settings. It's a separate application that launches from your operating system's app menu, designed specifically to manage multiple AI agent sessions running in parallel. Each session operates in its own isolated worktree, meaning you can have agents working on different repositories or branches simultaneously without their changes interfering with each other. This isn't about autocomplete anymore. This is infrastructure for delegating entire development tasks to machines.
Why a Separate App Matters More Than It Seems
The decision to ship VS Code Agents as a standalone application rather than integrating it into the main editor reveals Microsoft's architectural thinking. When you run multiple agent sessions, each potentially executing terminal commands, modifying files, and interacting with browsers, the resource overhead and complexity multiply quickly. A separate process boundary gives Microsoft room to optimize for agent workloads differently than human-driven editing sessions.
More importantly, it signals a conceptual separation. The main VS Code window remains your workspace for direct coding. The Agents app becomes your control center for supervised automation. You review diffs, leave feedback for agents, monitor progress across sessions, and submit pull requests—all from a unified interface designed around the assumption that you're managing work being done by non-human collaborators.
The app inherits your existing VS Code configuration automatically: themes, Model Context Protocol servers, custom instructions, prompt files, hooks, and plugins all carry over. That continuity matters because it means teams already invested in GitHub Copilot workflows can adopt the Agents app without rebuilding their toolchain. But it's currently only available through VS Code Insiders, Microsoft's preview channel, which means the company is still gathering feedback on how developers actually use multi-agent workflows in practice.
Browser Integration Gets Granular Visibility
The integrated browser improvements in this release focus on a problem that becomes acute when agents are doing the clicking: you need to know exactly what they're doing without watching every action in real time. Previous versions would log generic actions like "Clicked element in browser," which told you almost nothing useful when reviewing a session later. Now the tool call labels are specific: "Right-clicked header banner in Test Page," with a direct link to the browser tab where it happened.
This change addresses a trust problem inherent in agentic development. When a human clicks through a web interface, they have immediate visual feedback and can course-correct instantly. When an agent does it, you're trusting that it interpreted the page structure correctly and targeted the right element. Descriptive labels don't eliminate that trust gap, but they make it possible to audit agent behavior efficiently, which is essential for teams trying to figure out where an automated workflow went wrong.
The browser also handles long-running Playwright scripts more gracefully now. Scripts that take longer than five seconds return a deferred result that the agent can poll, rather than blocking or timing out. For developers running automated browser testing inside VS Code, this prevents sessions from failing unexpectedly when a test suite takes longer than the tool's original timeout window anticipated.
Terminal Interaction Finally Works in the Background
One of the more frustrating limitations in previous versions was that agents could only interact with foreground terminals. If a terminal session moved to the background—say, because it was waiting at an SSH password prompt and timed out—the agent lost the ability to send input. It could still read output, but it couldn't complete authentication or respond to interactive prompts. The session was effectively stuck.
The new `send_to_terminal` tool fixes this by allowing agents to send input to background terminals. That sounds like a minor technical detail until you consider how often development workflows involve SSH connections, Docker containers, or other interactive processes that don't complete instantly. An agent that can't handle background terminal interaction can't reliably execute deployment scripts, manage remote servers, or work with containerized development environments.
There's also an experimental setting—`chat.tools.terminal.backgroundNotifications`—that automatically notifies agents when a background terminal command finishes or requires input. Without this, agents had to poll terminal status manually, which is inefficient and introduces latency. With it, agents can respond to terminal events as they happen. It's opt-in for now, but this kind of event-driven interaction is likely to become standard as Microsoft refines the agent execution model.
The Infrastructure Play Behind the Features
What makes VS Code 1.115 significant isn't any single feature. It's the pattern across all of them: Microsoft is building the infrastructure layer that makes agent-driven development reliable enough for production use. Parallel session management, descriptive action logging, interactive background terminals, deferred script execution—these are the unglamorous capabilities that determine whether agentic workflows fail unpredictably or run consistently enough that teams can depend on them.
Mitch Ashley, VP and practice lead for software lifecycle engineering at The Futurum Group, frames it as an architectural shift: "Microsoft's VS Code 1.115 is aligning the editor's identity toward agent execution environment. The new VS Code Agents companion app delivers isolated worktrees and parallel session management, architecting the separation between concurrent agent workflows that production-scale agentic development requires."
He continues: "The supporting improvements, descriptive browser action labels, interactive background terminals, deferred script execution, apply the same logic: visibility and control must be embedded in agent workflows. Development platforms that build this governance infrastructure from the start set the ceiling for how much autonomous execution teams can safely run."
What Developers Should Watch For
The VS Code Agents preview is available now in VS Code Insiders, and Microsoft is actively soliciting feedback through GitHub issues. For teams already using GitHub Copilot agents, the companion app is worth testing, particularly if you're running into limitations with single-session workflows or finding it difficult to track what agents are doing across multiple tasks.
The broader question is how quickly this model of development becomes standard practice. Right now, most developers still think of AI assistance as autocomplete with extra steps. But when your editor ships with a separate application designed specifically to manage multiple autonomous agents working in parallel, the industry is signaling that the next phase isn't about better suggestions—it's about delegating entire tasks and learning to supervise machine collaborators effectively.
The technical improvements in this release are incremental, but they're incremental in a direction that fundamentally changes what a code editor is for. VS Code is becoming less of a text editor with smart features and more of a platform where humans and agents collaborate on software development, with the editor providing the infrastructure to make that collaboration legible, auditable, and reliable. Whether that's the future developers want is still an open question, but it's clearly the future Microsoft is building toward.