Build AI Agents as VS Code Extensions

Standard autocomplete tools provide limited, generic suggestions without understanding the entire application's context. AI agents, by contrast, are context-aware, comprehending how user queries relate to the application's specific structure. This enables them to not just suggest actions but to actively execute tools, directly modifying code and automating tasks.

Agents leverage customizable 'skills,' which are specific instructions tailored for particular development tasks. This autonomous behavior allows them to complete complex operations independently, transforming them from passive assistants into active contributors in the development workflow.

Generic agents, such as Claude Code, are designed to handle a broad array of common requests, necessitating extensive configuration for specific use cases. Building a custom agent, however, offers unparalleled control over its appearance, functionality, and integration into existing workflows. Developers can embed domain-specific skills directly, eliminating the need for constant manual adjustments.

Custom agents enable the implementation of proprietary Model Context Protocol (MCP) servers tailored to unique business problems and domains. This level of customization extends to the entire build cycle and user experience, providing a personalized and efficient tool that precisely meets an organization's needs.

Connecting to local models, often via tools like LM Studio, eliminates the token costs associated with cloud-based Large Language Models (LLMs). Running models within the local development environment leverages the developer's existing hardware, bypassing remote cloud resource charges entirely.

This approach not only reduces operational expenses but also facilitates extensive testing within the immediate development setup. Developers can iterate on agent behavior and tool integration without incurring continuous per-token fees.

A custom agent can be triggered by a simple slash command, initiating a specific skill designed for a particular task. In a demonstration, the agent processed multiple steps, including validating file paths to ensure correct execution. The user could audit the agent's 'thinking' process as it analyzed the input and determined the next steps.

Integrated tools, such as the ExtJS lint, allowed the agent to automate the identification of deprecations between different versions of a codebase. This capability demonstrates how agents move beyond mere suggestions to actively modify and improve code quality.

The demonstration highlighted the agent's ability to execute complex operations by combining contextual understanding with integrated development tools. This autonomous execution streamlines development workflows, especially for repetitive or migration-related tasks.

The agent not only identified issues but also provided actionable insights based on its analysis, showcasing its role as an intelligent assistant capable of delivering tangible improvements to the codebase.

Each major model provider, including Claude, Gemini, and OpenAI, offers its own unique Software Development Kit (SDK). This forces developers to implement distinct codebases to interact with each platform, even for accomplishing fundamentally similar tasks.

This fragmentation leads to significant repetitive coding, as developers must re-write or adapt their integrations every time they switch or add a new LLM provider. The lack of a unified interface complicates multi-model strategies and increases development overhead.

It provides a single, generic SDK that developers can use to communicate with any ACP-compliant model. This eliminates the need to write separate code for each LLM provider.

Developers can write a single set of code to interact with any ACP adapter, regardless of the underlying model. This standardization means switching between different LLM providers, such as Claude or Gemini, becomes a simple configuration change rather than a significant code rewrite.

This protocol allows agents to move beyond theoretical understanding to practical execution, interacting directly with system utilities like Bash, file read/write operations, or custom linting tools.

By enabling agents to utilize these tools, MCP transforms them from passive information providers into active performers within the development environment. This capability allows agents to not only analyze code but also to make and implement direct changes, automating complex tasks previously requiring manual intervention.

This allows developers to embed agent functionality, making it an intrinsic part of their daily coding workflow rather than an external application.

The underlying architecture often utilizes webview providers to instantiate React-based user interfaces for the agents within the IDE. This approach ensures a rich, interactive, and familiar user experience that aligns with modern web development practices.

Communication between the VS Code extension and the Large Language Model (LLM) is facilitated through the Agent Client Protocol (ACP) layer. This standardized protocol ensures that the agent can interact with various LLM providers without requiring extensive code changes.

By leveraging VS Code's extensibility features, developers can create powerful, context-aware AI agents that enhance productivity and streamline development tasks directly within their preferred integrated development environment.

Companies operating in highly regulated fields, such as healthcare (patient software) and human resources (payroll), face strict requirements regarding data residency and control. Local models offer a critical solution by ensuring that sensitive data remains within specified jurisdictions and is not utilized for external training by cloud-based model providers.

Compliance with acts like cyber resilience regulations often necessitates explicit knowledge of data location at all times. Running models locally guarantees that data never exits the controlled environment, providing a robust defense against data sovereignty issues and regulatory breaches.

Despite these limitations, local models are highly effective for specific applications such as tool calling and generating structured outputs. Their performance in these areas makes them valuable for targeted tasks, even if they cannot yet rival the advanced reasoning capabilities of large-scale cloud AI.

AI providers frequently update or entirely replace their models, which can significantly disrupt token budgets, API behaviors, and project planning for developers. These changes in model specifications create unpredictability, forcing development teams to constantly adapt their integrations.

Development cycles rely on predictable capabilities and consistent performance from AI models. When cloud providers alter these parameters, it creates instability that can lead to unexpected costs and delays. Local models serve as a necessary backup strategy, offering a stable and controlled environment to mitigate the risks associated with changing AI provider policies.

Custom agents provide businesses with the ability to implement proprietary workflows and generate outputs tailored to their specific operational standards, moving beyond generic tool outputs. This level of control allows for the creation of unique, business-specific functionalities.

These agents can deliver 'shrink-wrap' solutions for specialized tasks, such as automated application upgrades or compliance checks, directly through a custom interface. This bespoke approach ensures that the agent's behavior aligns perfectly with internal processes.

Standardizing on protocols like MCP/ACP ensures that the underlying development tools remain portable and interoperable across different agent frameworks. This future-proofs integrations and allows for flexibility in evolving AI ecosystems.

By allowing developers to control the agent's interface and user experience, custom agents significantly improve UI/UX consistency compared to relying on off-the-shelf agents. This leads to a more integrated and intuitive developer experience.

This allows developers to use a single set of code to communicate with various ACP-compliant models, significantly simplifying the integration process.

A public HTTP registry further facilitates this simplification, enabling easy configuration of LLM providers for Visual Studio Code extensions. Developers can effortlessly switch between different models by modifying a configuration, rather than rewriting core agent logic.

This unified codebase approach dramatically reduces development complexity and maintenance overhead. It fosters greater flexibility in selecting and experimenting with different LLM capabilities without incurring prohibitive engineering costs.

The ACP's architecture ensures that an agent's core logic remains independent of the specific LLM provider, making AI integration more robust and adaptable to future changes in the AI landscape.

Kai's ability to view code, make autonomous decisions, and even perform edits (with permission) directly influenced the design philosophy for new AI agents.

The core idea revolves around creating a 'companion' agent that can interact intelligently with a developer's codebase. This concept of an intelligent code assistant is broadly applicable across various Integrated Development Environments (IDEs), extending beyond specific platforms.

Skills and Model Context Protocol (MCP) servers can be packaged directly within a VSX (Visual Studio Code Extension) file, simplifying deployment for developers. This bundling capability ensures that all necessary components are delivered as a single unit.

Packaging MCP servers and skills inside the extension eliminates the need for users to manually configure local environments or install separate dependencies. This significantly reduces setup friction, making the agent instantly usable upon installation.

This integrated approach creates a 'just works' user experience by consolidating all standalone processes and functionalities into a self-contained extension. Developers benefit from a streamlined workflow, as the agent is fully operational without additional configuration steps.