VS Code 1.146: An Inbox to Watch Your Agent Sessions, and the Local Harness Gets Three Months to Live
VS Code 1.146 Stable shipped November 11: Inbox mode gathers sessions that need you, chat windows keep parallel threads from losing context, model comparison lets agents run evaluations, and permissions get finer while the sandbox hides secrets. But read the countdown first: the Local harness retires in February 2027.

Once agent sessions multiply, the editor learns the inbox first
On November 11, Microsoft released Visual Studio Code 1.146 Stable. If this update had to be summed up in one sentence, it would be this: once your agent sessions grow from one or two to a whole pile, the editor has to learn how to help you manage them. The most visible new feature is Inbox mode, which gathers every session that needs your attention across all your projects into one view — running, ready to merge, or safe to set aside, each in its own group. Alongside chat windows, model comparison, and a round of security tightening, 1.146 is not about one flashy feature but a whole system for managing multi-agent workflows. And behind the new features sits a decision with a countdown attached: the old Local harness is now deprecated and will be removed in February 2027, leaving three months to migrate.

First, the backdrop. VS Code 1.143 had already made the Copilot harness the default for new sessions; 1.146 continues in that direction. The harness is unified, sessions are multiplying, and the management tools have to catch up. Inbox mode, chat windows, and inline actions in the sessions list are three answers to the same problem: when sessions multiply, people lose track. Microsoft's answer is not to make you open fewer sessions but to give you an inbox-style workbench — the important ones float up, the rest wait, and the finished ones wait for you to merge them.
Note that many of these features still carry experimental or preview labels: Inbox mode is experimental and off by default; chat windows are a preview, off by default in Stable and on by default in Insiders; agent-run evaluations inside model comparison are experimental too. Read the status in parentheses before the feature name, and do not plan a workflow around a preview as if it were final.
Inbox mode: gathering everything that "needs you" in one place
Inbox mode is the headline feature of 1.146, and it solves a very specific pain: agents run in the background, and after a while you no longer know which session is waiting on you. Previously you had to dig through workspaces one by one. Now, enable the sessions.list.inboxEnabled setting, then choose Grouping > Inbox Mode in the Agents window's sessions list, and you get a single view: sessions that need your attention at the top, followed by the Working, Ready to merge, On hold, and Done groups. The release notes put it plainly: one view of what needs your attention, what is still running, and what is ready to merge.
Its actions are inbox-like, too. If a session can wait, use Dismiss from Inbox, Put on Hold, or Snooze to set it aside, and Undo if you change your mind; to archive it, select Mark Session as Done. One point of confusion is worth spelling out, and the release notes do: dismissing a session does not archive it — archiving requires the separate Mark as Done action. That distinction matters. Dismiss means "not now"; done means "this is finished." For anyone running several agent sessions at once, the distinction is not a detail; it is what makes the inbox trustworthy as a workbench.
The companion feature is inline actions in the sessions list, also experimental, controlled by sessions.list.inlineActions and off by default. Once enabled, you can fix failing checks and address review comments directly from the sessions list, without opening the session first. Each action sends a request to that session or nested session in the background, does not enable Agent Merge, and does not change action permissions. Inbox mode handles "seeing"; inline actions handle "doing." Together, the sessions list stops being a list and becomes a workbench.
My judgment is that the significance of Inbox mode lies less in the feature itself than in what it admits: agent programming is shifting from "one question, one answer" to "many threads running in parallel." One person watching three to five sessions at once is becoming normal. The editor competition is therefore extending from "whose model is smarter" to "who can let you manage more sessions without losing track." VS Code is not the first to build session management — third-party tools and rivals got there earlier — but once it ships inside the editor, the reach is different: everyone using VS Code gets it out of the box.
Chat windows: freeing conversations from the sidebar
The second feature worth unpacking is chat windows, a preview controlled by sessions.chatWindows.enabled. Until now, several chats crowded into a single Agents window, and switching between them meant losing sight of the one you were waiting on. With chat windows, you can open a chat in a window of its own and arrange the chat, its editors, and its terminals to fit the task: right-click a session or chat and choose Open in > New Window, or drag a chat out of the Agents window to create one; Move to Main Window brings it back. A chat window can hold several chats from one or more sessions, a new session can be started from the title bar, and chat windows reopen with their chats and editors after you restart VS Code.
The layout inside a window is freely arrangeable: drag a part by the grabber on the top edge of its card to move it, drag tabs between parts, place the terminal under the editor, under the chat, or full-width along the bottom, and switch between side-by-side and stacked layouts from Configure Layout in the title bar. In the stacked layout, Agents: Toggle Chat Conversation collapses the chat to only its input so the editor takes the rest of the window. If the layout gets messy, Developer: Reset Chat Window Layout restores it. The release notes include two demo videos, one for opening a window and one for rearranging it — a sign Microsoft sees this not as "adding a window" but as a change in how workspaces are organized.
Its practical value depends on how you work. If you habitually talk to one agent at a time, chat windows will not change much for you. But if you often run "build the feature," "fix the tests," and "check the docs" as three parallel threads, or wait on a long task in one session while handling something small in another, chat windows are essential. They do not solve "can I chat"; they solve "can I keep context while running several things at once." Preview-stage stability still needs verifying on your own machine, and more windows mean more memory and window-management overhead — something the release notes do not discuss, so test it yourself.
The biggest news is really a countdown: the Local harness retires in three months
Going by the feature list, Inbox mode and chat windows are the stars. But for long-term impact, the most important passage in 1.146 is the one about the harness switch. The Copilot harness is VS Code's latest agent harness and has been the default for new sessions since 1.143. It is built on the Copilot SDK, whose goal is to keep behavior, capabilities, and improvements consistent across Copilot products; sessions run through the Agent Host, so they keep running in the background independently of any editor window; and for organizations, it enforces managed sandbox and permission policies that the Local harness does not have. As of this release, the Local harness is deprecated and will be removed in three months, in February 2027.
The transition plan reads as follows. For the next three months you can still use the Local harness while you move your workflows, but it is functionally frozen: new features and improvements will focus on the Copilot harness and are not guaranteed to work on the Local harness. After three months, the Local harness will no longer be available, and the enterprise-managed setting vscode.temporaryDefaultToLocalHarness, introduced in 1.142 to keep the Local harness as the default, will be removed along with it. The official advice is to move completely to the Copilot harness before February 2027, and a Local-to-Copilot transition guide covers customization compatibility, continuing existing Local conversations, and organization rollout and verification. Problems should be filed as issues.
How do you confirm which harness you are on? The release notes give a direct check: look at the harness picker when you start a new session — if it says Copilot, you are on the new harness. The cover image is the official screenshot of that picker, listing Copilot, Local, Claude, Codex, and Cloud. Notably, the picker contains not only Microsoft's own Copilot but also Claude and Codex. The agent harness is becoming a multi-model entry point rather than just a Copilot shell — and the flip side of a unified harness is that model choice becomes more open: you can swap models inside one workflow without swapping editors.
Three months is neither long nor short. If you already use the Copilot harness as the default, this update barely affects you and nothing needs doing. If you still use the Local harness — especially teams whose enterprise policies pin it as the default — schedule the migration now. Customization compatibility, continuing old conversations, and staged enterprise rollout are exactly the items the transition guide names; do not leave them until January 2027. One reminder: what disappears in three months is the Local harness itself, not your conversation history — but whether old conversations continue working on the new harness depends on the details in the transition guide, so do not assume.
Model comparison: letting an agent run the evaluation for you
Model comparison (Compare Models) is another preview feature in 1.146 worth discussing. The idea: send the same prompt to several models, have a judge model evaluate the results, and use a synthesizer to combine their strengths. This release makes comparisons easier to configure, organize, and automate. First, a judge and synthesizer can now be added for chat-only responses without selecting a workspace; pressing Synthesize creates a new chat without changing the original attempts. Second, Copilot Fusion and its supported effort tiers can be selected for an attempt, the judge, or the synthesizer. Third, an experimental agent-run evaluation option — enable sessions.chat.compareAgents.tools.enabled — lets agents discover models, launch comparisons, read results and conversation references, and summarize findings across scenarios.
Pay attention to the permission boundary here: the agent-run tools are off by default and require Compare Models to be enabled first; disabling them still leaves manual comparisons available. Microsoft built "let an agent run evaluations for you" as a two-layer switch rather than an all-or-nothing toggle. That is the responsible design — evaluations burn tokens and generate piles of intermediate results, so off-by-default is the right call. In daily development, the practical value of model comparison is selection: when GPT, Claude, and Gemini write different code for the same task, you used to rely on gut feeling; now you can run one comparison, get a structured verdict from the judge, and then decide which model becomes your default.
A splash of cold water is still warranted: the judge is itself a model, and its verdict is not necessarily reliable; code stitched together by a synthesizer may be stylistically inconsistent and still needs a human pass. Model comparison is a tool that helps you decide, not one that decides for you. Use it as a reference for selection, not as the final answer.
Security tightening: finer permissions, hidden secrets
Version 1.146 does two solid things on security. First, permission prompts got more granular. The Copilot harness used to suggest overly broad tool-level allowances for operations like web fetches, terminal commands, and file reads — for example, fetching a URL defaulted to "Allow in this Session," which let the model access any URL for the rest of that session. Now, prompts default to allowances for specific domains, commands, and directories. It is a late but correct fix: when an agent runs commands on your behalf, "allow this once, this directory, this domain" and "allow the whole session to do anything" are risks of entirely different magnitudes.
Second, environment variable masking in the sandbox: the chat.agent.sandbox.credentials.envVars setting lets you configure which environment variables are masked in sandboxed sessions and hidden from agent tools. Sandboxed tools receive placeholders, and the real values are supplied only to approved HTTPS destinations. The official example is API_TOKEN: the real value is restored only in outgoing HTTPS requests to hosts listed in injectHosts — api.example.com in the example — while requests to other hosts keep the placeholder and never receive the actual value. Enter variable names, not secret values, in settings; on Windows, masking requires local-network access, and on macOS and Windows you need to trust the sandbox CA certificate for tools that require OS certificate trust. Separately, the chat input now shows "(sandbox enabled)" in its placeholder text, so you can see whether terminal sandboxing is on without opening the Permissions menu; the placeholder stays in sync as you switch chats or change the setting.
Taken together, both changes point in one direction: agent permissions are moving from coarse to fine-grained. It used to be that you handed an agent a key and trusted it to open the right doors; now authorization is per domain, per directory, per destination host, and secrets are hidden by default, restored only at approved exits. For vibe developers, that is a directly useful change: with the sandbox and fine-grained permissions on, the damage is capped when an agent wanders off, reads the wrong thing, or sends something to the wrong place. The cost is more prompts — you will click "allow" a few extra times the first time you use something — a normal trade-off between safety and convenience, which the release notes do not hide.
Other changes worth noting
Beyond the headline items, 1.146 has several smaller but solid updates. On MCP, this release adds support for SEP-2640, letting MCP servers automatically provide skills to the model (Skills over MCP), a preview controlled by chat.agentHost.mcpSkills.enabled. The first time you connect to an MCP server that provides skills, you are asked to allow them into your model context, and afterward they appear on the Skills tab of the Agent Customizations editor. Canvases improved as well: canvas extensions in Copilot harness sessions ask for approval before initializing privileged capabilities such as hooks; canvas menus distinguish Running canvases from Available ones; returning to an inactive Copilot harness session restores its canvases without sending another message; and while a canvas provider restarts, the last canvas image stays visible with a reconnecting indicator.
There is also a practical handoff feature: you can now run a session in the GitHub Copilot CLI outside VS Code and move it into VS Code to keep going. Enter /code in the CLI — or /code-insiders for VS Code Insiders — the CLI exits, and VS Code opens the same session in the Chat view, keeping its conversation history, model and reasoning effort, mode, and permissions. To return to the CLI, run the copilot --resume command the CLI shows during handoff. It requires Copilot CLI 1.0.107 or later with experimental features turned on. Permissions that apply only to the CLI process, such as --allow-tool or approvals granted in the session, do not carry over, and the CLI lists them before handing off; if another Copilot CLI process still has the session open, VS Code asks before opening it.
On the enterprise side: Copilot sessions now follow VS Code's proxy configuration, including PAC auto-configuration and Kerberos authentication, when running locally, in WSL, or in a local Dev Container; organizations can set communication.support.url in enterprise-managed settings to direct blocked developers to their own help page, adding Contact Admin links to supported policy restrictions; and strictPluginOnlyCustomization, which already restricted standalone skills, agents, hooks, and MCP servers, now also blocks standalone canvas extensions, so administrators can require canvas extensions to come from eligible plugins. On editor experience: Mermaid 12 now renders diagrams in chat, Markdown previews, and notebooks; the Integrated Browser can copy the file:// address of a local HTML file. And one inconspicuous but important fix: agent edit metrics reported through GitHub Copilot usage metrics no longer count unchanged text between edits as newly added or deleted code, so the numbers in usage reports get more accurate — relevant, given that this site covered the October incident in which Copilot usage reports lost agent activity, traced to IDE attribution.
Should vibe developers upgrade right away
The short answer: yes, upgrade, but do not switch on every experimental feature at once. The core value of 1.146 is not any single feature; it is that the release treats "many agent sessions at once" as the default way of working — Inbox mode watches them, chat windows separate them, model comparison helps you choose between models, and tighter security caps the downside. If you already run several agent sessions in parallel, or are considering it, this update speaks directly to your pain points. The upgrade itself is frictionless: Stable is out, and Check for Updates will fetch it.
Two things should be done in order. First, confirm your harness: look at the harness picker when starting a new session and check that Copilot, not Local, is selected. If you are still on Local, schedule the migration now rather than waiting for February 2027. The transition guide is already available, and customization compatibility, continuing old conversations, and staged enterprise rollout are worth walking through ahead of time. Second, decide which experimental features to enable: Inbox mode and inline session actions are safe to try first; chat windows depend on how much you parallelize; agent-run evaluations inside model comparison are best run manually a few times to confirm the verdicts are trustworthy before handing them to an agent.
Zooming out, 1.146 and the Qwen Code 1.0 Preview released the same day point at the same trend: on both the terminal and the editor side, agent tools are treating the "harness" and "session management" as the next battleground. Qwen Code open-sources its harness and makes it embeddable; VS Code makes the Copilot harness the default and manages background sessions through the Agent Host. Different wording, same direction: the first half of the model race is nearly over, and the second half will be decided by whose foundation is steadier, whose sessions are managed better, and whose permissions are tightened more carefully. For people building products, that is also a reminder: when choosing a tool, do not only ask which model it connects to — ask how it manages sessions, how it manages permissions, and how it runs in the background.
A final judgment. VS Code 1.146 is not a version that dazzles at first sight; it is more of a "tidying the house" release, getting the infrastructure — session management, window organization, permission granularity — done properly, piece by piece. Updates like this do not trend on social media, but they decide whether the next year of coding with agents feels like daily firefighting or like having an inbox that watches things for you. The Local harness retirement in three months is the only item here with a hard deadline, and the only one that needs scheduling now. Everything else can be tried at leisure.
Verification guide: every core fact in this article comes from the official VS Code 1.146 release notes, 501 lines in total, headed with a release date of November 11, 2026, Stable. Inbox mode, chat windows, the Local harness deprecation and February 2027 removal, model comparison, permission prompt granularity, environment variable masking, MCP skills, the CLI session handoff, Canvases improvements, and the enterprise updates are all taken from that text, with setting names checked character by character. The cover image is the harness picker screenshot from the official release notes, showing the Copilot, Local, Claude, Codex, and Cloud options. This article covers a different version with different content from this site's October 14 article on VS Code 1.142 (Canvases preview, chats surviving directory moves); there is no overlap.
Comments (0)
Sources
Related articles
On 17 November 2026, Microsoft launched MAI Code 2 and Code 2 Flash: the larger model has 77 billion active parameters and a one-million-token context, averaging 63.2% across four benchmarks — close to GPT-6.1 Sol and Claude Opus 5.5 — at $0.309 per task. Read the three caveats first: promotional pricing, the lowest score of the three, and no long-horizon work.
On 11 November 2026, AWS open-sourced UAEF: adapters turn traces from LangGraph, LangChain, Strands and Bedrock AgentCore into one format, then 36 metrics across 7 dimensions score them, flagging regressions past 5%. The judge model is hardened too — scores must cite verbatim evidence, and never decide safety.
On 17 November 2026, Perplexity launched the Orchestrator API: one interface reaching OpenAI, Anthropic, Google, xAI and open-weight models such as GLM, Kimi and DeepSeek, billed at the answering model's published rate with no platform fee. When one provider fails, the same model retries on another deployment, and preview routing assigns requests to models by task.