Latest Code Editors and IDEs Updates

• Mar 6, 2026

  • Date parsed from source:
    Mar 6, 2026
  • First seen by Releasebot:
    Mar 6, 2026
  

  Zed

  0.226.5

  Zed adds GPT-5.4 and GPT-5.4-pro models for OpenAI key users and fixes UI crash and usage-only event handling.

  • Added GPT-5.4 and GPT-5.4-pro as available models when using your own OpenAI API key. (#50858)

  • Fixed an error when OpenRouter returns a usage-only event with empty choices. (#50799)

  • Fixed a crash when opening the settings UI. (#50741)

  Original source Report a problem
• Mar 5, 2026

  • Date parsed from source:
    Mar 5, 2026
  • First seen by Releasebot:
    Mar 6, 2026
  

  Cursor

  Build agents that run automatically

  Cursor unveils Automations to run always-on agents triggered by Slack, Linear, GitHub, PagerDuty or custom webhooks. Agents spin up cloud sandboxes, learn over time, and cover security reviews, incident response, weekly digests, and more, turning code workflows into a factory.

  We're introducing Cursor Automations to build always-on agents.

  These agents run on schedules or are triggered by events like a sent Slack message, a newly created Linear issue, a merged GitHub PR, or a PagerDuty incident. In addition to these built-in integrations, you can configure your own custom events with webhooks.

  “I love that automations work for both quick wins and more complex workflows. I can schedule the obvious stuff in seconds, but I still have full flexibility to catch any webhook or plug into custom MCPs when I need to.”

  Trent Haines
  Software Engineer, Decagon

  Upgrading the software engineering pipeline

  With the rise of coding agents, every engineer is able to produce much more code. But code review, monitoring, and maintenance haven’t sped up to the same extent yet. At Cursor, we’ve been using automations to help scale these other parts of the development lifecycle.

  When invoked, the automated agent spins up a cloud sandbox, follows your instructions using the MCPs and models you've configured, and verifies its own output. Agents also have access to a memory tool that lets them learn from past runs and improve with repetition.

  As we’ve run more automated agents on our own codebase at Cursor over the past several weeks, two categories of automations have emerged.

  Review and monitoring

  Automations are great for reviewing changes. They can catch and fix everything from style nits and inconsistencies to security vulnerabilities and performance regressions.

  In fact, Bugbot is in many ways the original automation! It runs when a PR is opened or updated, gets triggered thousands of times a day, and has caught millions of bugs since we first launched it. Automations allow you to customize all kinds of review agents for different purposes. Here are three we use at Cursor:

  • Security review
    Our security review automation is triggered on every push to main. This way, the agent can work for longer to find more nuanced issues without blocking the PR. It audits the diff for security vulnerabilities, skips issues already discussed in the PR, and posts high-risk findings to Slack. This automation has caught multiple vulnerabilities and critical bugs at Cursor.

  • Agentic codeowners
    On every PR open or push, this automation classifies risk based on blast radius, complexity, and infrastructure impact. Low-risk PRs get auto-approved. Higher-risk PRs get up to two reviewers assigned based on contribution history. Decisions are summarized in Slack and logged to a Notion database via MCP so we can audit the agent’s work and tweak the instructions.

  • Incident response
    When triggered by a PagerDuty incident, this automation kicks off an agent that uses the Datadog MCP to investigate the logs and looks at the codebase for recent changes. It then sends a message in a Slack channel to our on-call engineers, with the corresponding monitor message and a PR containing the proposed fix. This has significantly reduced our incident response time.

  Chores

  We’ve also found automations useful for everyday tasks and knowledge work that require stitching together information across different tools.

  • Weekly summary of changes
    This automation posts a weekly Slack digest summarizing meaningful changes to the repository in the last seven days. The agent highlights major merged PRs, bug fixes, technical debt, and security or dependency updates.

  • Test coverage
    Every morning, an automated agent reviews recently merged code and identifies areas that need test coverage. It follows existing conventions when adding tests and only alters production behavior when necessary. The agent then runs relevant test targets before opening a PR.

  • Bug report triage
    When a bug report lands in a Slack channel, this automation checks for duplicates and creates an issue using Linear MCP. The agent then investigates the root cause in the codebase, attempts a fix, and replies in the original thread with a summary.

  How Rippling uses automations

  Teams outside Cursor have already started building automations. Abhishek Singh at Rippling set up a personal assistant. He dumps meeting notes, action items, TODOs, and Loom links into a Slack channel throughout the day. A cron agent runs every two hours, reads everything alongside his GitHub PRs, Jira issues, and Slack mentions, deduplicates across sources, and posts a clean dashboard.

  He also runs Slack-triggered automations for creating Jira issues from threads and summarizing discussions in Confluence. Singh and Rippling have extended their use of automations to handle tasks like incident triage, weekly status reports, on-call handoff, and more. The most useful automations get shared across the team.

  “Automations have made the repetitive aspects of my work easy to offload. By making automations to round up tasks, deal with doc updates, and respond to Slack messages, I can focus on the things that matter. Anything can be an automation!”

  Tim Fall
  Senior Staff Software Engineer, Rippling

  The factory that creates your software

  All of these automations are powered by cloud agents that use their own computers to build, test, and demo their work. Now you can build the factory that creates your software by configuring agents to continuously monitor and improve your codebase.

  “We built our software factory using Cursor Automations with Runlayer MCP and plugins. We move faster than teams five times our size because our agents have the right tools, the right context, and the right guardrails.”

  Tal Peretz
  Co-founder, Runlayer

  Try creating an automation at cursor.com/automations, or start from a template. Learn more in the docs.

  Original source Report a problem

  Show more
• All of your release notes in one feed

  Join Releasebot and get updates from Zed and hundreds of other software products.

  Create account

  Get updates with: RSS Email API CSV MCP Slack n8n Zapier
• Mar 5, 2026

  • Date parsed from source:
    Mar 5, 2026
  • First seen by Releasebot:
    Mar 6, 2026
  

  Cursor

  Automations

  Cursor unveils automations for always-on agents with triggers and schedules across Slack, GitHub, and more.

  Cursor automations

  Cursor now supports automations for building always-on agents that run based on triggers and instructions you define.

  Automations run on schedules or are triggered by events from Slack, Linear, GitHub, PagerDuty, and webhooks.

  When invoked, the agent spins up a cloud sandbox and follows your instructions using the MCPs and models you've configured. Agents also have access to a memory tool that lets them learn from past runs and improve with repetition.

  Create automations at cursor.com/automations, or start from a template. Read more in our announcement.

  Original source Report a problem

  Show more
• Mar 4, 2026

  • Date parsed from source:
    Mar 4, 2026
  • First seen by Releasebot:
    Mar 5, 2026
  • Modified by Releasebot:
    Mar 6, 2026
  

  Visual Studio Code by Microsoft

  February 2026 (version 1.110)

  Microsoft releases February 2026 VS Code with extensive agent improvements, background agent controls, Claude integration and new agent plugins, plus debugging panels, session memory, context compaction, forked chats, and accessibility and UI upgrades.

  February 2026 (version 1.110)

  Release date: March 4, 2026

  Downloads: Windows: x64
  Arm64 | Mac: Universal
  Intel
  silicon | Linux: deb
  rpm
  tarball
  Arm
  snap

  Welcome to the February 2026 release of Visual Studio Code. This release makes agents practical for longer-running and more complex tasks, giving you more control and visibility, new ways to extend agents, and smarter session management.

  • Agent plugins: install prepackaged bundles of skills, tools, and hooks from the Extensions view
  • Agentic browser tools: let the agent drive the browser to interact with your app and verify its own changes
  • Session memory: persist plans and guidance across conversation turns
  • Context compaction: manually compact conversation history to free up context space
  • Fork a chat session: create a new, independent session that inherits conversation history to explore alternative approaches
  • Agent Debug panel: get real-time visibility into agent events, tool calls, and loaded customizations
  • Chat accessibility: use chat to its fullest with screen reader improvements, keyboard navigation, and notification signals
  • Create agent customizations from chat: generate prompts, skills, agents, and hooks directly from a conversation
  • Kitty graphics protocol: render high-fidelity images directly in the integrated terminal

  Happy Coding!

  If you'd like to read these release notes online, go to Updates on code.visualstudio.com.

  Insiders: Want to try new features as soon as possible?
  You can download the nightly Insiders build and try the latest updates as soon as they are available.

  Agent controls
  Whether you are debugging an agent's behavior, tweaking approval flows, or handing work off to a background process, these updates give you more visibility and control over how agents run.

  Background agents
  With background agents, you can hand off tasks to Copilot CLI, while still keeping track of them in VS Code. We have made several improvements to align the capabilities and experience of background agents with local and cloud agents.

  • Context compaction: Copilot automatically compacts the conversation history when the context window reaches its limit. You can now also manually trigger compaction for background agents with the /compact slash command.
  • Use /slash commands: chat customization options like prompt files, hooks, and skills are now also available in background agent sessions as slash commands.
  • Rename background agent sessions: you can now rename your background agent sessions to keep track of them more easily.

  Claude agents
  Last month, we added Claude agents, enabling you to interact with the Claude Agent SDK using Claude models included in your GitHub Copilot subscription.

  This month, we've expanded this experience with new features and improvements:

  • Steering and queuing to let you send follow-up messages mid-conversation to alter the agent's approach or to queue up additional requests.
  • Session renaming
  • Context window rendering with compaction
  • Additional slash commands
  ◦ /compact for on-demand compaction
  ◦ /agents to manage custom agents
  ◦ /hooks to manage Claude hooks
  • Add the getDiagnostics tool to let the agent access editor and workspace problems
  • Significant performance improvements

  More improvements are planned. Share your feedback on GitHub!

  Agent Debug panel (Preview)
  With different agent customizations like hooks, skills, and custom agents, it can sometimes be difficult to understand what happens when you send a message to an agent. The Agent Debug panel gives you deeper visibility into your chat sessions and how your chat customizations are loaded.

  The Agent Debug panel shows chat events in real time, including chat customization events, system prompts, tool calls, and more. You can see exactly which prompt files, skills, hooks, and other customizations are loaded for a session, making it easier to understand and troubleshoot your agent configuration. This replaces the old Diagnostics chat action with a richer, more detailed view.

  Open the panel from the Command Palette with Developer: Open Agent Debug Panel, or select the gear icon at the top of the Chat view and choose View Agent Logs.

  The panel also includes a chart view that displays a visual hierarchy of events, so you can quickly understand the structure and sequence of what happens during a chat session.

  This experience is still in preview, so try it out and share your feedback!

  Note: The Agent Debug panel is currently only available for local chat sessions. Log data is not persisted, so you can only view logs for chat sessions from your current VS Code session.

  Slash commands for enabling auto approval
  You can now toggle global auto approve directly from the chat input using slash commands, without navigating to settings:

  • /autoApprove enables global auto approve for all tools
  • /disableAutoApprove disables global auto approve

  /yolo and /disableYolo are aliases for the same commands.

  CAUTION: Global auto approve skips all tool confirmation prompts, letting the agent run tools and terminal commands without waiting for your approval. This can speed up longer, multi-step tasks but means you won't have the opportunity to cancel potentially destructive actions. Make sure you understand the security implications before enabling it and consider using terminal sandboxing for additional protection.

  Edit and ask mode changes
  Setting: chat.editMode.hidden

  As agents have evolved, agent mode now handles everything edit mode can do and more, with better performance and reliability. Edit mode is now hidden from the agent picker by default, so users benefit from the most capable mode without having to choose between options. You can bring it back by disabling the chat.editMode.hidden setting.

  Ask mode is now backed by a custom agent definition, making it a fully agentic experience. This resolves previous limitations, such as requiring a new session when switching between ask and agent mode.

  Both changes demonstrate how to customize your own agents. If you prefer edit mode or want your own version of ask mode, create a custom agent that matches your needs by defining its tools, prompt, and language model. When you disable chat.editMode.hidden, you can select the View edit agent action in the agent picker to view the agent declaration that powers edit mode, which can serve as a starting point for your own custom agent.

  Learn how to create custom agents in the custom agents documentation.

  Ask questions tool
  The askQuestions tool, which presents a question carousel UI during chat interactions, has been moved into VS Code core. This improves reliability when canceling requests and enables the tool to work consistently across different contexts, including subagents.

  When the carousel is active, you can now send a steering message without needing to reply to or dismiss pending questions first. This allows you to redirect the agent's response on the fly, even in the middle of a question sequence. Use the keyboard to navigate between questions with unassigned (next) and unassigned (previous).

  Prevent auto-suspend during chat
  VS Code now asks the operating system not to automatically suspend the machine while a chat request is running. You can step away from your computer without worrying about interrupting the agent's response.

  Note that closing the lid of an unplugged laptop still triggers suspension.

  Agent extensibility
  Agents are only as useful as the tools and customizations you give them. This release makes it easier to extend what agents can do, from installable plugin bundles to browser automation and new code-aware tools.

  Agent plugins (Experimental)
  Settings: chat.plugins.enabled, chat.plugins.marketplaces, chat.plugins.paths

  VS Code now supports agent plugins, which are prepackaged bundles of chat customizations. Plugins can contain skills, commands, agents, MCP servers, and hooks.

  You can search and install agent plugins directly from the Extensions view within VS Code. Enter @agentPlugins in the search box or run the Chat: Plugins command from the Command Palette.

  By default, VS Code retrieves plugins from the copilot-plugins and awesome-copilot repos. You can configure more sources via the following settings:

  • chat.plugins.marketplaces: add additional plugin marketplaces by specifying GitHub or plain git repositories. The setting can also support Claude-style marketplaces such as anthropics/claude-code.
  • chat.plugins.paths: register local plugin directories by specifying their paths and enabling or disabling them.

  Learn more about agent plugins in the agent plugins documentation.

  Agentic browser tools (Experimental)
  Setting: workbench.browser.enableChatTools

  In the previous release, we added a new integrated browser in VS Code desktop which lets you interact with web pages directly within the editor. But what if your agent could autonomously use this browser and validate changes to your website while it's building it?

  In this release, we added a set of tools for agents to read and interact with the integrated browser. As the agent interacts with the page, it sees updates to page content and any errors and warnings in the console. The tools work out of the box without the need to install any extra dependencies.

  • Page navigation: openBrowserPage, navigatePage
  • Page content and appearance: readPage, screenshotPage
  • User interaction: clickElement, hoverElement, dragElement, typeInPage, handleDialog
  • Custom browser automation: runPlaywrightCode

  These tools give agents the ability to perform simultaneous authoring and verification of web apps and close the development loop for agents.

  By default, pages opened by the agent run in private, in-memory sessions. This gives you control over what browsing data the agent can access. To give the agent access to a specific web page in the integrated browser, you can explicitly share the page with the agent to give temporary access and any saved data.

  To try out the new tools, enable workbench.browser.enableChatTools and enable the browser tools in the chat tools picker.

  Get started with the browser agent testing guide for a step-by-step tutorial.

  Create agent customizations from chat
  You can now generate agent customization files directly from a chat conversation by using new /create-* slash commands in agent mode:

  • /create-prompt: generate a reusable prompt file
  • /create-instruction: generate an instruction file for project conventions
  • /create-skill: extract a multi-step workflow into a skill package
  • /create-agent: create a specialized custom agent persona
  • /create-hook: create a hook configuration for lifecycle automation

  Each command guides you through the creation process and lets you choose between user-level (account-wide) or workspace-level (project-specific) storage.

  The commands can also extract patterns from an ongoing conversation. For example, after debugging an issue over several turns, use /create-skill to capture the procedure as a reusable skill, or /create-instruction to turn corrections into project conventions.

  You don't need to remember the exact slash command. You can also use natural language, such as "save this workflow as a skill" or "extract an instruction from this", and the agent recognizes your intent and starts the correct creation flow.

  The same generation options are available from the quick pick menus for prompts, instructions, skills, and agents, indicated by a sparkle icon.

  Tools for usages and rename
  We have updated the usages -tool and also added a tool for rename. These tools reuse existing extension or LSP capabilities and allow agents to navigate and refactor code with high precision and best performance.

  Agents should automatically pick up these new tools. However, we have found that agents have a strong preference for using grep instead, which is inferior for this scenario. You can help the agent by explicitly #-mentioning the tool names, like Use #rename and change the name of fib to fibonacci or by setting up a SKILL.md file.

  Smarter sessions
  Long-running and multi-turn tasks work better when the agent remembers context, delegates research efficiently, and keeps your inline edits in sync. These improvements make sessions more resilient and context-aware.

  Session memory for plans
  Plans created by the Plan agent now persist to session memory and stay available across conversation turns. When you ask for refinements, the agent builds on the existing plan instead of starting from scratch.

  The plan is also recalled after unrelated messages in the same session, so you can return to a plan without repeating context. During longer implementation work, the plan remains accessible in memory even when older conversation history is compacted to free up context space.

  Context compaction
  As a conversation grows, the accumulated messages and context can fill up the model's context window. Context compaction summarizes the conversation history to free up space, so you can continue working in the same session without losing important details.

  VS Code automatically compacts the conversation when the context window reaches its limit, but you can also trigger compaction manually. Manual compaction is available for local, background, and Claude agent sessions. To manually compact, use one of the following methods:

  • Type /compact in the chat input field. Optionally, add custom instructions after the command to guide how the summary is generated, for example /compact focus on the database schema decisions.
  • Select the context window control in the chat input box, and then select Compact Conversation.

  Learn more about context compaction in the documentation.

  Codebase search with Explore subagent
  Setting: chat.exploreAgent.defaultModel

  The Plan agent now always delegates codebase research to a dedicated Explore subagent. Explore is a read-only agent that uses only search and file read tools, and focuses on fast, parallelized codebase exploration. By offloading research to Explore, the Plan agent can produce plans that reference specific files and code paths in your workspace.

  Explore runs on fast models by default (Claude Haiku 4.5, Gemini 3 Flash) to keep research quick while the Plan agent uses the full model for planning. You can override the model with the chat.exploreAgent.defaultModel setting. Hover over the explore task in chat to see which model is being used for research.

  Note: Explore is not directly invokable as a standalone agent. It is only available as a subagent used on-demand.

  Inline chat and chat session
  When an agent session already changed a file, inline chat now always queues new messages into that session instead of making changes in isolation. This ensures that the full context is used and is also useful when reviewing agent edits.

  Fork a chat session
  You can now fork a chat session to create a new, independent session that inherits the conversation history from the original. This is useful when you want to explore an alternative approach, ask a side question, or branch a long conversation in a different direction without losing the original context.

  There are two ways to fork a session:

  • Fork the entire session: type /fork in the chat input box to create a new session with the full conversation history.
  • Fork from a checkpoint: hover over any chat request and select Fork Conversation to create a new session that includes only the conversation up to that point.

  The forked session is fully independent—changes in one session do not affect the other. Learn more about forking chat sessions.

  Chat experience
  Small refinements to the chat interface add up: a cleaner model picker, less visual clutter from tool output, and notifications that reach you even when you are heads-down in another file.

  Redesigned model picker
  We have redesigned the language model dropdown to improve selecting the right model for the task. The new dropdown organizes models into clear sections:

  • Auto is always shown at the top of the list.
  • Featured and recently used models appear next. Up to four recently used models are shown alongside featured models curated for your account. As you use models, they move into this section automatically.
  • Other models is a collapsible group that contains the remaining available models. Expanding it also reveals the Manage Models option at the bottom.
  • A search box lets you quickly filter models by name.

  Each model entry shows a rich hover with model details such as capabilities and context window size. Models that are unavailable on your current GitHub Copilot plan are also shown but are not selectable.

  Discover features with contextual tips (Experimental)
  Setting: chat.tips.enabled

  VS Code now shows contextual tips in the Chat view to help you discover features and get the most out of your AI coding experience. Tips appear when you start a new chat session and are tailored to your usage patterns. To avoid being overwhelming, only features you haven't tried yet are suggested, making them relevant and actionable.

  Tips cover a variety of capabilities including:
  • Creating custom agents, prompts, and skills
  • Using message queueing and steering
  • Switching to better models
  • Enabling experimental features like YOLO mode and custom thinking phrases

  Use the navigation controls to browse through available tips, or dismiss individual tips you're not interested in. Tips automatically hide once you've used the suggested feature. You can disable tips entirely with chat.tips.enabled.

  New tips are added regularly as features are released, so check back often for fresh suggestions.

  Custom thinking phrases
  Settings: chat.agent.thinking.phrases

  The loading text that is shown during reasoning or during tool calls is now customizable. You can use the predefined custom phrases to complete the existing default phrases with the replace mode, or have custom phrases be an addition to the existing default phrases with append.

  This setting lets you personalize the chat loading experience.

  Collapsible terminal tool calls
  Settings: chat.tools.terminal.simpleCollapsible

  Terminal tool invocations in agent mode are now displayed as collapsible sections. Instead of long terminal outputs cluttering the conversation, each terminal command appears as a summary header that you can expand to reveal the full output. This reduces visual noise and makes it easier to scan through multi-step agent interactions. This functionality can be disabled with the chat.tools.terminal.simpleCollapsible setting.

  OS notifications for chat responses and confirmations
  Settings: chat.notifyWindowOnResponseReceived, chat.notifyWindowOnConfirmation

  Previously, OS notifications for chat responses and confirmation requests only appeared when VS Code was not focused. This meant that if you were actively working on another task in VS Code, you might miss important updates like when a response is received or when the agent needs your confirmation to proceed.

  You can now configure these notifications to appear even when the window is in focus by setting the settings value to always.

  Inline chat hover mode
  Setting: inlineChat.renderMode

  Inline chat is transitioning away from the "in-between lines" UI to a hover-based UI. You can enable it via inlineChat.renderMode, which makes the inline chat input more like the rename experience. Once a prompt is submitted, progress and results are shown in the upper right corner.

  Inline chat affordance
  Setting: inlineChat.affordance

  To provide an easier way of starting inline chat, we added two kinds of affordances that show alongside your selection. They combine with the lightbulb and should not get in your way.

  The inlineChat.affordance setting has three possible values:
  • off No affordance is shown on text selection
  • editor Show a menu in the editor alongside the selection
  • gutter Show a menu in the editor gutter (line number area) next to the selection

  Accessibility
  This release improves screen reader support, keyboard navigation, and awareness of chat interactions so that every developer can work effectively with VS Code's AI features.

  Toggle thinking content in the accessible view
  Screen reader users can now toggle the inclusion of thinking content in the chat response accessible view unassigned . This lets you choose whether to include the model's reasoning process when reading responses, providing flexibility to either follow the full chain of thought or focus only on the final output.

  Question carousel accessibility
  The chat question carousel is now fully accessible to screen reader users:
  • Questions are announced with their position (for example, "Question 1 of 3")
  • Use Alt+N and Alt+P to navigate between questions
  • Use unassigned to toggle focus between the question carousel and chat input
  • In screen reader mode, focus no longer automatically moves to prevent disruption

  Notifications for chat questions and confirmations
  Settings: chat.notifyWindowOnConfirmation, accessibility.signals.chatUserActionRequired

  When chat asks a question or requires confirmation, VS Code now plays an accessibility signal and shows an OS notification when enabled. This helps you stay aware of pending actions even when working in another window.

  Keybinding to toggle TODO list focus
  Use unassigned to quickly toggle focus between the agent TODO list and the chat input. This is particularly helpful for screen reader users to get an overview of pending tasks and return to the chat input.

  Cursor position remembered in accessible view
  When you close the accessible view while content is streaming (such as during a chat response), your cursor position is now preserved when you reopen it. This prevents the cursor from jumping back to the top and lets you continue reading from where you left off.

  Find and filter accessibility help
  Press Alt+F1 in any find or filter dialog to open contextual accessibility help. This includes help for:
  • Editor find and replace
  • Terminal find
  • Search across files
  • Output, Problems, and Debug Console filters

  The help content explains available keyboard shortcuts, navigation patterns, and context-specific behaviors. Find widgets also announce "Press Alt+F1 for accessibility help" when focused (controlled by accessibility.verbosity.find).

  Quick input screen reader improvements
  The Go to Line dialog ( Ctrl+G ) and other quick input boxes now work better with screen readers:
  • Characters are announced as you type
  • Arrow key navigation works correctly within the input field
  • Proper announcements when navigating list items
  • Line and column position announced after navigation

  Steering indicator for screen readers
  When you send a steering message while a response is streaming, screen reader users now receive an aria-status announcement indicating that steering has occurred.

  Accessibility skill
  A new built-in accessibility skill helps ensure new features include proper accessibility support. When you ask the agent to create a new feature and make it accessible, it automatically references accessibility guidelines and patterns.

  Checkmarks in chat
  Settings: accessibility.chat.showCheckmarks

  This iteration, in an effort to simplify the chat view and make it more consistent, checkmarks are now removed by default in front of tool calls and collapsible pieces. The accessibility.chat.showCheckmarks will re-enable checkmarks throughout the chat if you'd like to have them as indicators in the chat.

  Editor Experience

  Modal editors (Experimental)
  Settings: workbench.editor.useModal, extensions.allowOpenInModalEditor

  We are experimenting with a new modal editor experience for editors that you typically open briefly and then return to your active task. A modal editor floats on top of the editor without impacting the layout of your editor tabs. To close the modal editor, press Escape. The modal has an action to move the editor back into an editor tab, as well as an action to maximize the modal experience.

  The modal experience applies to the following editors:
  • Settings
  • Keyboard shortcuts
  • Profiles management
  • AI and Language models management
  • Workspace trust management

  Set workbench.editor.useModal to some for opting into this experience.

  Note: the Settings editor and Keyboard Shortcuts editor show a button to open the associated JSON file as a text editor

  Another setting extensions.allowOpenInModalEditor expands the use of modal editors to extensions. This experience is still a work in progress and will likely change in the future but we wanted to make it available for feedback now:

  In this modal editor, a control in the title bar allows you to navigate between all extensions from the list you had in the Extensions view. The same applies to MCP servers. Future versions will likely see the extensions list and search functionality also move into the modal. Try it out and share your feedback.

  Configurable notification position
  Setting: workbench.notifications.position

  Previously, VS Code notifications appeared in the bottom-right corner of the screen. With the default position of the Chat view also on the right, notifications could obscure the chat interface.

  You can now configure the position of notifications to be either top-right , bottom-right, or bottom-left . The default remains bottom-right . This setting enables you to choose the best position for your workflow.

  Settings editor cleanup
  We have moved the VS Code chat settings into their own top-level entry in the Settings editor with sub-categories. GitHub Copilot Chat extension entries remain in their own entry under Extensions.

  The displayed list of settings is also scoped to the selected table of contents entry, meaning that once you select a table of contents entry, you cannot accidentally scroll into the next entry anymore.

  Lastly, the experimental settings have been moved to the end of each section, so that stabilized settings appear first.

  Code Editing

  Long-distance next edit suggestions
  Next edit suggestions (NES) extend ghost text by suggesting edits not just at your cursor, but also nearby, anticipating what you'd change next. We've been continuing to advance this experience with long-distance next edit suggestions, which extend NES to predict and suggest edits anywhere in your file, not just near your current cursor position.

  Read the blog post on long-distance next edit suggestions to learn more about how it was built, from creating the training dataset, to refining the UX, evaluating success, and more. Make sure you have NES ( github.copilot.nextEditSuggestions.enabled ) and extended NES range ( github.copilot.nextEditSuggestions.extendedRange ) enabled in VS Code.

  NES eagerness
  The Copilot Status Bar item now includes an eagerness option for next edit suggestions. This option lets you choose between getting more suggestions that might be less relevant, or fewer suggestions that are more likely to be useful.

  Initially, this option primarily affects the timing of suggestions. As the NES model evolves, it will increasingly take your eagerness preference into account for more fine-tuned suggestions.

  Source Control

  AI co-author attribution for commits
  Setting: git.addAICoAuthor

  VS Code can automatically append a Co-authored-by: trailer when you commit code that includes AI-generated contributions. Additionally, Git blame hover tooltips now show co-authors from commit trailers, including non-AI Co-authored-by entries.

  Configure git.addAICoAuthor with one of these values:
  • off (default): does not add a co-author trailer
  • chatAndAgent: adds the trailer for code generated with Copilot Chat or agent mode
  • all: adds the trailer for all AI-generated code, including inline completions

  VS Code only adds co-author trailers for commits you make from within VS Code. This setting does not modify commits made in external Git tools or the command line.

  Debugging

  JavaScript Debugger

  Custom property replacements
  If an object has a method defined using Symbol.for('debug.properties'), then those properties will be shown by default in the debugger. This allows you to provide a more comprehensible view of complex objects.

  Emulate focused window and event listener breakpoints
  Previously, when debugging a browser, you could set breakpoints in the Event Listener Breakpoints view. We have renamed this view to Browser Options.

  We added an extra option to Emulate a focused page. When checked, moving your focus out of the browser window no longer causes the browser element to lose focus. This is useful for debugging elements that depend on hover or focus states.

  Terminal

  Kitty graphics protocol
  Settings: terminal.integrated.enableImages, terminal.integrated.gpuAcceleration, terminal.integrated.windowsUseConptyDll

  The VS Code terminal now supports the Kitty graphics protocol, enabling high-fidelity image rendering directly in the terminal. Programs that support this protocol can transmit and display images with a rich set of capabilities:
  • Image formats: PNG, 24-bit RGB, and 32-bit RGBA
  • Display layout: scale images to specific column/row dimensions, crop source regions, apply sub-cell pixel offsets, and control z-index stacking order
  • Transmission: direct inline base64 with chunked transfer and zlib compression support
  • Image management: transmit and display in one step, store images and place them later at different positions, delete by ID or all at once, and re-transmit to update existing images
  • Cursor control: choose whether the cursor moves past the image or stays in place after rendering
  • Terminal integration: images scroll with text, and are properly cleaned up on terminal reset or clear

  To enable image rendering, set terminal.integrated.enableImages to true and ensure terminal.integrated.gpuAcceleration is set to on or auto. On Windows, you also need to enable terminal.integrated.windowsUseConptyDll.

  Tools like kitten icat (macOS/Linux) or the VT CLI can be used to display images in the terminal.

  Note: Some Kitty graphics protocol features are not yet supported, including animations, relative placements, Unicode placeholders, and file-based transmission. See the xterm.js discussion for the most up-to-date implementation status.

  Ghostty support for external terminal
  Settings: terminal.external.osxExec, terminal.external.linuxExec

  Ghostty is now supported as an external terminal on macOS and Linux. You can set it as your default external terminal using the terminal.external.osxExec setting on macOS or terminal.external.linuxExec on Linux.

  Once configured, commands like Terminal: Open New External Terminal and debug configurations that launch in an external terminal will open in Ghostty.

  Workspace folder selection for external terminals
  When you open an external terminal in a multi-root workspace using Ctrl+Shift+C or the Terminal: Open New External Terminal command, VS Code now prompts you to select a workspace folder. The selected folder is used as the working directory for the external terminal.

  Terminal sandboxing improvements (Preview)
  Settings: chat.tools.terminal.sandbox.enabled, chat.tools.terminal.sandbox.linuxFileSystem, chat.tools.terminal.sandbox.macFileSystem, chat.tools.terminal.sandbox.network

  Trusted domains can now be selected for network isolation by enabling allowTrustedDomains in chat.tools.terminal.sandbox.network. Improved detection of restricted domains, with clear feedback indicating which domain is blocked.

  No installation is required to enable terminal sandboxing on macOS, and on Linux you can enable without installing ripgrep.

  Languages

  Unified JavaScript and TypeScript settings
  To prepare for the upcoming TypeScript 6.0 and 7.0 releases, we've consolidated and cleaned up our built-in JavaScript and TypeScript setting IDs. Previously many of these settings had duplicate javascript.* and typescript.* versions. This is because these settings are from before we added a standard approach to language-specific settings. Some of the settings names were also inconsistent.

  Now all of these settings have been moved under the js/ts.* prefix. This means that by default you only need to update a single setting value to change the behavior in both JavaScript and TypeScript files. You can use language-specific settings if you want different behavior in JavaScript and TypeScript files.

  For example, instead of setting:
  "javascript.format.enable": false,
  "typescript.format.enable": true

  You can now use language-specific overrides with the unified setting.

  The old javascript.* and typescript.* settings continue to work but are now marked as deprecated and will be overridden if the new unified js/ts settings are set.

  We understand this is a big change, however we think it's the right one for the long term quality of VS Code. The unified settings make it easier to change JavaScript and TypeScript settings, and also enable support for modern options such as language-specific settings.

  Python

  Python Environments extension rolling out to all users
  The Python Environments extension is now rolling out to all users after a year in preview. The extension brings a unified interface for managing Python environments, packages, and interpreters directly in VS Code, regardless of whether you use venv, conda, pyenv, poetry, or pipenv.

  Key capabilities include:
  • Quick Create: Create an environment with a single click using your default manager and the latest Python version
  • Python Projects: Assign environments to specific folders for monorepos and multi-service workspaces
  • uv integration: Faster environment creation and package installation when uv is installed
  • Built-in package management: Search, install, and uninstall packages from the Environment Managers view
  • Portable settings: Environment configurations use manager types instead of hardcoded paths, making settings.json portable across machines

  You can expect the extension to be enabled automatically over the next few weeks, or you can opt in immediately with the python.useEnvsExtension setting.

  For more details, read the announcement blog post or see the Python environments documentation.

  Contributions to extensions

  GitHub Pull Requests
  There has been more progress on the GitHub Pull Requests extension, which enables you to work on, create, and manage pull requests and issues. New features include:
  • Multiple pull request and issue descriptions can be open at once.
  • The setting githubPullRequests.autoRepositoryDetection can be set to true to include repositories that are outside of the workspace.
  • Repositories without matching issues are now hidden in the Issues view.

  Review the changelog for the 0.130.0 release of the extension to learn about everything in the release.

  Extension Authoring

  Webviews and Custom Editors can now use ThemeIcons for their icon path
  Webview Panels and custom editors can now use a ThemeIcon as their editor tab icon.

  Portable mode detection API finalized
  The env.isAppPortable API is now stable and available to all extensions without requiring enabledApiProposals.

  Use this API to detect whether VS Code is running in portable mode, which is enabled when the app runs from a folder containing a data directory.

  Proposed APIs

  Chat item controller API
  We continued to improve the chat session API. This API lets extensions contribute items to VS Code's built-in chat sessions view. Notable changes this iteration include:
  • Added ChatSessionItemControllerNewItemHandler so that controllers can specify the URI used for new sessions.
  • Added ChatSessionProviderOptions.newSessionOptions which sets the default options for new sessions.

  We also significantly optimized the API's implementation to support large numbers of sessions.

  Engineering

  TypeScript-Go for VS Code engineering
  We've continued adopting TypeScript-Go (tsgo) for development work in the vscode repo.

  As of this iteration, we default the vscode workspace to using TSGo for development. We've already noticed performance improvements from this, and it also helps us test TSGo's language tooling.

  We now also use TypeScript-Go (tsgo) to compile VS Code's built-in extensions during development. As a result, each of our built-in extensions is now built and fully typechecked in under a second.

  Extension bundling with esbuild
  We've migrated most of our built-in extensions to use esbuild instead of webpack for bundling. Esbuild is used for both bundling the desktop and web versions of these extensions.

  This migration has both simplified and sped up our builds. There are only a handful of extensions left to migrate and we hope to finish this work in March.

  Deprecated features and settings

  New deprecations in this release
  • Edit Mode is officially deprecated as of VS Code version 1.110. Users can temporarily re-enable Edit Mode via VS Code setting chat.editMode.hidden. This setting will remain supported through version 1.125. Beginning with version 1.125, Edit Mode will be fully removed and can no longer be enabled via settings.

  Upcoming deprecations
  None

  Notable fixes
  • vscode#251722: Inline actions on extension provided tree-view items withing the visible scroll area even when "workbench.list.horizontalScrolling": true

  Thank you

  Issue tracking
  Contributions to our issue tracking:
  • @gjsjohnmurray (John Murray)
  • @RedCMD (RedCMD)
  • @IllusionMH (Andrii Dieiev)
  • @tamuratak (Takashi Tamura)
  • @robotsnh (robotsnh)

  (Additional contribution and PR acknowledgements follow in the release notes.)

  We really appreciate people trying our new features as soon as they are ready, so check back here often and learn what's new.

  If you'd like to read release notes for previous VS Code versions, go to Updates on code.visualstudio.com.

  Original source Report a problem

  Show more
• Mar 4, 2026

  • Date parsed from source:
    Mar 4, 2026
  • First seen by Releasebot:
    Mar 5, 2026
  

  Cursor

  Cursor in JetBrains IDEs

  Cursor ACP lands in JetBrains IDEs enabling agent-driven development with frontier models from OpenAI, Anthropic, Google.

  Cursor ACP in JetBrains IDEs

  Cursor is now available in IntelliJ IDEA, PyCharm, WebStorm, and other JetBrains IDEs through the Agent Client Protocol (ACP).

  With Cursor ACP, developers who rely on JetBrains for Java and multilanguage support can use any frontier model from OpenAI, Anthropic, Google, and Cursor for agent-driven development.

  Install the Cursor ACP directly in your JetBrains IDE from the ACP Registry, and authenticate with your existing Cursor account.

  Read more in our announcement.

  Original source Report a problem

  Show more
• Mar 4, 2026

  • Date parsed from source:
    Mar 4, 2026
  • First seen by Releasebot:
    Mar 5, 2026
  

  Zed

  0.226.4

  This release adds self-hosted OpenAI-compatible server support for edit predictions, a Review Diff button for git branch diffs, and diagnostic count badges in the project panel. It also includes undo for the reject all action and several stability and performance improvements.

  Release Notes

  This week's release includes support for self-hosted OpenAI-compatible servers for edit predictions, a new Review Diff button in the git branch diff view for sending diffs to an agent for review, diagnostic count badges in the project panel, and the ability to undo the reject all action when reviewing agent-made changes.

  Features

  AI

  • Added the ability to use a self-hosted OpenAI-compatible server for edit predictions. (#49554)
  • Agent: Added the ability to undo the reject all action from agent-made changes. (#48462)
  • Agent: Added support for Claude Sonnet 4.6 for Bedrock. (#49439; thanks 5herlocked)
  • Agent: Added fallback error handling for connect failures. (#50063)
  • Agent: Changed agent::addSelectionToThread (cmd->) to use the current line of the cursor when there is no selection. (#48045; thanks notpeter)

  Git

  • Added diff stat numbers to the git branch diff (git: branch diff) view. (#49716)
  • Added a Review Diff button in the git: branch diff view so that the whole diff can be quickly sent for review to an agent. (#49513)
  • Improved split diff performance by reducing number of entity clones for very large pre-loaded multibuffers. (#49573)

  Languages

  • Improved completion order for Python-based LSPs. (#47160; thanks lingyaochu)
  • Added syntax highlighting for HTML character references (·, ', {, etc.) in TSX, JavaScript, and HTML files. (#48629; thanks br-schneider)
  • Go: Added definition highlights for functions, methods, and types. (#49120; thanks tvi)
  • Markdown: Added .mdc as a recognized file extension. (#50074; thanks avifenesh)

  REPL

  • Added WSL and SSH remote kernels and wired up spawn/kill kernel proto messages and client requests. (#47891; thanks MostlyKIGuess)
  • Added ability to clear outputs by action. (#49631; thanks rgbkrk)
  • Added basic handling of HTML in REPL outputs. (#49646; thanks rgbkrk)

  Windows

  • Added a zed: record etw profile action that can be used to collect performance profiles. (#49712)

  Other

  • Improved the memory footprint of Zed. (#49703)
  • Reduced memory usage on macOS. (#49236; thanks marcocondrache)
  • Optimized performance for language servers which register many file-watching notifications. (#49778)
  • Improved the checkerboard pattern in the image viewer to be more visually pleasant. (#49575; thanks MostlyKIGuess)
  • Added diagnostic count badges to the project panel, displaying error and warning counts next to file names. You can modify this setting using the diagnostic_badges option, which is disabled by default. (#49802; thanks Obli04)
  • Added copy button for project diagnostics messages. (#49671; thanks ozacod)
  • Improved multi-cursor paste to distribute each clipboard line to its corresponding cursor when the line count matches. (#48676)
  • Added debug_panel::Toggle to show/hide debug panel like terminal_panel::Toggle. (#48020; thanks samueldominguez)
  • Added workspace::ActivateLastPane action for keybindings that focus the last pane. (#49853; thanks gh-xj)
  • Improved the zed: open performance profiler action to display profiling data from the remote server. (#49582)

  Bug Fixes

  • Windows: Fixed remote server failing to launch. (#50153)
  • Windows: Fixed a panic registering a path with language servers when the UNC path cannot be represented by a Rust URI. (#50310)
  • Agent: Fixed the OpenAI-compatible setting description to point to the server's completion API URL. (#49846; thanks Marcuss2)
  • Agent: Fixed the agent edit tool clearing file contents before the first edit arrives, which caused buffers to appear empty for prolonged periods with slow agents. (#49633)
  • Agent: Fixed Codex ACP installation robustness by staging downloads. (#45428; thanks cppcoffee)
  • Agent: Fixed Anthropic streaming for alternative providers by accepting SSE data:{...} (no space) lines. (#47847; thanks raphaelluethy)
  • Agent: Fixed the agent panel silently stopping instead of showing an error when a model response stream terminates abnormally. (#49337)
  • Debugger: Fixed a bug where active debug lines could be set in the wrong pane. (#49390)
  • Git: Fixed a bug where the buttons to toggle the split diff view would have no effect when the diff being viewed was empty. (#49884)
  • Git: Fixed pull request link detection picking up unrelated links in git output. (#49817; thanks kbidlack)
  • Linux: Fixed crashes that could happen due to our crash handler erroneously catching signals intended for wasmtime. (#49944)
  • Fixed workspace: open files not respecting use_system_path_prompts setting. (#47027; thanks austincummings)
  • Fixed a (very rare) crash that could happen due to lost edits in channel buffers. (#50034)
  • Fixed a crash when git produces duplicate status entries for the same file path. (#49191)
  • Fixed a crash when using the editor minimal. (#49692)
  • Fixed a crash when using vim paste on clipboard data copied with the editor's copy command containing multiple entire-line selections. (#49134)
  • Fixed a panic in editor::GoToDefinitionSplit if you managed to close the current pane before the definitions were resolved. (#50060)
  • Fixed a panic when rendering an image larger than the GPU could support. (#50025)
  • Fixed a panic when authentication failed to bind to loopback port. (#49916)
  • Fixed panics with selection handling in expanded diff hunk. (#49719)
  • Fixed a panic when growing and shrinking selections while the buffer size changes (e.g., when expanding/collapsing diffs). (#48898)
  • Fixed a panic when opening the remote server modal. (#50650)
  • Fixed an issue where custom macOS app icons would revert to default blue folders after an update. (#49727; thanks amtoaer)
  • Fixed bracket highlights flickering when editing inside brackets. (#49797; thanks lingyaochu)
  • Fixed certain context menu items not reacting to click events. (#49557)
  • Fixed clipboard selection range for multi-line copy-and-trim. (#48977)
  • Fixed footer buttons clipped in stash picker when vim mode is enabled on macOS. (#49814; thanks amtoaer)
  • Fixed interop detection on WSL not working on newer setups. (#49708)
  • Fixed linked edits for delete/change/substitute commands so tag pairs stay in sync. (#48458; thanks ixacik)
  • Fixed mouse scroll in terminal apps (tmux, neovim, etc.) only sending one scroll event when scrolling down, regardless of scroll amount. (#49931; thanks emamulandalib)
  • Fixed remote reconnect failing with an error when the server is not running, now establishes a fresh connection instead. (#49834; thanks mangas)
  • Fixed settings row layout so right-side controls align better with multiline setting descriptions. (#49850; thanks altaywtf)
  • Fixed terminal auto-allow patterns incorrectly prompting for confirmation on commands containing /dev/null redirects (e.g., 2>/dev/null). (#49503)
  • Fixed typo in stop diagnostics update tooltip. (#49779; thanks gazure)
  • Fixed UI icons being hidden in buffer search when the search query was too large. (#49493)
  • Fixed some labels not using title case. (#49864; thanks ssanumand)
  • Fixed incorrect font weight in the Command Palette input. (#49539)
  • Fixed missing font weight in the Agent Panel's buffer. (#49539)
  • Fixed missing font weight in the Hover Popover. (#49539)
  • Fixed missing font weight in Markdown's code block and inline code. (#49539)
  • Fixed a bug that caused Zed to appear not to open if your workspaces failed to restore. (#50334)

  Breaking Changes and Notices

  • Anthropic: Removed models that have been deprecated from their API. (#49522)
  • Removed unused git actions – git: load more history and git: view commit from history. (#49901)

  Original source Report a problem

  Show more
• Mar 4, 2026

  • Date parsed from source:
    Mar 4, 2026
  • First seen by Releasebot:
    Mar 4, 2026
  

  Cursor

  Cursor is now available in JetBrains IDEs

  Cursor ACP lands in JetBrains IDEs, enabling agent-driven coding with frontier models from OpenAI, Anthropic, Google, and Cursor. It includes secure codebase indexing, semantic search, and model-specific optimization for peak performance inside IntelliJ, PyCharm, WebStorm. The ACP is free for paid plans.

  Coding with Cursor in JetBrains IDEs

  Using Cursor ACP in JetBrains IDEs offers many of the benefits that make our agents effective across all surfaces.
  Different models are better suited for different kinds of tasks. With Cursor ACP, developers can explore and choose frontier models from OpenAI, Anthropic, Google, and Cursor. Our agent harness is also custom-built for every model to optimize output quality and performance.
  Cursor also uses secure codebase indexing and semantic search to understand large enterprise codebases. ACP combines these capabilities with deep code intelligence and tooling in JetBrains IDEs.

  "JetBrains has always seen its mission as bringing the best of the industry to our users. I'm very excited about Cursor becoming a special guest in the family of ACP-compliant agents in JetBrains IDEs. In this setup, developers stay in control of their environment, while Cursor brings the powerful AI assistance that has earned it such popularity. This collaboration looks like a win for Cursor, for JetBrains, and most importantly for developers."

  Aleksey Stukalov
  Head of IDEs Division, JetBrains

  Getting started

  Install the Cursor ACP directly in the JetBrains AI chat, and authenticate with your existing Cursor account. The Cursor ACP is free for all users on paid plans. Learn more in the docs.

  What's next

  The Cursor ACP is a foundation for deeper integrations with JetBrains. We're excited to bring agentic coding capabilities to more developers.

  Original source Report a problem

  Show more
• Mar 4, 2026

  • Date parsed from source:
    Mar 4, 2026
  • First seen by Releasebot:
    Mar 4, 2026
  

  Zed

  0.225.13

  • Fixed Zed failing to initialize OpenGL on certain Linux devices (#50652)

  • Fixed Zed not being responsive on some Linux configurations (#50644)

  Original source Report a problem
• Mar 3, 2026

  • Date parsed from source:
    Mar 3, 2026
  • First seen by Releasebot:
    Mar 4, 2026
  

  Cursor

  2.6

  This release adds interactive UIs in agent chats, lets teams share private plugins, and tightens core features like Debug mode. MCP Apps bring charts, diagrams, and whiteboards inside Cursor, and admins can run team marketplaces for centralized plugin governance.

  Release Highlights

  This release introduces interactive UIs in agent chats, a way for teams to share private plugins, and improvements to core capabilities like Debug mode.

  MCP Apps

  MCP Apps support interactive user interfaces like charts from Amplitude, diagrams from Figma, and whiteboards from tldraw directly inside Cursor.

  Team marketplaces for plugins

  On Teams and Enterprise plans, Admins can now create team marketplaces to share private plugins internally. Go to the settings page to manage and distribute plugins with central governance and access controls.

  Desktop Improvements (15)

  Desktop Bug Fixes (10)

  Web Improvements & Fixes (2)

  Original source Report a problem

  Show more
• Mar 3, 2026

  • Date parsed from source:
    Mar 3, 2026
  • First seen by Releasebot:
    Mar 4, 2026
  

  Zed

  0.225.12

  • linux: Reduce crashes in the face of transient GPU errors (#50539)
  • Linux: Select a more appropriate GPU (#50528)

  Original source Report a problem