Agentic Coding Needs More Than a Bolted-On Chat Box Polypore, a new open-source IDE built with Tauri and React, redesigns the development environment to treat AI agents as first-class citizens rather than sidebar assistants. By exposing editor, terminal, debugger, and file system components as modular services via the Model Context Protocol, the IDE enables agents to directly control debugging, testing, and code manipulation without manual copy-paste. This approach aims to overcome the limitations of current AI coding tools that rely on chat panels bolted onto traditional editors. Dev Tools https://www.devclubhouse.com/c/dev-tools Article Agentic Coding Needs More Than a Bolted-On Chat Box Why the future of AI-assisted development demands a fundamental redesign of the IDE, not just sidebar extensions. Lenn Voss https://www.devclubhouse.com/u/lennart voss If you have spent any time lately working with AI coding assistants, you have probably noticed a pattern. Whether it is an extension in VS Code or a dedicated fork, the interface almost always defaults to a chat panel bolted onto the side of a traditional text editor. It is a neat trick for quick refactors or generating boilerplate, but as a workflow, it quickly hits a wall. The developer is forced to act as a manual copy-paste bridge between the chat window and the workspace, while the underlying AI agent remains blind to the active state of the terminal, the debugger, and the project's broader context. Treating an AI agent as a backseat driver shouting suggestions through a narrow sidebar window is a fundamental design bottleneck. True agentic development requires an IDE where the agent is a first-class citizen, equipped with direct, programmatic access to every layer of the development environment. A new open-source project called Polypore https://github.com/evanklem/polypore is attempting to prove exactly this. By building a modular, desktop-native IDE from the ground up, Polypore shifts the focus from "editor with an AI assistant" to "environment designed for autonomous agents." The Limitations of the Sidebar Paradigm In a typical setup, an AI tool has limited ways to interact with your workspace. It can read the files you feed it, write code blocks to its chat interface, and perhaps apply diffs if the extension has write permissions. However, it lacks a cohesive understanding of the runtime state. When an agent runs a test suite and it fails, the agent cannot easily inspect the call stack, set a breakpoint, step through the execution, or query the local database to see what went wrong. It relies on the developer to copy-paste terminal errors back into the chat. This high-friction loop exists because traditional IDEs were architected for human eyes and human hands. The APIs exposed to extensions are often restricted, preventing an external LLM from truly driving the environment. To break this bottleneck, an agentic IDE needs to treat every component—the editor, the terminal, the debugger, and the file system—as a set of modular services that both humans and agents can query and manipulate in real time. Designing for the Agent as a Primary Actor Polypore approaches this by leveraging a highly modular, desktop-native architecture. Built using Tauri https://tauri.app 2 and Rust for the shell, with a React https://react.dev 18 and Vite https://vite.dev frontend, the IDE is structured so that every interface element is a sandboxed panel operating behind a shared contract. Instead of a rigid layout, Polypore uses Dockview to allow developers and potentially agents to split, reorder, or close panels as needed. The editor itself is powered by the Monaco Editor https://microsoft.github.io/monaco-editor/ , but the real magic lies in how these panels communicate. Rather than relying on proprietary APIs, Polypore ships with a built-in Node sidecar that runs a Model Context Protocol MCP server. This allows agentic command-line tools, such as Claude Code, to automatically discover and control the IDE via a local .mcp.json configuration. The agent does not just suggest code; it drives the IDE through more than 22 specialized tools. Deep Tooling Integration via MCP By exposing the IDE's internals through structured JSON-RPC namespaces, Polypore allows an agent to perform complex engineering tasks that would normally require manual developer intervention. These namespaces cover the entire development lifecycle: : Allows agents to start debugging sessions, set breakpoints, step through code, and capture console, DOM, or network logs directly from the running application. polypore.debug. : Enables agents to declare and run verification suites to ensure their changes do not break existing functionality. polypore.verify. : Connects the agent to a project-specific knowledge base utilizing wiki-style links, allowing the agent to read, write, and hand off context documents to subsequent runs. polypore.memory. : Allows the agent to update its current progress and report its active workflow phase directly to the live UI, keeping the human developer informed without spamming a chat log. polypore.tasks. and polypore.phase. This level of integration transforms the agent from a simple text generator into an active operator. If a test fails during a test-driven development TDD cycle, the agent can programmatically trigger a debug run, inspect the state, fix the code in Monaco, and verify the fix—all without the developer touching the keyboard. Solving the Secret Leakage Problem Giving an autonomous agent free rein over an IDE introduces massive security risks, particularly around API keys, database credentials, and environment variables. If an agent is compromised or behaves erratically, it could easily exfiltrate sensitive secrets via outbound HTTP requests. Polypore addresses this with a dedicated "secret broker" backed by the OS keyring. When the IDE spawns an agent, it strips all registered secrets from the environment variables, replacing them with unique sentinel placeholders e.g., POLYPORE SECRET HANDLE