VS Code has been on a fast-moving trajectory toward what Microsoft calls "agent-native development." The April 2026 releases — versions 1.115 and 1.116 — represented the most significant step yet: a standalone Companion App for parallel agent sessions, deeper terminal control, Model Context Protocol (MCP) server bridging to external agents, and Copilot CLI remote steering from any device. If you have not revisited your VS Code setup since late 2025, a lot has changed.

This guide covers what shipped, what it means for everyday development workflows, and how to get started with each capability today.

The VS Code Agents Companion App

The headline addition in v1.115 is the VS Code Agents companion app, currently in preview and available exclusively with VS Code Insiders. It is not a panel or sidebar inside the editor — it is a separate surface that runs alongside VS Code and is designed specifically for agent-native development.

The core premise is parallelism. Before this, running an agent session meant committing your editor to one task at a time. The companion app lets you kick off multiple agent sessions across different repositories simultaneously, each isolated in its own Git worktree. You can assign a feature to one agent, a bug fix to another, and a code review to a third — then monitor all three from a unified interface.

The monitoring side is genuinely useful: inline diff views, the ability to leave feedback mid-session, and one-click pull request creation without leaving the app. All of your existing VS Code customizations — custom instructions, prompt files, MCP servers, hooks, plugins — carry over automatically into the companion app. Nothing has to be reconfigured.

A second addition in v1.116 built on this foundation: sub-sessions. From any active agent session, you can now spawn child sessions for parallel research or code review. This is the kind of workflow that multi-agent frameworks have been promising at a library level; VS Code is beginning to bake it into the UI itself.

One important caveat: the companion app remains Insiders-only as of May 2026. If you are on the stable release, you get all the other agent mode improvements described below, but not the companion app UI.

Terminal Sessions: What Changed

Terminal interaction has been the persistent weak point in IDE-based agents. The agent could read terminal output when the terminal was in the foreground, but background terminals — the ones running long-lived processes, SSH sessions, or interactive scripts — were effectively out of reach.

V1.115 addressed this with a new send_to_terminal tool that lets the agent continue interacting with a terminal even after it has moved to the background. The practical example from Microsoft's own release notes captures the value precisely: if an SSH session times out waiting for a password prompt, the agent can now send the required input and complete the connection rather than stalling.

V1.116 extended this further. Terminal tools in the latest release work with foreground terminals too, giving agents the ability to read output from and send input to any terminal currently visible in the panel. Combined with background terminal notifications, agents can now track what is happening across your entire terminal landscape — not just the one they opened.

This matters most for workflows involving Docker builds, test runners, dev servers, and any interactive CLI that previously required manual babysitting between agent steps.

MCP Servers: Setup and Bridging

Model Context Protocol support in VS Code has matured considerably. The configuration approach has stabilized around mcp.json — not settings.json — with "servers" as the root key. You can open this file directly from the Command Palette with MCP: Open User Configuration.

The most significant change in the April releases is MCP server bridging. Previously, MCP servers you configured in VS Code were available only to agents running inside the editor itself. V1.116 changed that: MCP servers registered in VS Code are now bridged to Copilot CLI and Claude agents as well. If you have a GitHub MCP server or a database context server configured locally, those tools are now accessible to CLI agents running in terminal sessions without any additional setup.

Configuring an MCP Server

The basic structure in mcp.json looks like this:

{
  "servers": {
    "github": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-github"],
      "env": {
        "GITHUB_PERSONAL_ACCESS_TOKEN": "${env:GITHUB_TOKEN}"
      }
    }
  }
}

The Extensions view now has an MCP-specific gallery. Search for @mcp in the Extensions panel to browse available servers. Three servers worth starting with:

• GitHub MCP Server — zero configuration beyond a personal access token; provides repo search, file reads, PR creation
• Context7 — no API key required; resolves library documentation on demand
• Playwright MCP — maintained by Microsoft; gives agents browser automation capabilities

You can scope mcp.json per workspace or globally in your user config. Workspace-scoped configs are version-controllable, which is useful for team setups where everyone should have the same MCP server configuration.

Using MCP Tools in Agent Mode

Once servers are configured, the tools they expose appear automatically in agent mode. The agent can invoke them like any other built-in tool — no explicit tool-call syntax required from the user side. You can see which tools are available by opening Chat and viewing the tool list in the agent mode panel.

Copilot CLI Remote Sessions

The April 13, 2026 public preview of remote CLI session steering is the most operationally significant addition for developers who run long agent tasks. The workflow addresses a real problem: you kick off an agent task that will take 20–30 minutes, step away from your machine, and now you have no way to check or intervene.

With remote sessions, you run /remote on inside a Copilot CLI session. VS Code streams that session to GitHub.com in real time. You can then open GitHub on a browser or the GitHub Mobile app (beta required for mobile) and see exactly what the agent is doing — and send input to it.

The implementation is deliberately symmetric. Both your local terminal and the remote interface stay active. Copilot uses whichever response arrives first. That means you can steer from your phone without disconnecting the local session.

Two utility commands round out the feature:

