Overview: Purpose · What is PAI? · New to AI? · Principles · Primitives
Get Started: Installation · Packs · Bundles
Resources: FAQ · Roadmap · Community · Contributing
Watch the full PAI walkthrough | Read: The Real Internet of Things
Important
PAI v2.3.0 Released — Complete .claude/ directories with continuous learning are back.
PAI exists to solve what I believe is the P0 problem in the world:
Most people don't believe they have valuable contributions to make. They think there are "special" people—and they aren't one of them. They've never asked who they are, what they're about, and have never articulated or written it down. This makes them catastrophically vulnerable to AI displacement. Without activation, there is no high-agency.
So our goal with PAI is to activate people.
PAI's mission is twofold:
- Activate as many people as possible — Help people identify, articulate, and pursue their own purpose in life through AI-augmented self-discovery
- Make the best AI available in the world accessible to everyone — Ensure this quality of AI infrastructure isn't reserved for just the rich or technical elite.
That's why this is an open-source project instead of private.
You've probably used ChatGPT or Claude. Type a question, get an answer. Simple.
You can think of AI systems as three levels:
ChatGPT, Claude, Gemini—you ask something, it answers, and then it forgets everything. Next conversation starts fresh. No memory of you, your preferences, or what you talked about yesterday.
The pattern: Ask → Answer → Forget
Tools like Claude Code, Cursor, and Windsurf. The AI can actually do things—write code, browse the web, edit files, run commands.
The pattern: Ask → Use tools → Get result
More capable, but it still doesn't know you—your goals, your preferences, your history.
Now your DA learns and improves:
- Captures every signal — Ratings, sentiment, verification outcomes
- Learns from mistakes — Failures get analyzed and fixed
- Gets better over time — Success patterns get reinforced
- Upgrades itself — Skills, workflows, even the core behavior evolves
Plus it knows:
- Your goals — What you're working toward
- Your preferences — How you like things done
- Your history — Past decisions and learnings
The pattern: Observe → Think → Plan → Execute → Verify → Learn → Improve
The key difference: PAI learns from feedback. Every interaction makes it better at helping you specifically.
PAI is a Personalized AI Platform designed to magnify your capabilities.
It's designed for humans most of all, but can be used by teams, companies, or Federations of Planets desiring to be better versions of themselves.
The scale of the entity doesn't matter: It's a system for understanding, articulating, and realizing its principal's goals using a full-featured Agentic AI Platform.
Everyone, full stop. It's the anti-gatekeeping AI project.
- Small business owners who aren't technical but want AI to handle invoicing, scheduling, customer follow-ups, and marketing
- Companies who want to understand their data, optimize operations, and make better decisions
- Managers who want to run their teams more effectively—tracking projects, preparing for reviews, and communicating clearly
- Artists and creatives who want to find local events, galleries, and opportunities to showcase their work
- Everyday people who want to improve their lives—better fitness routines, stronger social connections, personal finance, or just getting organized
- Developers using AI coding assistants who want persistent memory and custom workflows
- Power users who want their AI to know their goals, preferences, and context
- Teams building shared AI infrastructure with consistent capabilities
- Experimenters interested in AI system design and personal AI patterns
The first thing people ask is:
How is this different from Claude Code, or any of the other agentic systems?
Most agentic systems are built around tools with the user being an afterthought. They are also mostly task-based instead of being goal-based using all the context available to them. PAI is the opposite.
Three core differentiators:
-
Goal Orientation — PAI's primary focus is on the human running it and what they're trying to do in the world, not the tech. This is built into how the system executes all tasks.
-
Pursuit of Optimal Output — The system's outer loop and everything it does is trying to produce the exact right output given the current situation and all the contexts around it.
-
Continuous Learning — The system constantly captures signals about what was done, what changes were made, what outputs were produced for each request, and then how you liked or disliked the results.
These principles guide how PAI systems are designed and built. Full breakdown →
| # | Principle | Summary |
|---|---|---|
| 1 | User Centricity | PAI is built around you, not tooling. Your goals, preferences, and context come first—the infrastructure exists to serve them. |
| 2 | The Foundational Algorithm | The scientific method as a universal problem-solving loop: Observe → Think → Plan → Build → Execute → Verify → Learn. Define the ideal state, iterate until you reach it. |
| 3 | Clear Thinking First | Good prompts come from clear thinking. Clarify the problem before writing the prompt. |
| 4 | Scaffolding > Model | System architecture matters more than which model you use. |
| 5 | Deterministic Infrastructure | AI is probabilistic; your infrastructure shouldn't be. Use templates and patterns. |
| 6 | Code Before Prompts | If you can solve it with a bash script, don't use AI. |
| 7 | Spec / Test / Evals First | Write specifications and tests before building. Measure if the system works. |
| 8 | UNIX Philosophy | Do one thing well. Make tools composable. Use text interfaces. |
| 9 | ENG / SRE Principles | Treat AI infrastructure like production software: version control, automation, monitoring. |
| 10 | CLI as Interface | Command-line interfaces are faster, more scriptable, and more reliable than GUIs. |
| 11 | Goal → Code → CLI → Prompts → Agents | The decision hierarchy: clarify goal, then code, then CLI, then prompts, then agents. |
| 12 | Skill Management | Modular capabilities that route intelligently based on context. |
| 13 | Memory System | Everything worth knowing gets captured. History feeds future context. |
| 14 | Agent Personalities | Different work needs different approaches. Specialized agents with unique voices. |
| 15 | Science as Meta-Loop | Hypothesis → Experiment → Measure → Iterate. |
| 16 | Permission to Fail | Explicit permission to say "I don't know" prevents hallucinations. |
While the Principles describe the philosophy of PAI, the Primitives are the architecture—the core systems that make everything work.
These primitives work together to create the experience of working with a system that understands and knows you—as opposed to a tool harness that just executes commands.
PAI treats AI as a persistent assistant, friend, coach, and mentor rather than a stateless agent that runs tasks. An assistant knows your goals, remembers your preferences, and improves over time. An agent executes commands and forgets.
10 files that capture who you are: MISSION.md, GOALS.md, PROJECTS.md, BELIEFS.md, MODELS.md, STRATEGIES.md, NARRATIVES.md, LEARNED.md, CHALLENGES.md, IDEAS.md. Your DA knows what you're working toward because it's all documented.
Your customizations live in USER/. PAI infrastructure lives in SYSTEM/. When PAI upgrades, your files are untouched. Portable identity, upgrade-safe.
Six layers of customization: Identity (name, voice, personality), Preferences (tech stack, tools), Workflows (how skills execute), Skills (what capabilities exist), Hooks (how events are handled), and Memory (what gets captured). Start with defaults, customize when needed.
Highly focused on consistent results. It has a structure that puts deterministic outcomes first by going from CODE -> CLI-BASED-TOOL -> PROMPT -> SKILL instead of a haphazard structure.
Focused on continuous learning. Every interaction generates signals—ratings, sentiment, successes, failures—that feed back into improving the system. Three-tier architecture (hot/warm/cold) with phase-based learning directories.
Responds to lifecycle events—session start, tool use, task completion, and more. 8 event types enable voice notifications, automatic context loading, session capture, security validation, and observability.
Defines system and user-level security policies by default. You don't have to run with --dangerously-skip-permissions to have an uninterrupted experience. PAI's security hooks validate commands before execution, blocking dangerous operations while allowing normal workflows to proceed smoothly.
Your AI assistant reads the packs, understands your system, and installs everything for you. No manual configuration, no guessing—the AI handles it.
Keeps you informed without being intrusive. Push notifications via ntfy for mobile alerts, Discord integration for team updates, and duration-aware routing that escalates for long-running tasks. Fire-and-forget design means notifications never block your workflow.
Powered by ElevenLabs TTS. Hear task completions, session summaries, and important updates spoken aloud. Prosody enhancement makes speech sound natural. Your AI has a voice.
Rich tab titles and pane management. Dynamic status lines show learning signals, context usage, and current task state. Your terminal is a command center.
Caution
Project in Active Development — PAI is evolving rapidly. Expect breaking changes, restructuring, and frequent updates. We are working on stable and development branches, but currently it's all combined.
┌─────────────────────────────────────────────────────────────────┐
│ Do you want a complete, working PAI system right now? │
│ │
│ YES ──────────► Option 1: Full Release Install │
│ (Complete .claude/ directory, ~5 min) │
│ │
│ NO, I want to customize or learn the system │
│ │ │
│ ├──► Option 2: Bundle + Packs (Build it yourself) │
│ │ (Skeleton structure, then install packs manually) │
│ │ │
│ └──► Option 3: Individual Packs (Cherry-pick) │
│ (Install only specific capabilities you need) │
└─────────────────────────────────────────────────────────────────┘
This is the fastest path to a working PAI system. You get a complete, pre-configured
.claude/directory with all infrastructure packs already installed.
# Clone the repo
git clone https://github.com/danielmiessler/PAI.git
cd PAI/Releases/v2.3
# Back up your existing Claude Code configuration (if any)
[ -d ~/.claude ] && mv ~/.claude ~/.claude-backup-$(date +%Y%m%d)
# Copy the complete PAI installation
cp -r .claude ~/
# Run the configuration wizard
cd ~/.claude && bun run install.ts --setupThe wizard will:
- Ask for your name, DA name, and timezone
- Configure environment variables (works with both bash and zsh)
- Set up voice preferences (optional)
- Verify the installation
After installation: Restart Claude Code to activate hooks.
For users who want to understand the system as they build it, or need a customized setup.
Warning
The Bundle wizard creates a skeleton directory structure only. You must then install each pack manually in the correct order for a working system.
# Clone the repo
git clone https://github.com/danielmiessler/PAI.git
cd PAI/Bundles/Official
# Run the interactive wizard (creates skeleton structure)
bun run install.tsAfter the wizard completes, you MUST install packs in this order:
| Order | Pack | Command |
|---|---|---|
| 1 | pai-hook-system | "Install the pack at PAI/Packs/pai-hook-system/" |
| 2 | pai-core-install | "Install the pack at PAI/Packs/pai-core-install/" |
| 3 | pai-statusline | "Install the pack at PAI/Packs/pai-statusline/" |
| 4+ | Any skill packs | Install as needed |
Install individual packs by giving them to your DA:
- Browse packs - Find a pack you want in Packs/
- Give it to your DA - Provide the pack directory path
- Ask your DA to install it:
Install this pack into my system. Use PAI_DIR="~/.claude"
and DA="MyAI". Set up the hooks, save the code, and verify it works.
Packs are self-contained. You can:
- Read the code directly in the pack
- Copy specific functions or workflows
- Adapt the approach to your own system
- Use it as reference documentation
No forced structure. No mandatory setup. Take what's useful, leave the rest.
PAI capabilities are distributed as Packs—self-contained, AI-installable modules that add specific capabilities to your system.
Each pack includes everything needed: code, workflows, installation instructions, and verification tests. Your DA reads the pack and installs it into your system—no manual copying required.
| Pack | Description |
|---|---|
| pai-core-install | Core skills, identity, MEMORY system, and response format |
| pai-hook-system | Event-driven automation and security validation |
| pai-voice-system | Voice notifications with ElevenLabs TTS |
| pai-observability-server | Real-time agent monitoring dashboard |
| pai-statusline | 4-mode responsive status line with learning signals |
| Pack | Description |
|---|---|
| pai-agents-skill | Dynamic agent composition with personality mapping |
| pai-algorithm-skill | ISC management, effort classification |
| pai-annualreports-skill | Annual security report aggregation |
| pai-art-skill | Visual content generation |
| pai-brightdata-skill | Progressive URL scraping |
| pai-browser-skill | Browser automation with Playwright |
| pai-council-skill | Multi-agent debate system |
| pai-createcli-skill | Generate TypeScript CLI tools |
| pai-createskill-skill | Create and validate PAI skills |
| pai-firstprinciples-skill | First principles analysis |
| pai-osint-skill | Open source intelligence gathering |
| pai-privateinvestigator-skill | Ethical people-finding |
| pai-prompting-skill | Meta-prompting system |
| pai-recon-skill | Security reconnaissance |
| pai-redteam-skill | Adversarial analysis with 32 agents |
| pai-research-skill | Multi-source research |
| pai-system-skill | System maintenance and integrity checks |
| pai-telos-skill | Life OS and deep goal capture |
23 packs total — 5 infrastructure + 18 skills. All extracted from production PAI systems.
Bundles are curated collections of packs designed to work together.
| Bundle | Description | Packs |
|---|---|---|
| PAI Bundle | The official PAI bundle - complete personal AI infrastructure | 5 |
Quick install:
git clone https://github.com/danielmiessler/PAI.git
cd PAI/Bundles/Official && bun run install.tsPAI isn't a replacement for Claude Code—it's what you build on top of it. Claude Code gives you an AI that can read files, write code, and execute commands. But it's generic. It doesn't know your goals, your preferred workflows, your history, or your specific context.
PAI provides the scaffolding to make that generic AI yours:
- Persistent memory — Your DA remembers past sessions, decisions, and learnings
- Custom skills — Specialized capabilities for the things you do most
- Your context — Goals, contacts, preferences—all available without re-explaining
- Intelligent routing — Say "research this" and the right workflow triggers automatically
- Self-improvement — The system modifies itself based on what it learns
Think of it this way: Claude Code is the engine. PAI is everything else that makes it your car.
No. PAI v2 is modular by design:
- Packs are independent — Install one, install ten, install none
- Start small — Begin with the Hook System, add more when you need it
- No dependencies on the whole — Each pack declares its dependencies explicitly
- Incremental adoption — Use PAI alongside your existing setup
The best way to start: pick ONE pack that solves a problem you have today.
Anthropic's plugin system (Skills, slash commands, MCP servers) provides discrete functionality—individual tools your DA can use.
Anthropic's plugins = Individual pieces of functionality that don't understand overall context
PAI = A complete system where everything understands the context—your goals, your workflows, how pieces work together
The plugin system offers building blocks. PAI offers a complete system.
No. PAI packs are designed to be platform-agnostic. While the examples use Claude Code, the packs work with OpenCode, Cursor, Windsurf, and custom systems. The code is TypeScript, Python, and Bash—the concepts are universal.
Fabric is a collection of AI prompts (patterns) for specific tasks. It's focused on what to ask AI.
PAI is infrastructure for how your DA operates—memory, skills, routing, context, self-improvement. They're complementary. Many PAI users integrate Fabric patterns into their skills.
The modular design makes recovery easy:
- Packs are isolated — Breaking one doesn't affect others
- History is preserved — Your DA's memory survives mistakes
- Git-backed — Version control everything, roll back when needed
- DA can fix it — Your DA helped build it, it can help repair it
| Feature | Description |
|---|---|
| Local Model Support | Run PAI with local models (Ollama, llama.cpp) for privacy and cost control |
| Granular Model Routing | Route different tasks to different models based on complexity |
| Remote Access | Access your PAI from anywhere—mobile, web, other devices |
| Outbound Phone Calling | Voice capabilities for outbound calls |
| External Notifications | Robust notification system for Email, Discord, Telegram, Slack |
GitHub Discussions: Join the conversation
UL Community Discord: PAI is discussed in the Unsupervised Learning community along with other AI projects
Twitter/X: @danielmiessler
Blog: danielmiessler.com
- Fork the repository
- Create your pack using PAIPackTemplate.md
- Test it — Install in a fresh system with AI assistance
- Submit a PR with examples and testing evidence
Packs are reviewed for completeness, code quality, security, and usefulness. Most packs reviewed within 7 days.
Pack authors maintain their packs — respond to issues, fix bugs, consider feature requests.
MIT License - see LICENSE for details.
Anthropic and the Claude Code team — First and foremost. You are moving AI further and faster than anyone right now. Claude Code is the foundation that makes all of this possible.
IndyDevDan — For great videos on meta-prompting and custom agents that have inspired parts of PAI.
fayerman-source — Google Cloud TTS provider integration and Linux audio support for the voice system.
Matt Espinoza — Extensive testing, ideas, and feedback for the PAI 2.3 release, plus roadmap contributions.
PAI is free and open-source forever. If you find it valuable, you can sponsor the project.
- The Real Internet of Things — The vision behind PAI
- AI's Predictable Path: 7 Components — Visual walkthrough of where AI is heading
- Building a Personal AI Infrastructure — Full PAI walkthrough with examples
📜 Update History
v2.3.0 (2026-01-15) — Full Releases Return
- Complete
.claude/directory releases with continuous learning - Explicit and implicit rating capture
- Enhanced hook system with 14 production hooks
- Status line with learning signal display
- Release Notes
v2.1.1 (2026-01-09) — MEMORY System Migration
- History system merged into pai-core-install as MEMORY System
v2.1.0 (2025-12-31) — Directory-Based Pack Structure
- All packs migrated from single files to directory structure
- Source code now in real files instead of embedded markdown
v2.0.1 (2025-12-30) — Pack Expansion
- Added Prompting and Agents skills
- Standardized authentication to single
.envlocation
v2.0.0 (2025-12-28) — PAI Packs System Launch
- Transitioned from monolithic to modular pack architecture
- Platform-agnostic design
Built with ❤️ by Daniel Miessler and the PAI community
Augment yourself.
