When we open-sourced PlanOpticon five weeks ago, it did one thing well: extract knowledge from video. You pointed it at a meeting recording, conference talk, or training session, and it gave you a transcript, diagrams, action items, key points, and a knowledge graph. The problem it solved was simple – nobody rewatches meetings – and the tool was focused on that problem.

Five weeks later, PlanOpticon does substantially more. Versions 0.4.0 and 0.5.0 have shipped in rapid succession, and the tool has evolved from a single-purpose video analyzer into a comprehensive planning platform. This post covers what changed, why it changed, and what it means for the roadmap.

The short version: users told us what they actually needed, and it was not just video analysis. It was everything that comes after video analysis – the planning, the organizing, the turning-knowledge-into-action work that was the whole reason they were analyzing videos in the first place.

The Pattern We Kept Seeing

After the initial open-source release, we watched how people used PlanOpticon. We paid attention to the issues they filed, the feature requests, and the workflows they described. A clear pattern emerged.

People were not just extracting knowledge from videos. They were extracting knowledge from videos and then immediately switching to other tools to do something with that knowledge. They would analyze a strategy meeting, then switch to a project management tool to create tasks from the action items. They would extract insights from a series of recorded planning sessions, then switch to a document editor to write a PRD. They would build a knowledge graph from a conference talk series, then switch to a diagramming tool to visualize the relationships.

The knowledge extraction was the starting point, not the destination. And the context switch between “I have the knowledge” and “now I need to act on the knowledge” was where friction lived.

This is the kind of insight you only get from real usage. No amount of roadmap planning in a conference room would have surfaced it as clearly as watching users bounce between PlanOpticon and three other tools to complete a single workflow.

So we built the rest of the workflow into PlanOpticon.

v0.4.0: The Planning Agent (March 7, 2026)

Version 0.4.0 was the larger of the two releases, and it fundamentally changed what PlanOpticon is. The headline addition was a Planning Agent Framework that turns PlanOpticon from a passive analysis tool into an active planning partner.

11 Specialized Planning Skills

The Planning Agent ships with 11 skills that cover the core activities of software project planning:

1. Project planning – generate structured project plans from extracted knowledge, with phases, milestones, dependencies, and resource estimates.
2. PRD generation – produce product requirements documents from meeting transcripts, design discussions, and stakeholder interviews.
3. Roadmapping – create multi-quarter roadmaps that align extracted goals, milestones, and deliverables into a timeline.
4. Task breakdown – decompose high-level goals and features into implementable tasks with effort estimates and dependencies.
5. GitHub issue management – create, update, and organize GitHub issues directly from extracted knowledge, maintaining traceability from source material to issue.
6. Pull request management – generate PR descriptions from extracted specifications, link PRs to related issues, and track implementation against plans.
7. Requirements analysis – classify and analyze requirements extracted from any source material, identifying gaps, conflicts, and dependencies.
8. Documentation generation – produce technical documentation, runbooks, and guides from accumulated knowledge graph data.
9. Artifact export – package planning outputs into formats consumable by other tools and platforms.
10. Wiki generation – create structured wikis from knowledge graphs, organized by topic with cross-references and navigation.
11. Planning taxonomy classification – automatically classify extracted knowledge into a planning taxonomy: goals, risks, milestones, requirements, and tasks.

The taxonomy classifier deserves a specific mention. It applies a structured classification to everything PlanOpticon extracts, tagging each piece of knowledge as a goal, a risk, a milestone, a requirement, or a task. This classification feeds into all the other skills. When you ask the Planning Agent to generate a project plan, it draws on the classified knowledge to populate the plan with real content from your source material, not generic templates.

Interactive REPL Companion

The Planning Agent comes with an interactive REPL (Read-Eval-Print Loop) that provides a command-line interface for exploring and manipulating knowledge graphs and planning outputs. It ships with 15 slash commands for graph exploration:

• Navigate entities and relationships in the knowledge graph
• Query for specific patterns (e.g., “show me all risks related to this milestone”)
• Generate planning artifacts interactively
• Export subsets of the graph for specific purposes
• Visualize connections between extracted knowledge items

The REPL is designed for the kind of exploratory work that planning requires. You do not always know what you are looking for until you see it. Being able to traverse a knowledge graph interactively, ask questions, and generate artifacts on the fly matches how planning actually works – iterative, non-linear, and discovery-driven.

