Build software with an agent-first desktop IDE

Polypore

An agentic desktop IDE that treats the agent as the primary actor, not a sidebar.

Language agnostic, OS agnostic. Every surface is a dockable panel you can split, reorder, or close. The built-in panels cover most workflows; when they don't, the SDK is there.

Demo

https://github.com/user-attachments/assets/a3961bf3-46cd-4168-8e12-9acfcb2bf6b7

Screenshots

Editor: Monaco with a live file tree and per-project diagnostics.	Debug: verify runs and checks on the left, the side-by-side diff and history feed docked on the right.
Memory: a project knowledge base wired together with [[wikilinks]].	Agent: the formation canvas, skills, MCP servers, and secrets in one place.

Install

Download the build for your platform from the latest release. Polypore updates itself after the first install.

On Linux the AppImage needs FUSE (fuse2 on Arch). Mark it executable and run it:

chmod +x Polypore_*_amd64.AppImage
./Polypore_*_amd64.AppImage

To build from source instead, see Getting started below.

Why Polypore

The agentic tooling space moves fast. The right models, CLIs, and orchestration patterns shift faster than a typical IDE ships releases, so Polypore is built to keep up instead of freezing a stack in place. This is not a code editor with an agent panel bolted on. The layout, the memory, the debug tooling, and the MCP server are all designed around the agent doing the work and a human steering it.

Polypore is designed to be:

• Agent-first: every panel is wired into an MCP server, so an agent can drive the editor, debugger, and memory the same way you do.
• Swappable: each surface is a sandboxed panel behind one shared contract, so any piece can be extended, replaced, or dropped without touching the core.
• Language and OS agnostic: per-project config registries instead of a hardcoded toolchain, with builds for Linux, macOS, and Windows.
• Yours: secrets stay in the OS keyring, the model never sees plaintext, and there is no telemetry.

Panels

The built-in panels, all available from the + tab button:

SDK and plugins

Third-party panels are sandboxed iframes using the same HostRpcServer contract as the built-ins. Write a plugin in any framework, drop it in .polypore/plugins/<id>/, and it appears in the panel strip. Agents can drive it through the MCP server the same way they drive built-in panels.

polypore-ide MCP server

A Node MCP sidecar ships with Polypore. Claude Code picks it up from .mcp.json automatically. It gives agents direct IDE control through 22+ tools:

Secret broker

Secrets live in the OS keyring. When Polypore spawns an agent it strips every registered secret from the environment and replaces it with a POLYPORE_SECRET_HANDLE_<KEY> sentinel. Agents call polypore.secrets.use with an HTTP request; Polypore injects the value and masks it on the way back. The model never sees plaintext.

Polyflow skills

15 slash commands in packages/polyflow/ covering the full development loop:

/polyflow /polyflow-go /polyflow-brainstorming /polyflow-writing-plans /polyflow-executing-plans /polyflow-tdd /polyflow-iterate /polyflow-debug /polyflow-review /polyflow-design-interface /polyflow-prd /polyflow-improve-architecture /polyflow-qa /polyflow-glossary /polyflow-compact

Stack

Getting started

Prerequisites: Node 20+, Rust stable (rustup). Linux also needs libwebkit2gtk-4.1-dev libgtk-3-dev libayatana-appindicator3-dev librsvg2-dev.

npm ci
cd src-tauri && cargo build && cd ..
npm run app

For renderer-only development (no Tauri bridge):

npm run dev

Scripts

Architecture

┌────────────────────────────────────────────────────────────────────┐
│ Tauri shell (Rust, src-tauri/)                                     │
│  ├─ host_broker (HTTP)    → emits Tauri events to the renderer     │
│  ├─ secret_broker (HTTP)  → OS keyring, never returns plaintext    │
│  ├─ agent runtimes        → stdio adapters per CLI; ACP opt-in     │
│  ├─ pty (portable-pty)    ├─ persistence (rusqlite)                │
│  ├─ snapshotter           ├─ fs_watch (notify)                     │
│  └─ plugin:// protocol    → serves .polypore/plugins/<id>/<asset>  │
├────────────────────────────────────────────────────────────────────┤
│ Renderer (React + Dockview)                                        │
│  ├─ HostRpcServer (packages/host)  shared contract for all plugins │
│  ├─ PolyporeHost loopback          built-in plugins use this       │
│  ├─ PluginLoader                   3rd-party iframes use this      │
│  └─ built-in panels (plugins/)                                     │
├────────────────────────────────────────────────────────────────────┤
│ polypore-ide MCP sidecar (Node, packages/mcp-server/)              │
│  ├─ 22+ tools → host_broker for live state changes                 │
│  └─ secrets.* → secret_broker, value never returned to agent       │
└────────────────────────────────────────────────────────────────────┘

Contracts live in schemas/ and codegen into packages/sdk/src/types.gen.ts and packages/sdk/src/validators.gen.ts. Run npm run codegen after editing a schema.

Environment variables