What's New in VS Code: Remote, Permissions & BYOK

Key Concepts

• Agents Window: A dedicated, agent-first UI surface in VS Code for managing multiple AI agent sessions across workspaces.
• Agent Host: A background process that manages the model loop, tool execution, and workspace ownership.
• Agent Host Protocol (AHP): The communication protocol allowing the Agent Host to run independently of the UI window (enabling remote/cloud/local flexibility).
• Permission Modes: Three tiers of agent autonomy: Default (manual approval), Bypass (auto-approve all), and Autopilot (autonomous task completion with iteration loops).
• BYOM (Bring Your Own Model): The capability to integrate third-party LLM providers (Anthropic, Mistral, Hugging Face) directly into VS Code without requiring a GitHub Copilot subscription.
• Code Tunnels: A feature enabling secure remote access to VS Code workspaces from different devices (e.g., mobile to desktop).

---

1. The Agents Window

The VS Code team has shifted from an "editor-centric" chat panel to an "agent-first" dedicated window.

• Functionality: It allows users to manage multiple sessions across different repositories and workspaces simultaneously.
• Architecture: The window acts as a UI client, while the Agent Host handles the heavy lifting. Because of the Agent Host Protocol (AHP), the host can reside on a remote machine (via SSH or tunnels), allowing users to close their local window and reconnect from another device (e.g., mobile or a different browser instance) without losing session state.

2. Remote Connectivity and Mobile Integration

The video demonstrates using Code Tunnels to bridge devices.

• Process: By running code-insiders tunnel (or code space tunnel), a user creates a secure bridge.
• Real-world Application: A user can initiate a task on a desktop, then use a mobile device to monitor progress, provide approvals, or issue new commands. The UI streams the agent's output and tool-call requests to all connected clients in real-time.

3. Permission Modes and Autopilot

To manage agent autonomy, VS Code introduced three distinct permission levels:

• Default: Requires manual user approval for every tool call (e.g., file edits, terminal commands). Includes Sandboxing to prevent unsafe execution.
• Bypass: Automatically approves all tool calls, ignoring specific settings. It will pause only for user input or if a specific "ask question" tool is triggered.
• Autopilot (Preview): The most advanced mode. It utilizes a Task Complete Tool and system prompts to determine if a goal is achieved. If not, it enters an iteration loop to continue working until the task is finished. It also supports "Plan Mode," where the agent plans the steps before executing them autonomously.

4. Bring Your Own Model (BYOM)

VB demonstrated how to use VS Code as an AI-agnostic editor, independent of GitHub Copilot.

• Configuration: Users can navigate to the "Manage Language Models" view to add providers like Anthropic or custom endpoints (e.g., Mistral).
• Customization: Integration is handled via a chat-language-models.json file, where users can define:
  • Constraints: Max input/output tokens.
  • Capabilities: Enabling vision, tool calling, or "thinking" models.
• Extensibility: Third-party extensions (e.g., Hugging Face) can be installed to pull specific models into the picker.
• Utility Models: VS Code allows users to assign specific "BYOM" models to background tasks like generating commit messages or renaming symbols.

5. Notable Quotes and Technical Insights

• On the shift in workflow: "We're getting into a world where we're running multiple agents at the same time... having just a single chat in the editor may be not enough." — Justin
• On Autopilot: "It also has a new thing called the task complete tool... it will continue to loop and loop and loop if it thinks that the task isn't done." — Justin
• On AI-first editing: "We want to let you use the models of your choice with the provider of your choice... VS Code lets you use your model of choice with our init harness." — VB

Synthesis

The VS Code team is aggressively evolving the editor into an AI-first platform. By decoupling the UI (Agents Window) from the execution logic (Agent Host) and providing granular control over model providers and agent autonomy (Autopilot), they are enabling a highly flexible, remote-capable development environment. The transition toward autonomous agents is balanced by new safety features like sandboxing and explicit permission modes, ensuring that developers can scale their productivity while maintaining control over their codebase.