For decades, the “rubber duck” has been a staple of the developer’s desk, serving as a silent, plastic sounding board for troubleshooting complex logic. The practice of explaining code line-by-line to an inanimate object often reveals the very flaws that a solo developer might overlook. With the release of Visual Studio Code 1.135 on August 26, Microsoft has digitized this concept into a functional AI component. The update introduces an experimental Rubber Duck agent designed to act as a built-in critic for primary AI interactions. By providing a second opinion on code, plans, and tests, this new agent aims to transform how developers validate AI-generated output within their primary workspace.
The arrival of version 1.135 marks a significant step in the evolution of integrated development environments (IDEs). While previous updates focused on the speed of code generation, this release prioritizes the accuracy and reliability of those generations through a multi-agent architecture. By integrating a “critic” directly into the workflow, Visual Studio Code addresses the growing need for oversight in agentic workflows, where AI is increasingly responsible for complex, multi-step tasks rather than simple autocompletion. This shift is supported by the new Agent Host Protocol, which provides the technical foundation for these sophisticated interactions.
The Evolution of the Critic Agent in VS Code
The standout feature of Visual Studio Code 1.135 is the Rubber Duck agent, an experimental tool that serves as a dedicated critic for the primary AI agent. Unlike standard AI assistants that focus on generating code, the Rubber Duck agent is specifically tasked with providing a constructive second opinion on the primary agent’s proposed plans and tests. This feature originally debuted in the GitHub Copilot CLI in April and has now been integrated directly into the VS Code environment to surface missed details or edge cases that a single model might ignore.
A key technical differentiator of the Rubber Duck agent is its use of a different underlying AI model than the one driving the main session. According to InfoWorld, this cross-model approach ensures objectivity. When a single model generates code and then reviews its own work, it is prone to the same biases and “hallucinations” that created the original error. By utilizing a secondary, distinct model, the Rubber Duck agent can provide a truly independent perspective. This helps ensure that the logic is sound and that the proposed solution addresses the problem without introducing new vulnerabilities.
In practice, the Rubber Duck agent acts as an automated peer reviewer. When the primary agent suggests a complex refactor or a new test suite, the Rubber Duck evaluates the plan for potential pitfalls. Microsoft suggests that this helps surface edge cases that are often missed during rapid development cycles. For developers, this means the AI is no longer just a “doer” but also a “checker,” creating a more robust feedback loop that mirrors the traditional pair-programming experience.
The following table illustrates the functional differences between the primary coding agent and the new Rubber Duck critic within the VS Code 1.135 ecosystem:
| Feature | Primary AI Agent | Rubber Duck Agent |
|---|---|---|
| Core Function | Generation and Execution | Critique and Validation |
| Underlying Model | User-selected (e.g., GPT-4o, Claude) | Independent/Different from Primary |
| Primary Output | Code snippets, refactors, test files | Second opinions, edge case alerts |
| Best Use Case | Initial drafting and boilerplate | Validating complex logic and plans |
Benchmarking the Impact of Multi-Model Review
The performance benefits of utilizing a critic agent like Rubber Duck are supported by data from the SWE-Bench Pro benchmark. This benchmark evaluates the ability of AI models to solve real-world software engineering problems, such as fixing bugs in large repositories. According to reports from NTCompatible, the combination of a primary model like Claude Sonnet and the Rubber Duck agent closed 74.7% of the performance gap between the standard Sonnet model and the more powerful Opus model. This suggests that a smaller, faster model paired with a critic can rival the performance of much larger, more expensive models.
The impact is particularly noticeable when tackling “hard problems,” defined as tasks involving more than three files and requiring over 70 steps to complete. In these scenarios, the integration of the Rubber Duck agent resulted in scores that were 3.8% to 4.8% higher than the baseline performance of the primary model alone. This indicates that the critic agent is most effective when the complexity of the task increases, as these are the situations where human developers are most likely to miss subtle architectural flaws.
From a cost-benefit perspective, running a second “critic” model is often more efficient than relying solely on a single, top-tier model. While the second model adds a layer of token usage, the reduction in debugging time and the prevention of logical errors provide a significant return on investment. Developers can achieve high-tier results without the latency or expense typically associated with the largest available language models. This makes the Rubber Duck agent an essential tool for maintaining high code quality in professional environments where accuracy is non-negotiable.
Standardizing Workflows with the Agent Host Protocol
Beyond the individual agents, Visual Studio Code 1.135 introduces the Agent Host Protocol (AHP), an open standard designed to treat coding agents as shared resources. The Agent Host is a dedicated process that runs agent harnesses and sits between the IDE and various agent backends. This architecture allows the agent host to own the authoritative session state, ensuring that the agent’s context remains consistent regardless of how many windows or tools are accessing it. NTCompatible reports that this protocol allows multiple VS Code windows to connect to the same agent session simultaneously.
This development is comparable to the historical impact of the Language Server Protocol (LSP) and the Debug Adapter Protocol (DAP). Just as LSP standardized how editors communicate with programming languages, AHP aims to standardize how IDEs interact with AI agents. By creating a monotonic, totally ordered stream of session data, the host keeps all connected clients perfectly synchronized. If a developer makes a change in one window, the agent’s state is updated across all other connected windows in real-time, preventing context fragmentation.
The strategic importance of Microsoft establishing an open standard like AHP cannot be overstated. By positioning VS Code as the universal runtime for AI agents, Microsoft is ensuring that the editor remains the central hub of the development lifecycle. As AI agents become more autonomous, having a standardized protocol for their execution and communication will be critical for interoperability between different tools and platforms. This move effectively locks in the IDE as the primary “agentic layer” for modern software engineering.
Session Portability and Cross-Application Continuity
One of the most practical improvements in version 1.135 is the ability to maintain session continuity across different applications. Developers can now see and continue recent agent sessions created in other tools, such as the standalone Claude app or the GitHub Copilot CLI, directly within VS Code. This feature is powered by the Copilot SDK, which aligns the behavior of the agent across the CLI, web interfaces, and the IDE. According to InfoWorld, this creates a seamless transition for developers who may start a prompt on a mobile device or web browser and need to finish the implementation in their local coding environment.
Portable sessions significantly reduce the friction associated with context-switching. In traditional workflows, moving from a chat-based AI tool to an IDE requires the developer to manually copy-paste code and re-explain the context to the IDE’s built-in assistant. With the new session continuation features, the full history and intent of the conversation are preserved. This allows for a “start anywhere, finish in VS Code” workflow that respects the developer’s current focus and reduces the mental overhead of re-establishing context.
The integration also benefits from the Agent Host Protocol’s ability to broadcast session changes. Because the host maintains the “source of truth” for the conversation, the transition between a terminal-based CLI and a graphical IDE window is instantaneous. This level of synchronization is essential for teams that utilize a variety of AI-assisted tools throughout the day, ensuring that the AI “memory” is never lost as the developer moves between different stages of the software development life cycle.
Enhancing Transparency with UX and Token Breakdowns
To support the management of these complex agent interactions, Visual Studio Code 1.135 includes several UX refinements and transparency features. The chat response footer has been redesigned to include per-model token usage breakdowns. This view provides specific data on input tokens, cached tokens, and output tokens for every interaction. Daily.dev notes that this level of transparency is critical for developers who need to manage API costs and stay within the context limits of their chosen AI models.
In addition to token tracking, the Agents window has received a significant layout update. The new streamlined side layout simplifies session controls and makes it easier to manage multiple active agents. By organizing these controls into a more intuitive interface, VS Code allows developers to focus on the code rather than the configuration of the AI tools. This is particularly important when running the Rubber Duck agent alongside a primary assistant, as it prevents the interface from becoming cluttered with competing windows.
These UX improvements reflect a shift toward treating AI agents as first-class citizens within the IDE. By providing clear metrics on how much data is being processed and which models are active, VS Code empowers developers to make informed decisions about their AI usage. This transparency is vital for professional operations where developers must justify the use of specific tools based on both performance and cost. The streamlined layout further ensures that these powerful tools remain accessible without overwhelming the user’s screen real estate.
Implementing the Rubber Duck Workflow
To begin using the experimental Rubber Duck agent, developers must ensure they are running Visual Studio Code 1.135 or later. The agent can be accessed through the Agents window, where it can be toggled on to provide oversight for the primary session. Once active, the Rubber Duck will automatically analyze the output of the primary agent and offer “second opinions” when it detects potential issues. Developers can also use the new “Sessions” list to resume work that was started in other Copilot-enabled applications, ensuring a unified history across all tools.
While the Rubber Duck agent provides a powerful layer of validation, best practices still dictate a “critique the critic” approach. Developers should treat the Duck’s suggestions as high-quality advice rather than absolute truth. Manual oversight remains necessary to ensure that the AI’s critique aligns with the specific architectural goals of the project. By using the Rubber Duck to catch the “easy” mistakes and edge cases, developers can free up their cognitive resources to focus on high-level design and complex business logic that AI still struggles to fully grasp.
The Future of Agentic Development
The release of Visual Studio Code 1.135 represents a fundamental shift in the developer experience, moving from AI-assisted coding to AI-reviewed coding. By establishing the IDE as a universal runtime for agents through the Agent Host Protocol, Microsoft is laying the groundwork for a more autonomous and reliable development landscape in 2026 and 2027. The Rubber Duck agent is more than just a debugging tool; it is a transition toward a multi-agent future where specialized AI roles work in tandem to produce higher-quality software. As these protocols evolve, the boundary between the developer and the tool will continue to blur, making the “second opinion” of a critic agent an indispensable part of the modern coding workflow.
Frequently Asked Questions
What is the Rubber Duck agent in Visual Studio Code 1.135?
The Rubber Duck agent is an experimental AI component that acts as a critic, providing a constructive second opinion on the primary AI agent's code, plans, and tests to identify logic flaws and edge cases.
How does the cross-model approach improve AI reliability in VS Code?
By using a different underlying AI model than the primary agent, the Rubber Duck agent provides an independent perspective that avoids the biases and hallucinations inherent in a single model reviewing its own work.
What is the purpose of the Agent Host Protocol (AHP)?
The Agent Host Protocol is an open standard that synchronizes AI agent states across multiple IDE windows and tools, ensuring context consistency and treating agents as shared resources.
Does Visual Studio Code 1.135 support session portability?
Yes, version 1.135 allows developers to continue agent sessions started in other applications, such as the GitHub Copilot CLI or the standalone Claude app, directly within the VS Code environment.
