PAI: The Open-Source System That Turns Claude Into Your Personal AI Operating System
I've spent the last few months building my own AI agent team. Documentation systems for AI. Notification hooks. Memory persistence. Custom workflows. Piece by piece, manually, from scratch.
Then I found a repository that does exactly what I've been building - but as a complete, production-grade system.
And it's free.
Daniel Miessler - cybersecurity expert, author of the Unsupervised Learning newsletter, and creator of Fabric (the open-source project with 237 AI patterns for analysis, security, and knowledge extraction) - built PAI. Personal AI Infrastructure. 10,000+ GitHub stars. 1,400+ forks. MIT license.
This is not another ChatGPT wrapper. This is not a prompt collection. This is an operating system for your AI.
Let me show you why.
The problem PAI solves
Every time you open Claude, ChatGPT, or any other AI assistant, you start from zero. You explain who you are, what you're working on, what your goals are. Every single time.
Your AI doesn't remember you. Doesn't know your preferences. Doesn't know what you did yesterday. Each session is a blank slate.
Most people accept this as normal. PAI treats it as a fundamental design flaw.
Three levels of AI evolution
Miessler frames the problem as an evolution in three stages:
Level 1 - Chatbots: Ask a question, get an answer, everything is forgotten. This is ChatGPT, Claude, Gemini in their default mode.
Level 2 - Agentic platforms: Ask a question, the AI uses tools to get a result, but still has no persistent knowledge of who you are. This is Claude Code, Cursor, Windsurf.
Level 3 - Personal AI Infrastructure: The AI observes, thinks, plans, executes, verifies, and learns. It knows your goals, remembers your preferences, and gets better at helping you with every single interaction.
PAI is Level 3.
The Algorithm - PAI's gravitational center
Everything in PAI exists to serve one thing: The Algorithm.
It's a 7-phase cycle that PAI follows for every task:
Observe - Reverse-engineer the request. What did the user explicitly ask for? What did they imply? What do they obviously not want? What's the right effort level?
Think - Pressure-test the plan. What are the riskiest assumptions? Run a premortem - how could this fail?
Plan - Validate prerequisites. Select capabilities. Map the approach.
Build - Prepare everything needed for execution. Invoke selected skills and tools.
Execute - Do the actual work. Track progress against criteria in real-time.
Verify - Test every criterion. Did each one actually pass? Provide evidence, not assumptions.
Learn - What should I have done differently? What would a smarter algorithm have done instead? What capabilities should I have used?
The last phase is what makes PAI different from everything else. The system captures learnings from every interaction - ratings, sentiment analysis, success patterns, failure analysis - and feeds them back into improving The Algorithm itself.
PAI is not a static tool. It's a continuously upgrading algorithm.
The TELOS system - your AI knows who you are
This is the part that stopped me in my tracks.
TELOS is a set of 10 markdown files that describe who you are:
- MISSION.md - Your life mission
- GOALS.md - Short and long-term goals
- PROJECTS.md - What you're working on
- BELIEFS.md - What you believe in
- MODELS.md - Mental models you use
- STRATEGIES.md - Your strategies
- CHALLENGES.md - What you're struggling with
- IDEAS.md - Your ideas
- LEARNED.md - What you've learned
- NARRATIVES.md - Your story
When your AI knows your goals, values, and challenges, every response changes. It's not generic advice anymore. It's advice calibrated to your specific situation, your specific goals, your specific constraints.
Miessler calls this "the P0 problem" - most people never articulate who they are, what they're about, or what they're working toward. TELOS forces that articulation, and then your AI uses it as context for everything it does.
The Skill system - 63 self-activating capabilities
PAI organizes domain expertise into Skills - self-contained packages that activate automatically based on what you're asking for.
You don't need to remember commands. You say "research this topic" and the Research skill activates with multi-agent workflows. You say "analyze security" and the Security skill runs a STRIDE threat model. You say "think about this problem" and the Thinking skill launches first principles decomposition, council debates, or red teaming.
63 skills across 13 categories. Each one follows a strict structure:
skills/SkillName/
├── SKILL.md # Main skill file with routing
├── Tools/ # TypeScript CLI tools
└── Workflows/ # Operational procedures
Every skill has a USE WHEN trigger in its description. Claude Code parses this to automatically activate the right skill for the right task. No manual invocation needed.
The separation between System skills (shareable, no personal data) and Personal skills (prefixed with underscore, never shared) is elegant. You can export your System skills as PAI Packs for others while keeping your personal configurations private.
The Hook system - 21 automations running in the background
Hooks are event-driven automations that fire at specific moments in the Claude Code lifecycle:
SessionStart - Automatically loads your context. Your AI knows who you are, what you've been working on, and what you learned from past sessions before you type a single word.
PostToolUse - Syncs your work tracking, captures security events, updates progress dashboards.
SessionEnd - Captures work completions, generates session summaries, records relationship context, runs integrity checks.
There's even a hook that captures your satisfaction ratings (explicit and implicit through sentiment analysis) and feeds them into the learning system.
All hooks run asynchronously and fail gracefully. They enhance the experience but never block your work. Fire and forget.
The Memory system - nothing is lost
PAI's memory architecture is a three-tier system:
MEMORY/
├── WORK/ # Active project tracking (PRDs, criteria, progress)
├── LEARNING/ # System learnings, algorithm reflections, failure analysis
├── RESEARCH/ # Agent output captures
├── SECURITY/ # Security audit events
├── STATE/ # Runtime state, session tracking, event logs
└── PAISYSTEMUPDATES/ # Architecture change history
The WORK directory tracks every significant task through a PRD (Product Requirements Document) with Ideal State Criteria - binary-testable checkboxes that define what "done" looks like.
The LEARNING directory is where PAI truly differentiates itself. It stores:
- Algorithm reflections (what went well, what didn't)
- Failure analysis with full context dumps for low ratings
- Weekly pattern synthesis
- Rating signals tracking user satisfaction over time
The FAILURES subdirectory deserves special mention. When something goes wrong (rating 1-3), PAI captures the full context: conversation transcript, sentiment metadata, tool invocations, and a human-readable analysis. This is how the system learns from its mistakes.
Voice - your AI speaks to you
PAI integrates ElevenLabs for text-to-speech. This sounds like a gimmick until you try it.
Your AI announces when it starts working. Reads summaries when it finishes. Each agent has its own voice - the architect speaks with a British accent, the engineer has a different voice, the researcher another.
When you're deep in code and don't want to break focus to read terminal output, hearing "Entering the Execute phase" or "Task complete, all criteria passed" changes how you work. It's ambient awareness without context switching.
Packs - install only what you need
You don't need to install the full PAI system. Packs are standalone, self-contained capability packages:
- Research - Multi-agent research across 4 depth modes (quick to deep)
- Thinking - First principles, council debates, red teaming, brainstorming
- Security - Reconnaissance, OWASP testing, prompt injection testing
- Investigation - OSINT, company intel, people search, due diligence
- Media - Image generation, diagrams, infographics, Remotion video
- Telos - Life OS with goals, beliefs, project dashboards
- Agents - Custom agent composition from personality traits and voices
- ContentAnalysis - Wisdom extraction from videos, podcasts, articles
- Scraping - Web scraping via Bright Data proxy and Apify
- USMetrics - 68 US economic indicators from FRED, EIA, Treasury, BLS
- Utilities - CLI generation, Fabric patterns, Cloudflare, browser automation
- ContextSearch - Instant recall of prior work sessions
Install one, five, or all of them. Each pack includes an installation wizard that analyzes your system, asks questions, creates backups, installs, and verifies.
The architecture philosophy
PAI is built on 16 founding principles. Three of them define the entire system's DNA:
Scaffolding > Model - The system architecture matters more than which AI model you use. A well-structured system with good scaffolding will outperform a more powerful model with poor structure. This is why PAI works - it's not about Claude being smart. It's about the structure that makes Claude consistently effective.
Code Before Prompts - If you can solve it with a bash script, don't use AI. Prompts should orchestrate code, not replace it. This keeps the system deterministic where it can be deterministic, and probabilistic only where it needs to be.
As Deterministic as Possible - Same input should produce same output. Behavior defined by code, not prompt variations. This is the opposite of how most people use AI, and it's why PAI produces consistent results.
The technical stack is TypeScript + Bun, running natively on Claude Code. You need a Claude subscription (Pro or Max) - no separate API key required for the core system.
What makes PAI fundamentally different
Most AI tools are task-centric - you tell the AI what to do, it does it, end of story.
PAI is goal-centric - your AI knows what you're trying to achieve in life, and every interaction is informed by that context. The difference is profound.
A task-centric AI will help you write an email. A goal-centric AI will help you write an email that aligns with your communication strategy, references your current projects, and moves you toward your quarterly goals - because it knows all of those things.
Miessler's mission statement captures it perfectly:
"AI should magnify everyone - not just the top 1%."
Getting started
git clone https://github.com/danielmiessler/Personal_AI_Infrastructure.git
cd Personal_AI_Infrastructure/Releases/v4.0.3
cp -r .claude ~/ && cd ~/.claude && bash install.sh
The installer detects your system, installs prerequisites (Bun, Git, Claude Code if needed), asks for your name, AI assistant name, timezone, and temperature preference. Five minutes and you have a running system.
Your USER/ directory with personal files is never overwritten during upgrades. Your data is safe.
The bigger picture
PAI is at v4.0.3 with active development. The evolution from v2.0 (December 2025) to v4.0 (February 2026) shows rapid iteration: from a basic system with embedded markdown to a full infrastructure with 63 skills, 21 hooks, 180 workflows, and 14 named agents.
The roadmap includes local model support (Ollama, llama.cpp), granular model routing by task complexity, remote access from mobile and web, and outbound phone calling.
Whether you're a developer building with AI, a business owner automating operations, or someone who wants their AI to actually remember them - PAI is worth a serious look.
The project is MIT licensed, actively maintained, and has a growing community on GitHub Discussions and Discord.
I've been building my own version of this for months. Finding PAI was both humbling and exciting - humbling because someone built it better, exciting because now I can build on top of an established foundation instead of from scratch.
That's open source at its best.
Links: