Ever updated VS Code, opened a dozen tabs to figure out "wait, what actually changed?", and given up halfway through? Yeah, me too.

VS Code 1.125 landed on June 17, 2026, and this time the changelog is actually worth your coffee break. There's a browser built right into your editor that can now search the web and reach into remote machines, you finally get to decide when your extensions update instead of being surprised mid-debug session, and IT admins get a much easier way to roll out Copilot settings across a whole company.

Let's break down what's new, why it matters, and how to actually use it. 👀

What Is VS Code 1.125?

If you're new here: Visual Studio Code is the free code editor made by Microsoft that most developers use every single day. Think of it like your workshop — it's where you write code, fix bugs, and build whatever you're working on.

Every few weeks, the VS Code team ships an update. Sometimes it's small polish, sometimes it's a feature that changes your daily workflow. Version 1.125 is one of the bigger ones, with real improvements to the agent experience, the language model picker, the integrated browser, and how extensions update themselves.

Think of it like your phone getting a software update — except instead of just fixing battery drain, it sometimes hands you a whole new tool you didn't know you needed.

Why This Update Matters

A code editor isn't just where you type. It's where you search docs, test APIs, debug remote servers, manage extensions, and (if you're on a team) follow company policy without it getting in your way.

1.125 touches all of that:

• You can now search the web directly inside VS Code's browser instead of alt-tabbing to Chrome fifty times a day.
• You get control over when extensions update, so a risky update doesn't drop in the middle of a live demo.
• Teams using Copilot get centralized policy management, which makes life easier for admins and more predictable for developers.

None of this is flashy AI magic. It's the kind of "small friction removed" update that quietly makes your day smoother — and those add up.

Benefits with Real-Life Examples 💡

1. Web search right in the integrated browser

Setting: workbench.browser.searchEngine

You can now type a query straight into the integrated browser's address bar, and it searches using your configured search engine — just like a normal browser tab.

Real-life example: You're deep in a function, need to quickly check a Stack Overflow answer or MDN doc, and instead of switching windows and losing your train of thought, you just search right there in VS Code. Small thing, but it keeps you "in the zone."

2. Browse over remote connections (Preview)

Setting: workbench.browser.enableRemoteProxy

When you're working in a remote workspace (like a dev container or remote SSH server), the integrated browser can now proxy your web traffic through that remote connection. That means you can securely reach ports or internal services that are only visible from the remote machine.

Real-life example: You're running a local dashboard on a remote dev server at port 5000. Normally that's invisible to your laptop's browser. Now, with this preview setting on, VS Code can reach it directly. It's still labeled "preview," so expect a few rough edges — but it solves a genuinely annoying problem.

3. Better port handling for agents

If you've forwarded a port in a remote workspace, agents previously could fumble trying to open the browser because the port number didn't match. Now, when an agent requests a forwarded port, VS Code rewrites the URL automatically and lets the agent know. Less confusion, fewer "why isn't this loading" moments.

4. Install model providers straight from the Language Models editor

Extensions can bring their own AI model providers beyond the usual Bring Your Own Key (BYOK) setup. Before, you had to already know the right tag to search for in the Extensions view (language-models — now you know 😄).

Now there's an Install Model Providers button right in the Language Models editor. Click it, and it opens the Extensions view already filtered to relevant extensions. Once installed, the new models just show up in your model picker alongside everything else.

Real-life example: You hear about a new model provider extension from a colleague but don't remember the exact search term. Now you don't need to — the button does the filtering for you.

5. Configurable extension auto-update delay

Setting: extensions.autoUpdateDelay

This builds on the delayed auto-update feature from the previous release. You can now set, in hours, how long VS Code waits before it installs an extension update. By default, it's two hours.

Real-life example: An extension you rely on pushes a buggy update. With a delay configured, you (or your team) have a window to spot the problem before it lands on every machine. It's a small safety net that costs nothing to set up.

6. Simplified auto-update setting

Setting: extensions.autoUpdate

The setting is now just on or off — no more juggling true, false, onlyEnabledExtensions, and delayed. Existing values migrate automatically. One useful behavior to know: when auto-update is on, only enabled extensions get updated. Disabled ones update the next time you turn them back on.

7. Track your Copilot additional spend

The Copilot status dashboard now shows what percentage of your additional spend budget you've used. If you're on a usage-based plan, you can glance at this before you accidentally blow past your limit.

Real-life example: You're mid-sprint, leaning on Copilot heavily, and instead of getting surprised by a bill, you check the dashboard and see you're at 80% of your extra budget. Now you can pace yourself (or ask finance for more budget, no judgment).

8. Native MDM delivery for managed Copilot settings

For teams: admins can now push Copilot policies through native device management (MDM) on Windows and macOS, not just through the account-based settings file. This means policy can be enforced at the device level, without needing every developer to sign in first.

Real-life example: A company wants to disable a certain Copilot feature org-wide for compliance reasons. IT can now push that through the same MDM tooling they already use for everything else — no extra sign-in step required from each developer, and the setting shows up as policy-enforced and locked in VS Code.

9. Language Server Protocol updated to 3.18

If you build language servers, you can now use protocol version 3.18, with vscode-languageclient@10.0.0 and vscode-languageserver@10.0.0 available as the matching client and server packages. Check the changelog for the full list of additions and breaking changes before upgrading.

Auto-Update: Before vs After 1.125

	Before 1.125	After 1.125
Update timing control	Limited delay options, confusing setting values	Clean on/off toggle plus a configurable delay in hours
Disabled extensions	Could still get updated in some cases	Only update when you re-enable them
Admin policy control	Account-based settings file only	Account-based file or native MDM on Windows/macOS

This isn't a dramatic before-and-after — it's VS Code quietly removing rough edges. But if you've ever been bitten by a surprise extension update, you'll appreciate it.

Best Tips for Using 1.125

• Set a sensible auto-update delay. Two hours is the default, but if you work on a critical project, consider bumping it up so you have time to notice problems before they hit your machine.
• Try the integrated browser's web search before reaching for Chrome. It's a tiny habit change that keeps you focused.
• If you're on a remote workspace often, turn on workbench.browser.enableRemoteProxy and see if it saves you from manual port-forwarding gymnastics. Remember it's a preview feature, so report bugs if you hit any.
• Check your Copilot spend dashboard regularly if you're on a usage-based plan — don't wait for the bill to surprise you.
• If you manage a team, look into the new MDM delivery option for Copilot policies. It can simplify your rollout, especially if you already use device management tools.

Common Mistakes to Avoid

Assuming the remote browser proxy is production-ready. It's explicitly marked as a preview feature. Don't build a critical workflow around it yet — test it, expect occasional bugs, and report issues if you find them.

Forgetting that disabled extensions don't auto-update. If you disable an extension to "deal with it later" and forget about it, it'll be stuck on an old version until you re-enable it. Not a bug — just something to remember.

Ignoring the LSP version bump if you maintain a language server. Jumping to vscode-languageclient@10.0.0 without checking the changelog could introduce breaking changes you didn't expect. Read the notes first, then upgrade.

Mixing up the auto-update setting values after migration. If you had a custom value like onlyEnabledExtensions before, it gets migrated automatically — but it's worth double-checking your settings.json after updating, just so there are no surprises.

Wrapping Up

VS Code 1.125 isn't a flashy, headline-grabbing release — it's a "the little things finally got fixed" release. A browser that searches the web and reaches remote ports, extension updates you actually control, and Copilot policies that are easier for teams to manage. Put together, it's a smoother day-to-day experience for solo developers and teams alike.

If this rundown helped you understand what's new without digging through the full changelog yourself, that's exactly what it's here for. 😊

Want more developer-friendly breakdowns like this one? Check out more posts at hamidrazadev.com, and if this saved you some time, share it with a teammate who's still wondering why their extensions keep updating at the worst possible moment. Got thoughts on the new integrated browser features? Drop a comment — I'd love to hear how you're using them. 🔧