• /keep-alive — prevents your machine from sleeping while a session is running remotely
• /remote off — ends the remote stream without closing the session

This is currently public preview, so expect the interface and available commands to evolve. But the capability — coordinating long-running agent work from any device — is now available to test.

GitHub Copilot Built-In

One quality-of-life change worth noting: as of v1.116, GitHub Copilot is built into VS Code. You no longer need to install the GitHub Copilot Chat extension separately to start using agent mode or chat features. For developers setting up a fresh VS Code install or onboarding a new team member, this eliminates one configuration step and one potential point of "why isn't agent mode showing up?" confusion.

The chat mode dropdown now presents Agent, Copilot, and any custom agents you have configured in a single, consistent place.

Agent Debug Logs

V1.116 also added persistent agent debug logs. The Agent Debug Log panel shows a chronological event log of every interaction during a chat session — which tools were called, what parameters were passed, and what the agent decided at each step. Crucially, these logs now persist across sessions and are stored locally on disk.

For anyone building custom agents or debugging why an agent took an unexpected path, this is a substantial quality-of-life improvement. You no longer have to reproduce the exact session to understand what happened.

Practical Guidance: Which Features to Enable First

Not all of these features need immediate adoption. Here is a practical prioritization:

Enable now (stable release users):

• Agent mode is available in stable — enable it via chat.agent.enabled in settings if you have not already
• Configure one or two MCP servers (mcp.json) to give agents access to your actual stack

Try in Insiders:

• The companion app is the most impactful feature for developers who regularly run multi-step tasks
• Sub-sessions are worth experimenting with for code review and parallel research workflows

Public preview — test with low-stakes tasks:

• Remote CLI sessions are functional but changing — good for long test runs or deployment monitoring, not for anything requiring precise intervention

Strengths
<ul>
  <li>Companion app brings real parallel agent execution to a mainstream IDE surface</li>
  <li>Terminal agent tools now cover both foreground and background terminals</li>
  <li>MCP bridging means one config works across VS Code, Copilot CLI, and Claude agents</li>
  <li>Remote session steering solves a real workflow problem for long-running tasks</li>
  <li>Debug logs persist — much easier to understand and reproduce agent behavior</li>
</ul>


Current Limitations
<ul>
  <li>Companion app is Insiders-only — stable users cannot access it yet</li>
  <li>Remote CLI sessions are preview, not GA — interface may change</li>
  <li>Parallel worktree sessions require Insiders; stable release gets agent mode but not the companion UI</li>
  <li>Mobile remote steering requires GitHub Mobile beta, not the released app</li>
</ul>

Common Questions

Q: Do I need GitHub Copilot paid plan to use agent mode?

Agent mode in VS Code requires an active GitHub Copilot subscription (Individual, Team, or Enterprise). The free tier includes limited Copilot completions but agent mode features require a paid plan as of May 2026. Claude Agent in the companion app follows its own billing through Anthropic.

Q: Can I use agent mode with models other than GPT-4o?

Yes. VS Code agent mode supports multiple models. In the Chat view, you can switch models using the model picker. As of April 2026, Claude 3.5 Sonnet, GPT-4o, and o3 are among the available options depending on your Copilot subscription tier. The companion app supports Claude Agent as a first-class participant alongside Copilot agents.

Q: How is mcp.json different from the MCP config in other tools?

VS Code uses mcp.json with a "servers" root key. This differs from Claude Desktop (claude_desktop_config.json, "mcpServers" key) and some other tools. If you are migrating an existing MCP setup, check the key names. The VS Code docs at code.visualstudio.com/docs/copilot/customization/mcp-servers have the current canonical format.

Q: Is the VS Code Agents companion app free to use?

The companion app itself is free, but the underlying agents (Copilot CLI, Claude Agent) follow their respective billing models. Copilot CLI usage counts against your Copilot premium request quota; Claude Agent usage is billed through Anthropic.

Q: What happens if I close VS Code while a remote session is running?

The Copilot CLI session continues running on your machine even if you close VS Code, because CLI sessions operate independently of the editor window. The remote stream at GitHub.com stays active as long as the CLI process is running. Use /keep-alive to prevent your machine from sleeping and cutting the session.

Key Takeaways

The April 2026 VS Code releases mark a shift from agent mode as a chat feature to agent mode as a first-class development workflow. The companion app, terminal control, MCP bridging, and remote sessions are all aimed at the same thing: making it practical to run multiple agents in parallel, leave them to work, check in from anywhere, and debug what happened.

For developers primarily on stable VS Code, the most immediate wins are enabling agent mode (if you haven't), configuring MCP servers for your stack, and using the persistent debug logs to understand agent behavior. The companion app and sub-sessions are worth tracking — they are likely to move to stable within a few release cycles given the cadence of the April updates.

Bottom Line

VS Code's April 2026 releases are the most substantive agentic update the editor has seen. The companion app moves parallel agent execution from a framework-level concept into a tool most developers can use without configuration overhead. MCP bridging is the quiet win — one config file, multiple agents. Worth upgrading to Insiders if you regularly run multi-step agent tasks.