20+ Data Source Connectors

This was the other major expansion in v0.4.0. PlanOpticon started as a video analysis tool. It now ingests content from over 20 sources:

Video and audio: YouTube (direct URL support), podcast feeds, Zoom recordings, Microsoft Teams recordings, Google Meet recordings.

Documents and notes: Google Drive, Dropbox, Google Workspace (Docs, Sheets, Slides), Microsoft 365 (Word, Excel, PowerPoint), Notion, Obsidian vaults, Logseq graphs, OneNote notebooks.

Development and research: GitHub (repos, issues, PRs, discussions), arXiv papers, S3 buckets.

Community and feeds: Reddit threads, Hacker News discussions, RSS feeds.

The connector architecture is pluggable, so adding new sources is straightforward. Each connector handles authentication, content retrieval, and format normalization, converting the source material into the common format that PlanOpticon’s analysis pipeline expects.

Why so many connectors? Because planning knowledge does not live in one place. A product roadmap might draw from recorded stakeholder interviews (video), competitive analysis (web), technical constraints documented in GitHub issues (development), research papers that inform the approach (arXiv), and internal design documents (Google Drive or Notion). PlanOpticon can now ingest all of these, build a unified knowledge graph, and use the Planning Agent to produce planning artifacts from the combined context.

Infrastructure Changes

Two infrastructure changes in v0.4.0 are worth highlighting because they reflect a deliberate design philosophy:

SQLite replaced FalkorDB. The original PlanOpticon used FalkorDB, a graph database, for storing knowledge graphs. FalkorDB is a solid graph database, but it was an external dependency that required separate installation and management. We replaced it with SQLite, which ships with Python and requires zero external configuration. This means PlanOpticon has no external service dependencies. You install it and it works. No database to set up, no Docker containers to run, no services to manage.

This was a pragmatic trade-off. We lost some graph query performance for very large graphs. We gained a dramatically simpler installation and operational model. For the graph sizes PlanOpticon typically handles (thousands to low tens of thousands of nodes), SQLite performs more than adequately.

Default models shifted to cost-efficient options. The initial release defaulted to frontier models: Claude Sonnet, GPT-4o. Version 0.4.0 defaults to cost-efficient options: Claude Haiku, GPT-4o-mini, Gemini Flash. For most PlanOpticon tasks – transcription, classification, entity extraction, summarization – these models perform comparably to frontier models at a fraction of the cost. Users who want to use frontier models still can; the defaults just no longer assume everyone has a budget for them.

Document Generation and Export

PlanOpticon can now generate documents in 7 formats without any LLM dependency. This means you can produce structured output – project plans, requirements documents, reports – using only the data in your knowledge graph and deterministic templates. No API calls, no token costs, no latency.

Export targets now include Obsidian vaults (with proper wiki-link formatting and frontmatter), Notion-compatible markdown, GitHub wiki format, and an interactive D3.js viewer for graph visualization. The D3.js viewer is particularly useful for presentations and stakeholder reviews – it renders the knowledge graph as an interactive, browser-based visualization that non-technical stakeholders can explore.

v0.5.0: Polish, Performance, and Reliability (March 8, 2026)

Version 0.5.0 shipped one day after v0.4.0. Where v0.4.0 added capabilities, v0.5.0 focused on making those capabilities reliable, fast, and easy to adopt.

Cross-Platform Installation

The most requested feature after the initial release was easier installation. Despite being a Python package available on PyPI, many users encountered friction with Python version management, virtual environments, and dependency conflicts.

Version 0.5.0 includes a cross-platform one-command installation script that handles Python version detection, virtual environment creation, dependency installation, and PATH configuration. On macOS, Linux, and Windows (via WSL or PowerShell), the install is a single command that produces a working planopticon CLI.

Two new commands support the installation experience:

• planopticon init – a setup wizard that walks through initial configuration: API key setup, default model selection, output directory preferences, and connector configuration.
• planopticon doctor – a diagnostic command that checks the installation, verifies API key validity, tests model connectivity, validates dependencies, and reports the system state. When something is not working, planopticon doctor tells you what and why.

Performance Improvements

Two performance changes made a significant difference for users processing large volumes of content:

