VS Code 1.106 Turns AI into an Operating System for Your Dev Workflow

Release: October 2025 (v1.106)
Source: Visual Studio Code Release Notes

Visual Studio Code 1.106 is the clearest signal yet that the editor is evolving into an AI-native control plane for software development. This release is less about flashy widgets and more about infrastructure: agent orchestration, security boundaries, enterprise policy, terminal safety, MCP governance, and open-sourced AI surfaces.

For developers, this means your editor is becoming the place where cloud agents, CLIs, LLMs, terminals, and org policies converge—with a growing focus on auditability, trust, and extensibility rather than opaque magic.

Agent HQ: VS Code as Command Center for Human–AI Collaboration

A first-class Agent Sessions view

As AI agents spread across your tooling—Copilot coding agents, Copilot CLI, OpenAI Codex, cloud missions—you need more than scattered chat panels. 1.106 introduces the Agent Sessions view, a central dashboard for every active agent session, local or remote.

Sessions are grouped by source (local, Copilot coding agent, CLI, etc.) and can be searched (Ctrl+Alt+F / ⌥⌘F). A consolidated mode moves Agent Sessions next to Chat in the Secondary Side Bar, inching VS Code closer to a true agent control surface. Not all capabilities are unified yet, but the intent is obvious: one place to see what every agent is doing to your code.

Plan agent: Structured tasks before codegen

The new plan agent formalizes a pattern senior engineers already follow: design before implementation.

Instead of immediately emitting code, the plan agent:

• Breaks complex tasks into explicit, reviewable steps.
• Asks clarifying questions.
• Produces an implementation plan you must approve before code changes.

You can then delegate execution to Copilot locally or to cloud agents. Crucially, teams can define custom plan agents—codifying internal workflows, architecture rules, or tool stacks via .agents.md under .github/agents. This shifts AI from ad-hoc prompting toward repeatable, reviewable process automation.

Cloud & CLI agents: One fabric, many surfaces

Cloud agent integration has been migrated into the Copilot Chat extension, tightening the loop with GitHub Mission Control and enabling cross-surface flows like launching cloud sessions from Agent HQ.

On the command line, initial Copilot CLI integration lets you:

• Start and resume CLI agent sessions in a chat editor or integrated terminal.
• Switch models, attach context, and track edits.

Delegation is now explicit: from chat or CLI (/delegate) you can hand tasks to cloud agents and see their edits surfaced as inline pills and in the working set view. The theme here is observability of AI actions—a requirement if agents are to touch production code at scale.

Custom Agents: Standardizing How AI Runs Across VS Code & Copilot

“Chat modes” are now formally custom agents, aligning VS Code with Copilot Cloud Agents and the MCP ecosystem.

Custom agent definition files:

• Live in .github/agents with .agents.md suffix.
• Support target metadata to optimize behavior for:
  • vscode (local tools, editor-integrated behavior), or
  • github-copilot (cloud agents, MCP tools, CLI integration).
• Accept attributes like name, argument-hint, tools, and handoffs for chaining workflows.

VS Code’s editor provides validation, completions, and actions for these files. The underlying idea: write once, run everywhere—your agent logic becomes portable across local VS Code, GitHub, and remote automation.

Open-Sourcing Inline Suggestions: Toward an Open AI Editor Stack

1.106 continues Microsoft’s gradual unbundling of Copilot into open infrastructure:

• Inline suggestions are now open source, merged into the vscode-copilot-chat repo.
• The classic GitHub Copilot and Copilot Chat extensions consolidate into a single extension powering chat, agents, and inline completions.
• The legacy Copilot extension will be deprecated by early 2026.

From an ecosystem standpoint, this matters more than it sounds:

• It gives transparency into how AI suggestions are wired into the editor.
• It lowers friction for alternative model providers to integrate in a first-class way.
• It sets precedent: the AI-native UX is infrastructure, not a black box.

Developers can temporarily opt-out of the unified experience with chat.extensionUnification.enabled, but the direction is clear.

Security, Trust, and Safer Automation at Scale

The more work you hand to agents, the more blast radius you create. 1.106 invests heavily in trust boundaries, especially around tools, MCP, and terminals.

Tool approvals & post-approval for external data

