Skip to content

Visual Studio Code AI Features (1.110–1.121)

Visual Studio Code underwent a significant architectural shift in early 2026, evolving from a code editor with AI chat features into a platform built explicitly for agentic development. The period from version 1.110 (February 2026) through 1.120 (May 2026) — spanning roughly eleven weekly stable releases — represents the most concentrated wave of AI-centric changes in VS Code's history. GitHub Copilot shifted from an optional extension to a built-in capability, agents gained persistent memory and full session debugging, a dedicated multi-project Agents window graduated from Insiders to Stable, and the platform adopted a philosophy of developer-controlled autonomy from manual approval all the way to fully autonomous Autopilot mode.

The Release Cadence Shift

Starting with version 1.111 (March 2026), VS Code moved to a weekly stable release cadence rather than the previous monthly schedule. This accelerated the pace at which experimental features in VS Code Insiders could reach the broader developer base. Monthly changelogs covering Copilot features were consolidated and published on the GitHub Changelog alongside the VS Code release notes.

1.110 — February 2026: Agents Become Practical

The 1.110 release (shipped March 4, 2026) framed itself around making agents "practical for longer-running and more complex tasks." The headline additions:

  • Agent plugins: installable bundles of skills, tools, and hooks from the Extensions Marketplace. A single plugin install via the GitHub Copilot CLI is now automatically picked up by VS Code without a separate installation step.
  • Agentic browser tools: the agent can now drive the integrated browser, navigate to pages, interact with the running application, and verify its own output against rendered UI — closing the loop between code changes and visual result.
  • Session memory: plans and guidance persist across conversation turns within a session, so the agent retains context about what it has tried and what constraints were given.
  • Context compaction: conversation history is automatically compressed when the context window approaches its limit. A /compact slash command is also available for manual triggering.
  • Fork a chat session: creates a new, independent session that inherits the existing conversation history, enabling exploration of alternative approaches without discarding prior context.
  • Agent Debug panel (Preview): real-time visibility into chat events, system prompts, tool calls, and loaded customisations (prompt files, skills, hooks). Replaces the older Diagnostics chat action with a richer event hierarchy view.
  • Claude agents expanded: steering and queuing (send follow-up messages mid-execution), session renaming, /compact, /agents, /hooks slash commands, and getDiagnostics tool access.
  • Create agent customisations from chat: generate prompt files, skills, agents, and hooks directly within a conversation.

1.111–1.115 — March–April 2026: Autonomy and Browser Debugging

The weekly releases covering March and early April 2026 (published in the GitHub Changelog as the "March Releases" summary on April 8) introduced the biggest single shift: a spectrum of agent autonomy levels.

Agent Permission Levels

Level Behaviour
Default Copilot requests confirmation before running terminal commands and non-built-in tools.
Bypass Approvals Reduces confirmation prompts for lower-risk actions.
Autopilot Agent approves its own actions, auto-retries on errors, and runs until the task is complete. No manual approvals required. (Preview)

The permission level is set per session, applies to both local and Copilot CLI sessions, and is configurable from the Chat view.

Other Notable Additions (1.111–1.115)

  • Configurable thinking effort: reasoning models such as Claude Sonnet 4.6 and GPT-5.4 expose a thinking-effort slider directly in the model picker. The selected level persists across conversations.
  • Integrated browser debugging: set breakpoints, step through code, and inspect variables in the integrated browser without leaving VS Code. Uses a new editor-browser debug type compatible with existing Chrome/Edge configurations.
  • Nested subagents: subagents can invoke other subagents (chat.subagents.allowInvocationsFromSubagents), enabling complex multi-step decomposition workflows.
  • Images and video in chat: attach screenshots and videos to chat messages; agents can return images or recordings of changes.
  • Chat customisations editor (Preview): a unified interface for managing instructions, custom agents, skills, and plugins, with direct access to MCP and plugin marketplaces.
  • Sandbox MCP servers: local MCP servers run in a restricted sandbox limiting file and network access (macOS and Linux).
  • Agent-scoped hooks (Preview): attach pre/post-processing logic to specific custom agents via YAML frontmatter in .agent.md files.
  • Monorepo customisations: VS Code discovers instructions, agents, skills, and hooks from parent folders up to the repository root.
  • VS Code Agents app (Preview, Insiders in 1.115): a companion app for agent-native development. Parallelises tasks across multiple repositories in separate worktrees, with progress monitoring, inline diff review, and pull request creation — all reusing the existing customisation layer (prompt files, hooks, MCP servers).

1.116 — April 15, 2026: GitHub Copilot Goes Built-In

Version 1.116 made GitHub Copilot a built-in capability in VS Code — no separate GitHub Copilot Chat extension installation required. This is a significant distribution change: AI assistance is now available from a fresh VS Code install without any additional setup step.

Also in 1.116: - Agent Debug Log persistent: the debug panel now stores event logs for current and past agent sessions on disk. For teams building prompt files, custom agents, and hooks, agent behaviour can be inspected after the fact, not just watched live. - Thinking effort in Copilot CLI: select a reasoning model in the CLI language model picker and configure effort level to trade response quality vs. latency. - VS Code Agents app refinements: reasoning level selection, automatic plan mode handling, Files tab visible by default in Changes, welcome-page entry point.

1.117–1.119 (April–May 2026)

These weekly releases continued iterating on the Agents app and agent debugging. Specific release notes were not individually covered in the primary sources consulted for this page; the VS Code release notes at code.visualstudio.com/updates/v1_117 through v1_119 contain the authoritative detail.

