Plumy
Live / Open SourceLocal-first project planning for teams
Open-source planning software for teams that want Timeline, Kanban, and Roadmap planning surfaces, optional AI-assisted workflows, and a local-first desktop path without accounts, hidden telemetry, or a hosted planning service.
How It Works
Plan visually
Timeline planning gives teams a date-based view of project swimlanes, delivery windows, workload shape, and upcoming conflicts.
Useful when you need to understand sequence, duration, and conflicts before work moves into execution.
Execute in Kanban
Kanban columns keep the same tasks moving through execution, review, and handoff without duplicating planning data.
Status, owner, notes, comments, and agent handoff state stay attached to the same task.
Architecture overview
Plumy grew from a visual planner into a local-first workspace with desktop persistence, backup portability, release packaging, Roadmap planning, and an optional MCP interface for agent workflows.
Desktop shell
Electron owns the desktop runtime, packaging, file attachment handling, external links, local storage access, and the local MCP server lifecycle.
Renderer workspace
The React app keeps the planning UI focused on one shared workspace model, with Timeline, Kanban, Roadmap, people, preferences, and details panels reading from the same state.
Three planning surfaces
Tasks can be scheduled visually on a timeline, moved through status columns in Kanban, or grouped into roadmap milestones without splitting the data into separate tools.
Local persistence
The app is local-first. Electron store acts as the canonical desktop persistence layer, while renderer storage remains useful for portability and backup-friendly flows.
Workspace portability
Backup and import include tasks, comments, people, projects, swimlanes, status columns, preferences, MCP settings, and UI state rather than just a partial task export.
Agent interface
A local MCP surface exposes workspace snapshots, task and card projections, board polling, structured comments, and gated revision-protected handoff flows on the user device.
Engineering challenges
The difficult parts were less about making another task board and more about keeping planning, execution, persistence, backups, and agent access aligned around one durable workspace model.
Keeping Timeline, Kanban, and Roadmap in sync
Plumy has to let the same task live comfortably in date-based planning, status-based execution, and milestone planning. The challenge is preserving one source of truth while each view feels natural.
Building dense drag-and-drop planning
The timeline needs swimlanes, horizontal scrolling, task positioning, resizing, reorder flows, and collision-resistant interactions without making the workspace feel heavy.
Making local-first feel dependable
A local desktop product still needs recovery, migration, backup, import, separate dev and packaged stores, and clear storage diagnostics so users can trust the data model.
Designing safe agent workflows
The MCP layer is useful only if it stays understandable and controlled. Plumy exposes native planning primitives to AI systems while keeping execution local, reviewable, and revision-checked when agent access is enabled.
Planning system
Plumy is built around the idea that planning and execution should not require separate tools or duplicated task records.
- Timeline view supports calendar-like scheduling across project swimlanes.
- Kanban view turns the same work into status columns with persistent filters for execution and prioritization.
- Roadmap view adds milestones, task links, filters, and explicit dependency arrows for longer-range planning.
- A shared WorkspaceReadModel feeds Timeline, Kanban, Roadmap, task details, milestone details, and dialogs.
- People management separates human teammates from agentic teammates and tracks workload context.
- Task details support markdown notes, structured comments, and concise completion summaries.
- Preferences expose MCP diagnostics, backup/import, storage usage, and audit log surfaces.
Agent workflow layer
- Plumy is one of the few open-source projects I have seen so far that offers a credible paid-tier style AI interaction model while still running on a local device.
- Agents are not treated as a chat overlay. They can inspect the full workspace snapshot plus task, Kanban-card, and Timeline-card projections through stable MCP tools.
- Board watchers can poll specific statuses with persisted duplicate suppression, so AI systems can participate in real planning loops instead of one-off prompt exchanges.
- Agents can add structured comments and activity entries, update summaries, assign work, and move tasks through review-oriented statuses when write capability is enabled.
- Write operations use expected revisions and can run in read-only or gated modes, giving local AI workflows a product-grade control model instead of unrestricted automation.
Product layer
The public Plumy site emphasizes open-source, local-first planning. Under the surface, the product also needed packaging, release automation, docs, a web migration path, and a planning model that can be projected into multiple product surfaces.
- The public site positions Plumy as open source, local-first, no-account planning software.
- The desktop app is packaged for macOS, Windows, and Linux through release automation.
- The GitHub Pages site is built from the same project and deployed separately from the desktop renderer.
- Plumy Web now extends the product with Convex-backed data, Clerk account flows, roadmap support, comments, and assigned work.
Key Features
- Timeline planning across project and people swimlanes
- Kanban execution with persisted filters and flexible status columns
- Roadmap planning with milestones, task links, and dependency arrows
- Human and agentic teammate management
- Markdown task details, comments, and structured completion notes
- Local MCP workflows with paid-tier interaction quality for AI systems
- Cross-platform desktop packaging for macOS, Windows, and Linux