Personal OS: The Complete Blueprint Personal OS：完整系统架构

This is Part 2 of a series. Part 1 covers the philosophy behind the system. This article is the architecture itself: folders, files, rules, and how they work together.

What You’re Building

A personal operating system is a file-based infrastructure on your computer that lets AI act as a genuine thinking partner, not just a question-answering machine. It’s built on three ideas:

1. Human-AI co-cognition. AI both initiates and responds. It notices patterns, suggests connections, and challenges your thinking, instead of waiting passively for prompts.
2. Compound growth. Every interaction, project, and reflection feeds back into the system, making the next one better.
3. Cross-domain transfer. Insights move freely between different areas of your life, powered by shared vocabulary and active synthesis.

The system is built on a Mac laptop as the primary device, with local-first data architecture and cloud as an access/sync layer.

Tool-Agnostic by Design

Everything in this architecture (markdown files, folder structures, git repositories) is independent of any specific AI tool. It works with Claude Code, Cursor, Codex, local models, or whatever comes next. Throughout this article, Claude is the reference example. Every Claude-specific mention represents a pattern you can adapt to any AI tool by writing a thin config file that points to the same underlying data.

Why You Should Own the Scaffolding

Here’s a reality worth sitting with: current AI systems have no intrinsic persistent memory. Every form of AI “memory” today (ChatGPT’s memory feature, Claude’s project knowledge, custom instructions, system prompts) is external scaffolding. Structured information gets passed into a fundamentally stateless model at the start of each session. The AI doesn’t remember you. It reads notes about you.

As AI memory capabilities evolve (and they are evolving rapidly), this architecture stays valid. You end up with a portable, inspectable, version-controlled self-model that any memory system can draw from, rather than your context being locked inside one platform’s black box.

Part 1: The Three Layers

The system is organized into three layers separated by privacy and AI-access boundaries. This is the most durable architectural decision in the whole system. It maps to a permanent human need (public self / working life / secrets) and doesn’t depend on any specific AI technology.

Part 2: PersonalOS — The Brain

This is the AI-facing layer. It’s small (roughly 20–40 markdown files), always loaded as context, and represents your self-model. AI reads this first in every session.

What this layer is: infrastructure for human-AI co-cognition. A robust starting point that you actively construct and maintain. These folders and files don’t run themselves. They are structured scaffolding that becomes powerful when you build habits around them and when your AI tools are configured to read and act on them. The value comes from the architecture being ready, so that when you engage, everything has a place and a purpose.

How Each Component Works

None of these components are automatic. Each one is infrastructure that requires human action, AI tool configuration, or both. Here’s what each does and what activates it.

00-identity, 10-mission, 20-goals — Your foundational self-model. You write and revise these. AI reads them passively at session start for context. They change infrequently, only when you have a genuine shift in self-understanding, direction, or priorities.

30-journal — A reflective practice you maintain. You write entries; AI reads the most recent one (latest.md) for context each session. Older entries live in entries/ and are loaded on demand (during pulse synthesis or when reviewing a time period). The writing is yours; the structure just ensures AI always has your latest thinking.

40-frameworks — Your codified mental models. You create and refine these over time as your thinking evolves. INDEX.md is the key mechanism: it lists each framework with trigger conditions so AI knows when to load which framework based on the current task. AI doesn’t generate frameworks for you. It uses the ones you’ve defined.

60-pulse — Periodic AI-generated synthesis across your active domains. This is the most AI-proactive component, but it is not self-triggering. You initiate a pulse by running a script or starting a conversation (e.g., “do a pulse synthesis”). AI then reads across your projects, journal, learning, and writing to surface patterns and cross-connections. Output goes to latest.md; you review and decide what to act on. A realistic rhythm is biweekly or monthly. The architecture anticipates this becoming automated via background agents, but today it requires human initiation.

70-connections — The cross-domain transfer mechanism. active-map.md is a living summary of all your active work; update it after significant sessions (the bootloader instructs AI to do this, but it depends on your AI tool following those instructions). cross-links.md captures discovered connections between domains, updated as a byproduct of pulse work or when AI notices a connection mid-session. transfer-log.md records confirmed transfers. None of this runs automatically; it depends on AI tool configuration.

