From Graph Views to Semantic Schemas: Replacing Manual PKM Linking with LLM-Driven Folder Ontologies

For decades, the holy grail of Personal Knowledge Management (PKM) has been the "linked thought"—the ability to create a web of interconnected ideas that mirror the associative nature of human cognition. We have seen the rise and fall of various methodologies designed to achieve this: from the manual backlinking of Obsidian’s graph view to the highly structured, entity-based approach of Tana and Heptabase. However, these systems share a fundamental flaw: they rely on manual friction. The cognitive load required to manually link notes, tag entities, and perform weekly reviews creates a bottleneck that eventually leads to system abandonment.

The emergence of Large Language Models (LLMs) like Claude, Gemini, and Codex has rendered the manual "weekly review" and the manual linking of nodes obsolete. We are moving away from an era of active management toward an era of automated synthesis, where the intelligence lies not in the tool's interface, but in the underlying structural scaffold provided by a localized folder hierarchy.

The Friction of Manual Knowledge Management

Traditional PKM workflows—whether utilizing Obsidian’s networked thought approach or Tana’s super-tagging architecture—require the user to act as the primary indexer. As you capture information (meeting notes, fleeting thoughts, research snippets), you are tasked with:

1. Categorization: Deciding which folder or tag a note belongs to.
2. Linking: Manually creating edges between nodes (e.g., linking a Person entity to a Meeting node).
3. Reviewing: Periodically auditing the "pile" of unorganized notes to extract meaning and prevent data rot.

This manual process is inherently unsustainable. As the volume of captured data increases, the time required for maintenance scales linearly (or even exponentially), leading to what many call "the pile"—a graveyard of unlinked, unreviewed digital artifacts. The transition from a tool like Heptabase or Tana back to a simpler system isn't a regression in capability; it is an optimization of cognitive energy.

The Scaffold: Implementing a Localized Ontology

The breakthrough in replacing manual linking is not found in the LLM itself, but in the scaffold. An LLM, no matter how high its parameter count or reasoning capability, cannot effectively organize unstructured data without a predefined schema. Without context, an AI agent is merely performing sophisticated pattern matching on a vacuum.

The solution lies in a structured local folder system—a concept we refer to as MyPKA. This system utilizes a specific ontology called MyLife, which defines the high-level domains of the user's knowledge base:

• Key Elements: The foundational pillars of the user's ecosystem.
• Topics: Specific areas of interest or research.
• Projects: Active, time-bound endeavors with specific deliverables.
• Goals: Long-term objectives driving project creation.
• Habits: Recurring behavioral patterns and routines.

By organizing a local directory into these predefined directories, you are essentially providing the LLM with a semantic map. When a new note is dropped into this folder structure, the AI does not have to "guess" its relevance. It performs an extraction task against the existing schema. The model reads the incoming text, compares it against the definitions of Topics, Projects, and Key Elements, and executes the necessary file movements and metadata updates.

Model Agnosticism and Automated Extraction

One of the most significant technical advantages of this "folder-as-database" approach is model agnosticism. Because the intelligence is grounded in the folder structure (the schema) rather than a proprietary database format, the user can switch between Claude, Gemini, or Codex without any loss of structural integrity. The data remains in plain text; only the processing engine changes.

The workflow operates as an automated pipeline:

1. Capture: A raw input (voice transcription via mobile, quick text entry) is saved to a central "inbox" or journal directory.
2. Transcription & Processing: An agentic layer (e.g., a Python script or specialized AI agent like Pen) monitors the folder. It uses an LLM to transcribe and parse the raw input.
3. Semantic Mapping: The LLM identifies entities within the text that correspond to the MyLife schema. If a note mentions a specific person, it checks for an existing node in the People directory; if none exists, it creates one.
4. Automated Linking: The system updates internal references, connecting the new journal entry to relevant projects or topics based on semantic similarity and explicit mentions.

This enables a "Capture and Forget" methodology. The user is relieved of the burden of filing; they simply capture the thought, knowing that the structural scaffold will handle the indexing.

From Weekly Review to Automated Friday Recaps

The ultimate casualty of this system is the traditional weekly review. Instead of a human manually scanning through seven days of notes to find connections, the system performs an automated synthesis.

Every Friday, the agent executes a "Recap" function. This is not merely a summary of recent entries; it is a cross-temporal analysis. Because all data—including backfilled historical data from legacy apps like Evernote or Notion—resides in the same structured folder, the AI can identify connections across massive time gaps.

For example, an agent might identify a link between a project launched this week and a fleeting thought captured four years ago. This is "serendipity on autopilot." The system can also surface quantitative insights, such as analyzing YouTube Studio data to report that "42% of new subscribers were driven by only 28% of total views," directly linking performance metrics to specific content nodes within the knowledge base.

Conclusion: The Death of Core Applications

We are witnessing a fundamental shift in software utility. For years, apps like Tana, Notion, and Obsidian were "core applications"—the primary repositories where your data lived, making you dependent on their proprietary databases.

As LLMs become capable of managing complex schemas via simple file structures, these tools are transitioning into "utility apps." They will serve as front-end interfaces (or "cockpits") for interacting with the data, but they will no longer be the owners of it. The power has shifted from the application developer to the user, who now owns the database through a simple, structured, local folder.