1.120 — May 13, 2026: Agents Window Reaches Stable

Version 1.120 promoted the Agents window from Insiders to Stable (as a Preview in the standard release), and added several agent safety and context management features.

Agents Window

The Agents window is a separate window type alongside the main VS Code editor, purpose-built for orchestrating agents across multiple projects simultaneously. A single Agents window can manage parallel agent sessions in isolated worktrees across different repositories. It supports: - Choosing your agent harness (Copilot CLI, Claude, custom) - Running agents on remote machines - Per-window settings overrides - Preference persistence across sessions - Session navigation (arrow keys in title bar) - Upstream change sync before session start

BYOK Improvements

Bring Your Own Key (BYOK) models (from Anthropic, OpenAI, xAI, OpenRouter, custom Azure OpenAI endpoints) now show accurate token usage and context-window percentage in the Chat view — previously this always displayed 0%. Thinking effort is now configurable for BYOK reasoning models from the model picker.

Safety and Context Tools

  • Terminal output compression (chat.tools.compressOutput.enabled): large terminal outputs from git diff, npm install, and similar commands are compressed before being sent to the model. Unchanged diff hunks, lockfile diffs, and npm progress bars are stripped. A prepended banner tells the model what was filtered.
  • Command risk assessment (chat.tools.riskAssessment.enabled, experimental): terminal command confirmation dialogs now include an AI-generated risk badge (Safe / Caution / Review carefully) with a one-sentence explanation.
  • Plan mode improvements: inline plan editing in a dedicated control rather than a separate editor tab; clearer feedback mode indication.
  • Model picker by provider: models are grouped by provider with search; recently used models show provider name.

1.121 — May 2026: Agent Host Polish and Terminal Improvements

Version 1.121 (changes shipping May 11–15, 2026) is a focused release centred on two themes: hardening Agent Host connections for remote and SSH scenarios, and improving how the agent handles terminal output.

Agent Host Enhancements

Keyboard-interactive SSH authentication (May 11) adds support for SSH connections that require interactive challenge-response input — common in corporate environments with MFA or jump hosts. This fills a gap in the Agent Host SSH flow that previously blocked connections to a subset of enterprise servers.

Friendly tool names (May 15) replaces the raw internal identifiers shown in Agent Host session tool call logs with human-readable display names and enhanced input/output UI. This makes it easier to understand what an agent is doing at a glance without needing to decode tool identifiers.

Auto-approve picker (May 15) adds a UI element to Agent Host connections for approving tool calls in bulk, reducing the number of individual approval clicks during high-frequency agent sessions.

Pre-select workspace folder (May 14) means that when opening the Agents window from within a VS Code instance, the current workspace folder is automatically pre-selected. In practice this eliminates a manual step when launching an agent session from an already-open project.

Terminal Tool Improvements

Expanded terminal output compression (May 13) extends the compression that was introduced in 1.120 to cover a broader set of commands: test runners (pytest, jest, cargo test), build tools (tsc, cargo build, make), linters, Docker, and package managers. Unchanged diff hunks, lockfile diffs, and progress bars from these tools are now also stripped before being sent to the model.

Idle-silence timer for run_in_terminal (May 12) addresses long-running background commands. When a synchronous run_in_terminal call produces no output for a configurable period, it is automatically promoted to background execution instead of blocking the agent. This prevents agents from timing out while waiting for slow build or test commands.

VSCODE_AGENT environment variable (May 13) is set in the terminal whenever Copilot Chat runs a command, allowing scripts and build tools to detect they are running in an agent context and adjust behaviour accordingly.

Other

  • Add to Chat option in the integrated browser right-click menu (May 13) makes it one step easier to bring browser content into a chat conversation without switching to the Chat panel.
  • Auto-dispose background terminals (May 13): background terminals created by the chat agent are now automatically disposed once their command finishes, reducing terminal clutter.
  • Model picker: pin favourite models (May 13): frequently used models can be pinned to the top of the language model picker.
  • Multi-line shell command fixes in Agent Host terminal (May 12).

Key Architectural Themes (1.110–1.121)

Looking across the full release span, four themes dominate:

  1. Autonomy spectrum: VS Code moved from manual-approval-only to a configurable spectrum ending in full Autopilot. The permission model makes the degree of human-in-the-loop an explicit, per-session choice.
  2. Cross-project and multi-session management: the Agents window addresses a gap in the single-workspace model; it enables work patterns where multiple independent tasks run in parallel across separate repositories.
  3. Observability of agent behaviour: the Agent Debug panel and persistent session logs reflect a maturing understanding that debugging agent workflows requires the same tooling as debugging code — visibility into what happened, why, and in what order.
  4. Copilot as platform infrastructure: Copilot becoming built-in, BYOK reaching parity with built-in model accounting, and the customisation layer (hooks, skills, plugins, MCP) all point toward a model where AI capability is a layer of the IDE, not an add-on.

Continuous Refresh Note

VS Code ships weekly stable releases. This page covers 1.110–1.121 (February–May 2026). It should be refreshed each pipeline run to pick up new AI features. The release notes index is at https://code.visualstudio.com/updates; the GitHub Copilot changelog at https://github.blog/changelog/ covers cross-release summaries.

Changelog

2026-05-18 — Page created covering VS Code 1.110–1.120 (Type B sources: official VS Code release notes, GitHub Copilot changelog, VS Magazine coverage). Confidence 88. Covers 10 releases as requested; versions 1.117–1.119 have partial coverage pending individual release note review.