90-changelog — Entirely human-driven. You write this during periodic reviews (monthly is a reasonable rhythm) or when something significant shifts. Think of it as release notes for yourself. AI can help draft entries, but you decide when a change is worth logging.

Part 3: Life — The Body

This is where actual work and life data lives. AI accesses specific folders when you choose, but never gets blanket access to everything. Organized by life domain, not by file type.

Numbering uses gaps of 10 so you can insert future domains without restructuring.

Part 4: Vault — The Private Layer

Encrypted, isolated, AI-excluded. This is for anything you would never want inside an AI context window.

The boundary here is absolute. No AI tool, no script, no configuration should ever touch this folder. When you delete something from the Vault, it’s gone — no git history, no backup unless you made one yourself.

Part 5: Global Configuration

The bootloader makes PersonalOS available to AI across all sessions, regardless of which project directory you’re working in.

What bootloader.md Contains

# PersonalOS Bootloader — Instructions for Any AI Session

## Always Load (Tier 1)
At the start of every session, read these files to understand who I am:
- ~/PersonalOS/00-identity/me.md
- ~/PersonalOS/10-mission/mission.md
- ~/PersonalOS/20-goals/current.md
- ~/PersonalOS/30-journal/latest.md
- ~/PersonalOS/40-frameworks/INDEX.md
- ~/PersonalOS/50-interaction/global-protocol.md
- ~/PersonalOS/60-pulse/latest.md
- ~/PersonalOS/70-connections/active-map.md
- ~/PersonalOS/80-domains/INDEX.md

## After Every Significant Session
1. Update ~/PersonalOS/70-connections/active-map.md
2. Check for cross-domain connections
3. Add significant insights to ~/PersonalOS/60-pulse/inbox.md

## Co-Cognition Rules
- You are a thinking partner, not just an assistant
- Proactively surface patterns, connections, and observations
- Challenge my thinking when misaligned with mission/goals
- Never modify identity/mission/values without explicit approval
- Never access ~/Vault/ under any circumstances

Gradual Engagement

Not every AI session needs the full system. The architecture is designed to be gradually engageable: a quick coding question doesn’t require loading your identity file, and a casual conversation doesn’t need your active project map. The bootloader is for sessions where you want AI to operate as a thinking partner with full context. For lightweight tasks, work without loading PersonalOS at all. The data sits on disk, costing nothing until called upon.

Part 6: The Compound Interest Mechanisms

These mechanisms make the system accumulate value over time rather than just store data. Each one is infrastructure: it defines what should happen and where outputs go. The triggering depends on human habits and AI tool configuration, not on built-in automation.

Part 7: Version Control Architecture

Part 8: Future-Proofing

What Is Permanent (the Architecture)

• The three-layer separation (PersonalOS / Life / Vault)
• The privacy boundary model (full access / selective access / no access)
• The tiered loading pattern (always-loaded index → on-demand content)
• Human final authority on identity, mission, and values
• Local-first data with cloud as sync layer
• Tool-agnostic data layer (markdown, folders, git, no vendor lock-in)

What Will Evolve (the Implementation)

• File formats may expand beyond markdown (structured data, embeddings)
• The Pulse may become a true always-on background agent as AI capabilities mature
• The AI access boundary between PersonalOS and Life may become a smart membrane with automated rules
• Local models may replace or supplement cloud AI for privacy-sensitive operations
• The interaction protocol will deepen as AI capabilities grow
• New domains and frameworks get added as life evolves
• Manual triggering and maintenance will progressively automate

What This Architecture Is Ready For

• Migration to any AI platform (all data is in open, portable formats)
• Addition of local/private language models
• Automated agents that monitor and synthesize
• Multi-device sync (the structure works identically on any machine)
• Collaboration (specific Life folders can be shared without exposing the whole system)
• Multi-tool usage (different AI tools for different tasks, all reading the same PersonalOS)

Quick Reference: What Goes Where