If you have been searching for what changed in GitHub Copilot for Visual Studio Code in March 2026, the short answer is this:

GitHub and VS Code spent March turning Copilot from a chat sidebar into a more complete agent workspace.

The official GitHub roundup published on April 8, 2026 covers releases v1.111 through v1.115, which rolled out across March and early April. The headline features are easy to list: Autopilot in public preview, integrated browser debugging, image and video support in chat, and a new unified editor for chat customizations.

The more important story is how those pieces fit together.

This is not just a bundle of UI upgrades. It is a workflow update aimed at developers who want to stay inside VS Code while the agent reasons longer, uses more tools, debugs browser-based apps, and carries more project-specific instructions.

What GitHub highlighted on April 8, 2026

GitHub’s April 8, 2026 changelog for “GitHub Copilot in Visual Studio Code, March Releases” calls out four themes:

  • more control over how agents run
  • broader support for what agents can do
  • simpler ways to customize and troubleshoot agent behavior
  • a few adjacent productivity updates that make the IDE workflow smoother

That summary is accurate, but it compresses a meaningful product shift across five releases.

The practical timeline looks like this:

  • March 9, 2026 / VS Code 1.111: agent permissions and Autopilot (Preview) arrive in Stable release notes
  • March 18 / VS Code 1.112: integrated browser debugging ships with the new editor-browser debug type, and MCP server sandboxing arrives
  • March 25 / VS Code 1.113: the new Chat Customizations editor (Preview), thinking effort in the model picker, nested subagents, and image preview for chat attachments land
  • April 1 / VS Code 1.114: the image carousel adds video preview, #codebase becomes a simpler semantic-search tool, and /troubleshoot can inspect previous sessions
  • April 8 / VS Code 1.115: browser-agent tooling and background terminal handling get better, including improved long-running Playwright support and the new send_to_terminal tool for background sessions

Taken together, that is a bigger update than the single changelog headline suggests.

The biggest shift is that Copilot sessions can now run with much less friction

The most important release in the bundle is probably VS Code 1.111.

That release introduced a permissions picker with three modes:

  • Default Approvals
  • Bypass Approvals
  • Autopilot (Preview)

According to the official release notes, Autopilot can auto-approve tool calls, retry on errors, auto-respond to questions, and keep working until the task is complete. The warning in the same release notes matters too: these higher-autonomy modes bypass manual approval prompts, including for file edits, terminal commands, and external tool calls.

That combination tells you how GitHub wants Copilot in VS Code to evolve.

This is no longer just “ask a question, get an answer.” It is increasingly a controlled agent runtime inside the editor, with explicit knobs for how autonomous the session should be.

If that broader agent direction is what you care about, this post fits next to our earlier coverage of GitHub Multi-Agent Workflow in 2026, GitHub Copilot CLI BYOK and Local Models, and GitHub Copilot Cloud Agent April 2026 Update.

Integrated browser debugging is one of the most practical additions

The feature with the clearest day-to-day developer value is integrated browser debugging in VS Code 1.112.

VS Code says the integrated browser can now start debug sessions directly inside the editor, letting you interact with a web app, set breakpoints, step through code, and inspect variables without leaving VS Code. The release also adds a new editor-browser debug type that supports both Launch and Attach configurations and works with many existing chrome and msedge setups.

This matters because agentic coding tools get more useful when the debug loop is close to the edit loop.

If your workflow involves frontend fixes, browser-based testing, or tool-driven debugging, keeping the browser inside the same surface as chat, terminals, breakpoints, and code review reduces a lot of context switching. It also makes the later March and April agent improvements more valuable, because the agent is not just editing files. It is operating in a richer execution environment.

GitHub’s April 8 roundup highlights this for a reason. It is one of the clearest examples of Copilot inside VS Code becoming an actual developer workspace, not just a model wrapper.

The new customization editor fixes a real adoption problem

One of the more underrated updates came in VS Code 1.113 with the Chat Customizations editor (Preview).

The release notes say the new editor centralizes:

  • custom instructions
  • prompt files
  • custom agents
  • agent skills
  • MCP servers and plugins via marketplace browsing