VS Code now supports post-approval for tools that fetch external data (including #fetch and MCP tools with openWorldHint). Data can be inspected before it is used in a prompt, mitigating prompt injection via remote content.

You can:

• Approve all tools from a given MCP server/extension at once.
• Manage pre- and post-approval centrally via updated UI.

This moves tool invocation closer to an allow-listed, auditable surface—a critical step for regulated environments.

Terminal tool: real parsing, less guesswork

The Copilot terminal tool gets a serious upgrade:

• Uses bash/PowerShell grammars instead of naive string splitting.
• Correctly handles complex command lines, pipes in strings, and structured syntax.
• Can detect file writes via redirection and, experimentally, block auto-approval via chat.tools.terminal.blockDetectedFileWrites.
• chat.tools.terminal.ignoreDefaultAutoApproveRules lets power users fully own the policy.
• Shell-specific descriptions plus PowerShell command rewriting reduce cross-shell failures.

Output handling is more deliberate:

• New chat.tools.terminal.outputLocation controls where results appear.
• You can inline terminal output in chat or reveal terminals on demand.
• Hidden chat terminals are discoverable so you don’t lose track of long-running processes.

This is VS Code treating shell execution as a governed resource, not a side effect.

MCP for organizations: Registry, policy, and OAuth hardening

For enterprises adopting Model Context Protocol:

• Org-managed MCP registries (via policies) define which servers are discoverable and runnable.
• VS Code enforces these via chat.mcp.gallery.serviceUrl and chat.mcp.access (marked as managed in settings).
• MCP servers can be installed per-workspace into .vscode/mcp.json for shareable, versioned configuration.

Authentication advances include:

• Client ID Metadata Document (CIMD) support for remote MCPs: a more scalable, standards-aligned OAuth flow than Dynamic Client Registration.
• Scope step-up via WWW-Authenticate, aligning with OAuth 2.0 best practices: tools request wider scopes only when needed.

The net effect: MCP is being treated as first-class, policy-driven infrastructure for orgs, not a hobbyist plugin.

Editor & Workflow Details That Matter in Practice

Beyond AI systems, 1.106 includes a series of sharp, developer-centric improvements.

Code editing & navigation

• Selectable deleted code in inline diffs: restore or reuse removed snippets without hacks.
• Go to Line upgrades: support for character offsets (::599, ::-100), negative columns, and better out-of-range handling—useful when tools report positions by offset.
• Copy diagnostic hover text: a small but impactful tweak for debugging and CI integration.
• Accent-insensitive command palette: more forgiving across locales.
• Advanced settings: powerful options are tagged and hidden by default, but discoverable (@tag:advanced, @id:), keeping UX clean for most while serving power users.

Terminal IntelliSense graduates

After a long preview, Terminal IntelliSense effectively becomes a default capability:

• Works for PowerShell, bash, zsh, fish.
• Suggests commands, paths, git options, and more.
• Highly tunable via terminal.integrated.suggest.* settings.
• Gains completions for copilot and azd CLIs and shows git commit messages.

This blurs the line between “shell” and “editor”—your terminal now behaves like an IDE surface rather than a blind TTY.

Source control & testing

• Graph view incoming/outgoing nodes expose divergence at a glance.
• Compare with..., including remote and merge base, tightens review flows.
• A new Repositories explorer (experimental) turns the repo list into a richer control surface for branches and tags.
• Test coverage navigation (next/previous uncovered line) makes closing coverage gaps mechanically easy.

Notebooks & accessibility

• Notebook search across cells using familiar navigation keys.
• Accessibility tweaks for chat, including better announcements and voice session defaults.

These are the kind of features that don’t headline keynotes but quietly shave minutes off daily workflows across large teams.

Python & Language Intelligence: More Opinionated, Less Friction

Python developers get a meaningful quality-of-life pass:

• Poetry path support in Python Environments extension (python.poetryPath).
• Smarter venv creation that reads both requirements.txt and dev-requirements.txt.
• Copilot Hover Summaries → docstring insertion: AI-generated documentation becomes a one-click structural part of your codebase.
• Localized summaries respect your editor language.
• Convert wildcard imports action in Pylance: from module import * becomes explicit imports with one command.
• Native .env support for dotenv-style configuration.

This set nudges teams toward cleaner imports, documented APIs, and reproducible environments, without adding ceremony.

Language Models Editor: Curating Your AI Stack

In VS Code Insiders, a Language Models editor previews what multi-model development might look like when it’s no longer theoretical.

You can:

• View all models from providers like Copilot, OpenAI, Anthropic, Azure, Google, Groq, Ollama, etc.
• Inspect context sizes, capabilities (tools, vision, agent), and metadata.
• Filter via @provider:, @capability:, and @visible: queries.
• Toggle which models appear in the chat model picker.
• Add models from installed providers without leaving the editor.

This UI acknowledges a reality for many teams in 2025: you don’t have a model, you have a fleet, and you need governance, not a dropdown.

Extension Authors: Richer Surfaces, Tighter Identity, Better UX

For extension developers, 1.106 opens more of VS Code’s UI and auth stack.

Key updates include:

• ID tokens in AuthenticationSession for identity-aware integrations.
• A new Git getRepositoryWorkspace API for mapping remotes to folders.
• View containers in the Secondary Side Bar via secondarySidebar contribution: place custom views next to Chat and Agent HQ for more integrated experiences.
• Proposed Quick Pick/Quick Input enhancements:
  • Toggle buttons in the input box.
  • Persistent prompts.
  • File-type icons via resourceUri.
• GitHub-style alert syntax for MarkdownString (supportAlertSyntax) and Markdown-enabled TreeItem labels, allowing clearer, more expressive in-editor UX.

Collectively, these push VS Code closer to a platform for building complex, multi-surface tools rather than isolated panels.

Automation as a First-Class Reviewer

In an under-the-radar but telling move, the VS Code team is experimenting with automated UX PR testing:

• Tag a PR with ~copilot-video-please.
• A workflow builds VS Code from that branch.
• Uses Copilot CLI + Playwright MCP to drive the UI, record a video, and produce a trace.

This is the same story as Agent HQ, terminal policies, and MCP controls: AI isn’t a novelty; it’s being wired into the engineering lifecycle—review, verification, governance.

Currently internal, but the pattern is one many organizations will likely mirror.

Why 1.106 Matters

VS Code 1.106 is not defined by a single headline feature. Its significance lies in the convergence:

• Agents are first-class citizens, with sessions observable, delegations explicit, and plans reviewable.
• AI wiring is moving into the open, via shared repos, unified extensions, and model-aware UIs.
• Security and policy are catching up—MCP registries, OAuth hardening, terminal parsing, tool approvals—so you can responsibly scale AI-assisted development.
• Core ergonomics (diffs, coverage nav, terminals, SCM graphs, Python workflows) continue to sharpen, ensuring the AI layer enhances rather than obscures craft.

For teams building serious systems in 2025, that combination is the real story: VS Code isn’t just adding AI features; it’s steadily becoming the operating system for human–AI software engineering.

Source: Official Visual Studio Code 1.106 release notes — https://code.visualstudio.com/updates/v1_106