Parallel frame analysis via ThreadPoolExecutor. Video analysis involves extracting frames and analyzing each one for diagrams, slides, and visual content. Previously, this was sequential. Version 0.5.0 parallelizes frame analysis, distributing work across available CPU cores. For a typical 60-minute meeting recording, this reduces analysis time by 40-60% depending on hardware.

Content-hash caching to skip re-analyzed frames. PlanOpticon now computes content hashes for extracted frames and caches analysis results. When re-analyzing a video (common during iterative workflows), frames that have not changed are skipped. For re-analysis of a previously processed video with minor edits, this can reduce processing time by 80-90%.

Graph Query Capabilities

The knowledge graph gained two new query capabilities:

Shortest path finding – given two entities in the graph, find the shortest path of relationships connecting them. This is useful for understanding how concepts relate to each other through intermediary connections. How does a risk item connect to a specific deliverable? What is the chain of dependencies between two features?

Connected component detection – identify clusters of closely related entities within the graph. This surfaces natural groupings in the extracted knowledge that may not be obvious from reading individual items. A knowledge graph from a series of planning meetings might reveal three distinct clusters of work that could be parallelized.

Report Generation

New report generation capabilities add professional output formats:

PDF reports via reportlab – generate formatted PDF reports from knowledge graphs and planning artifacts. Reports include table of contents, structured sections, embedded diagrams, and consistent styling. These are presentation-ready documents, not raw dumps.

PPTX slide decks via python-pptx – generate PowerPoint presentations from planning artifacts. Particularly useful for stakeholder presentations where you need to communicate extracted insights and proposed plans in a familiar format.

Developer Experience

Several quality-of-life improvements for developers and power users:

Tab completion for all CLI commands and options. This makes the CLI discoverable without constantly referencing documentation.

Persistent REPL history across sessions. Commands and queries entered in the REPL are saved and accessible via up-arrow navigation in subsequent sessions.

860+ tests passing across Python 3.10-3.13. The test suite has grown substantially from the initial 222 tests at launch. Coverage includes the Planning Agent skills, all data source connectors, graph query operations, report generation, and the installation infrastructure.

The Bigger Picture: What This Evolution Means

PlanOpticon’s trajectory from video analyzer to planning platform was not planned in a traditional roadmap sense. It was driven by a feedback loop: release, observe usage, identify friction, build what removes that friction.

This is the pattern we advocate for in our AI-native development approach. Build the smallest useful thing. Ship it. Watch what happens. Let real usage – not theoretical feature prioritization – drive the roadmap. The Planning Agent Framework did not come from a brainstorming session. It came from watching users extract action items from a meeting recording and then manually copy them into GitHub issues one by one.

The evolution also reflects something we believe strongly about AI tools: they should reduce the distance between insight and action. Extracting knowledge from a video is insight. Creating a project plan from that knowledge is action. If the user has to leave your tool and context-switch to bridge that gap, you have not finished the job.

PlanOpticon is now a tool that spans that distance. Ingest content from wherever it lives. Extract and classify the knowledge it contains. Build a unified knowledge graph. Generate planning artifacts. Export to the platforms where work happens. The full loop, from raw content to actionable plans, without leaving the tool.

What Is Next

The roadmap is guided by the same principle that shaped v0.4.0 and v0.5.0: build what users actually need.

Current areas of focus:

• Collaboration features – multi-user knowledge graphs with merge and conflict resolution. Planning is a team activity, and PlanOpticon needs to support that.
• Streaming analysis – real-time processing of live meetings, not just recordings. The knowledge graph updates as the meeting progresses.
• Custom planning skills – a plugin API that lets users define their own Planning Agent skills tailored to their specific workflows and organizational processes.
• Integration with project management platforms – direct bi-directional sync with Jira, Linear, Asana, and similar tools, so planning artifacts stay in sync with execution tracking.

PlanOpticon is MIT licensed, open source, and actively maintained. If you work with video content, meeting recordings, or any form of unstructured knowledge that needs to become structured plans, we would appreciate you taking it for a spin.

• GitHub: github.com/ConflictHQ/PlanOpticon
• Documentation: planopticon.dev
• PyPI: pypi.org/project/planopticon

pip install planopticon
planopticon init
planopticon doctor
planopticon analyze -i recording.mp4 -o ./output

Four commands from zero to your first knowledge graph and project plan. We built PlanOpticon because we needed it. We open-sourced it because we think you might need it too.