That sounds like setup plumbing. It is more important than that.

As AI tooling gets more configurable, the weak point often becomes discoverability and maintenance. Teams end up with scattered instruction files, half-documented agents, and unclear plugin setup. A single editor for these pieces is not flashy, but it is exactly the kind of product work that makes advanced workflows more usable beyond early adopters.

The same release also moved thinking effort into the model picker for reasoning models like Claude Sonnet 4.6 and GPT-5.4, which is another sign that GitHub is trying to make advanced agent controls visible in the normal IDE flow instead of hiding them in settings.

Visual context in chat is finally becoming first-class

March also improved how Copilot handles images and videos in chat.

In VS Code 1.113, image attachments got a fuller viewer with navigation, grouping by conversation turn, and zoom and pan support. In VS Code 1.114, that same carousel added video preview, so chat attachments are no longer limited to static screenshots.

This matters more than it sounds.

The agent workflow in modern IDEs increasingly depends on visual context:

  • UI regressions
  • browser screenshots
  • generated images
  • quick recordings of interaction flows

If the review surface for that context is awkward, the whole loop slows down. Better image and video handling does not make headlines the way model launches do, but it does make the product more credible for real frontend and debugging workflows.

Another useful change arrived in VS Code 1.114.

VS Code says the #codebase tool is now focused purely on semantic search, and that developers no longer have to think about managing separate local and remote indexes. The release notes describe a simpler model where the codebase is either semantically indexed or it is not, while the indexing details are handled behind the scenes.

That is a good product decision.

One persistent problem with agentic dev tools is that users are expected to understand too much about retrieval internals. A semantic-search tool is most useful when it feels boring and dependable. This update moves in that direction.

It also fits a broader pattern: GitHub is making Copilot more agentic while trying to hide the configuration complexity that usually comes with that power.

Troubleshooting and sandboxing show the platform is maturing

Two other March updates are worth paying attention to if you care about serious adoption rather than demo value.

First, VS Code 1.112 added MCP server sandboxing, which lets locally running MCP servers operate with restricted file and network access. That is the kind of feature platform and security-conscious teams will care about immediately.

Second, VS Code 1.114 expanded /troubleshoot so it can analyze previous chat sessions, not just the current one. That matters because debugging agent behavior is easier when you can inspect what happened after the fact instead of trying to reproduce it live.

These are not glamour features. They are platform features.

And platform features are often what separate a promising AI tool from a durable one.

What this means for developers evaluating Copilot in VS Code

The cleanest way to read the March release bundle is this:

GitHub is making Copilot in VS Code more autonomous, more inspectable, and more capable inside real development loops.

That matters if you want:

  • more autonomous sessions without leaving the IDE
  • browser debugging tied directly into the coding workflow
  • richer project-level customization for agents, skills, MCP servers, and plugins
  • stronger semantic search and better troubleshooting
  • better support for image and video context in chat

It matters less if your use case is still mostly autocomplete plus occasional chat questions. But if you are trying to decide whether Copilot in VS Code is becoming a credible agent workspace for day-to-day development, March 2026 is one of the clearest signs that the answer is increasingly yes, with guardrails.

That last part still matters. Autopilot’s own release notes explicitly warn about the security implications of bypassing approvals for edits, terminal commands, and external tool calls. So this is not a story about full trust. It is a story about better operator control over stronger agents.

That is also why this release bundle fits the larger trend we covered in AI Coding Agents Need Guardrails, Not More Autonomy. The market does not just need smarter models. It needs smarter boundaries, better review surfaces, and less friction in the handoff between human and agent.

Bottom line

The April 8, 2026 GitHub roundup for Copilot in VS Code matters because it packages several smaller releases into one clearer product signal.

Across VS Code 1.111 to 1.115, GitHub and Microsoft improved autonomy controls, browser-native debugging, chat customization, semantic search, visual review, and troubleshooting. None of those features alone is the whole story.

Together, they make GitHub Copilot in Visual Studio Code look much more like a serious agent-native IDE surface than it did a month earlier.

Sources