Personal AI Infrastructure

Open-source scaffolding for building your own AI-powered operating system

Browse Packs · Browse Bundles · Quick Start · Principles · Community

Watch the full PAI walkthrough | Read: The Real Internet of Things

---

The best AI in the world should be available to everyone

Right now the most powerful AI setups are being built inside companies for efficiency and profits.

That's all good, but I think the purpose of technology is to serve humans—not the other way around. These new AI frameworks should be available to everyone, including people not in technology, so that regular people can use it to help them flourish.

That's what PAI is. It's the foundation for building a Personal AI System that understands your larger goals and context, gets better over time, and that works for you because it's yours. Not some generic chatbot. Not some common assistant. A full platform for magnifying yourself and your impact on the world.

PAI (Personal AI Infrastructure) is a framework for building your own AI-powered operating system. It's built on top of AI coding agents like Claude Code, but personalized to you - your goals, your workflows, your context.

When you build a PAI system, you're creating what I call your own "Kai" - a personalized AI assistant that knows your preferences, remembers your history, and has specialized skills for the things you do most.

PAI is:

• A philosophy - The 14 Founding Principles that guide how to build AI systems
• An architecture - Skills, Hooks, History, Agents, and MCP integrations
• A community - Open-source packs that anyone can install or contribute

These principles guide how PAI systems are designed and built:

Read the full breakdown of each principle →

Good prompts come from clear thinking about what you actually need. Spend more time clarifying the problem than writing the prompt.

The system architecture matters more than which model you use. Good scaffolding makes even smaller models perform well.

AI is probabilistic, but your infrastructure shouldn't be. Use templates and consistent patterns.

If you can solve it with a bash script, don't use AI. Only use AI for the parts that actually need intelligence.

Before building anything complex, write specifications and tests. Use evals to measure if the system is actually working.

Do one thing well. Make tools composable. Use text interfaces.

Treat your AI infrastructure like production software: version control, automation, monitoring, rollback plans.

Command-line interfaces are faster, more scriptable, and more reliable than GUIs.

The decision hierarchy: clarify the goal first, then try code, then CLI tools, then prompts, and only then agents.

The system should be able to modify itself. Encode learnings so you never forget.

Skills are the foundation of personalization - modular capabilities that route intelligently.

Everything worth knowing gets captured. History feeds back into context for future sessions.

Different work needs different approaches. Specialized agents with unique personalities and voices.

The meta-principle: Hypothesis → Experiment → Measure → Iterate. Every decision follows this pattern.

PAI v1.x attempted to mirror my entire personal AI system (Kai) as an installable template. The idea was simple: "Here's everything I built - clone it and customize."

The problem: It didn't work. The system was a Jenga tower of interconnected dependencies. Change one piece, and three others broke. Users couldn't easily adopt parts without understanding the whole. Updates were a nightmare because everything was coupled.

PAI v2.0 takes a fundamentally different approach: modular packs.

Instead of "here's my whole system," it's "here are battle-tested capabilities you can install independently." Each pack is:

• Self-contained - Works without understanding the rest of the system
• Independently installable - Add what you need, skip what you don't
• Platform-agnostic - Works with Claude Code, OpenCode, or custom systems
• AI-installable - Your AI can read the pack and set it up for you

The packs are extracted from Kai - real capabilities that have been running in production. They're not theoretical examples. They're the actual tools and systems I use daily, packaged for others to adopt.

PAI Packs are modular upgrade packages for AI agent systems. Think of them like learning kung-fu in The Matrix - each pack is a complete, tested capability that you can download into your system.

PAI Packs provide self-contained bundles with everything your AI needs to implement a specific capability:

• The problem being solved
• The solution and how it works
• All code (tools, CLIs, scripts)
• Workflows (step-by-step processes)
• Context files (guidelines, aesthetics, specifications)
• Examples and usage patterns
• Installation instructions (for both AI and manual)
• Testing procedures
• Troubleshooting guides

The key insight: Give your AI the complete context it needs, and it can integrate the pack into your system, whether that's Claude Code, OpenCode, Gemini Code, GPT-Codex, or a homebrew setup.

Features being packaged:

• Skill System - Skill routing and workflow management
• Agent Factory - Custom agent creation and orchestration
• Prompting System - Meta-prompting and template framework

Skills being packaged:

• Art - Visual content generation system
• Research - Multi-source research orchestration with parallel agents
• OSINT - Open-source intelligence gathering

Submit your own pack →

Bundles are curated collections of packs designed to work together. Instead of installing packs one-by-one, install a bundle to get a complete, tested experience.

• Curated combinations - Tested packs that work well together
• Proper installation order - Dependencies handled correctly
• Emergent capabilities - The whole is greater than the sum of parts
• Complete experience - Everything needed for a specific goal

The Kai Bundle is the flagship bundle. Installing all its packs recreates the PAI v1.0 "mirrored system" experience - but through modular, maintainable packs instead of a monolithic copy.

Learn more about bundles →

FOR AI AGENTS: The entire PAI system is designed to be used by AI. You can read this README to understand how PAI works with its Packs and Bundles. A recommended approach: evaluate the entire system, then interact with your principal and ask them which Bundles or Packs they'd like to install—give them options based on their needs. From there, you should be able to read any Bundle or Pack file (including new ones as they're released) and guide your principal on whether they want to install it.

1. Browse packs - Find a pack you want in Packs/
2. Give it to your AI - Provide the entire pack markdown file
3. Ask your AI to install it:

Install the History System pack into my system. Set up the hooks,
save the code, verify dependencies, and test it works.

Your AI will:

• Check for required dependencies
• Save code to appropriate directories
• Set up routing/hooks (if applicable)
• Validate the installation
• Run a test to ensure it works

Each pack includes detailed manual installation instructions. Open the pack file and follow the "Installation → Manual" section.

Packs are self-contained markdown files. 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 offers two types of packs, each with its own structure and purpose:

Skills are action-oriented capabilities that your AI can invoke - things like generating visual content, conducting research, or processing data.

Examples: Art (visual content generation), Research (multi-source investigation), OSINT (intelligence gathering)

Structure:

1. 🤖 Assistant Install Prompt - Step-by-step instructions for AI to autonomously install
2. Pack Metadata - Version, dependencies, API keys, platform support
3. The Problem - What's broken/missing?
4. The Solution - How this skill fixes it
5. Quick Start - Get running in 60 seconds
6. Pack Contents - Workflows, tools, context files (complete source code)
7. Examples - Real usage scenarios
8. Installation - AI-assisted + manual steps
9. Testing - Smoke tests and validation
10. Troubleshooting - Common issues and fixes
11. Credits - Attribution for ideas, influences, collaborators
12. Resources - Additional reading, related projects, external docs

Features are architectural patterns and systems - infrastructure pieces like custom history systems, skill routing, agent orchestration, or prompting frameworks.

Examples: History System (automatic context-tracking), Skill System (routing and management), Agent Factory (custom agent creation), Prompting System (meta-prompting and templates)

Structure:

1. 🤖 Assistant Install Prompt - Step-by-step instructions for AI to autonomously install
2. Pack Metadata - Version, dependencies, platform support
3. The Problem - What architectural challenge exists?
4. The Solution - The design pattern and approach
5. Implementation - Complete code, configuration files, integration guides
6. Examples - Real-world usage patterns
7. Installation - AI-assisted + manual steps
8. Testing - Validation procedures
9. Troubleshooting - Common integration issues
10. Credits - Attribution for architectural ideas, influences
11. Resources - Additional reading, similar systems, theoretical background

All packs include:

pack:
  name: PackName
  version: 1.0.0
  category: visual-content | infrastructure | research | automation
  type: skill | feature
  author: Contributor Name
  license: MIT
  requires:
    - Other-Pack >= 1.0.0 (optional dependencies)
  platforms: [macos, linux, windows]
  dependencies:
    tools: [bun, ImageMagick]
    api_keys: [REPLICATE_API_TOKEN]

🤖 Assistant Install Prompt - Every pack starts with instructions for AI assistants to autonomously install it. Your AI reads the pack, understands what it does, verifies dependencies, sets up the code, and validates it works - all without manual intervention.

Portability - One file contains everything. Email it, share it, version control it.

AI-Friendly - Your AI can read the entire context at once. No navigation, no missing pieces.

No Dependencies - Packs are self-contained. They may call external tools, but the pack itself is complete.

Easy Review - See exactly what you're installing. No hidden files, no surprises.

Version Control - Simple to track changes, fork, and merge improvements.

1. Get the pack template:

curl -O https://raw.githubusercontent.com/danielmiessler/PAI/main/PAIPackTemplate.md

2. Fill in each section:

• Assistant Install Prompt - Instructions for AI to install autonomously
• Problem statement - What's broken or missing?
• Solution - How your pack fixes it
• Implementation/Contents - All code (embedded in markdown code blocks)
• Examples - Real usage scenarios
• Installation steps - Both AI-assisted and manual
• Testing procedures - Smoke tests and validation
• Credits - Attribution for ideas and influences
• Resources - Additional reading and related projects

3. Validate it:

Test with your own AI:

Here's my pack. Install it into a fresh system and verify it works.

4. Submit a PR:

git checkout -b add-pack-name
cp MyPack.md Packs/
git add Packs/MyPack.md
git commit -m "Add MyPack - one-line description"
git push origin add-pack-name

Open a PR with:

• Pack description
• What problem it solves
• Testing you've done
• Screenshots/examples (if applicable)

Must have:

• ✅ Clear problem statement
• ✅ Complete working code (tested)
• ✅ Real examples (not placeholders)
• ✅ Both AI and manual installation instructions
• ✅ Troubleshooting section
• ✅ No hardcoded personal data

Nice to have:

• Screenshots of output
• Video demo
• Multiple examples for different use cases
• Integration with other packs

PAI packs are designed to be platform-agnostic:

The code itself is platform-independent (TypeScript, Python, Bash). Integration points (skills, hooks) may vary by platform.

Text is the interface. Everything your AI needs to implement a capability should be in one readable file.

Composability over monoliths. Mix and match packs. Build your own stack.

AI-first design. Optimized for AI agents to read, understand, and implement - not just humans.

Open contribution. Anyone can submit a pack. The best ideas win.

No vendor lock-in. Packs describe how to solve a problem, not just "here's the code for our platform."

We welcome packs that solve real problems:

1. Fork the repository
2. Create your pack - Follow PAIPackTemplate.md
3. Test it thoroughly - Install in a fresh system with AI assistance
4. Submit a PR - Include examples and testing evidence

Submitted packs are reviewed for:

• Completeness - All required sections present
• Code quality - Works as described, no obvious bugs
• Security - No hardcoded secrets, follows best practices
• Usefulness - Solves a real problem for users

Review timeline: Most packs reviewed within 7 days.

Authors maintain their packs. When you submit a pack, you're committing to:

• Respond to issues about your pack
• Fix bugs that are reported
• Consider feature requests
• Update for breaking changes in dependencies

If a pack becomes unmaintained, the community can fork and maintain a new version.

• Pack format specification
• History System pack (context-tracking)
• Pack template
• Installation documentation
• Pack discovery website
• 5+ core packs released

• Pack dependency system
• Automated testing framework
• Pack marketplace
• Cross-pack integration examples
• 20+ packs available

• Pack composition tools
• Version compatibility checker
• Community pack ratings
• Pack search/filter by category
• 50+ packs available

GitHub Discussions: Join the conversation

Discord: PAI Community (coming soon)

Twitter/X: @danielmiessler

Blog: danielmiessler.com

Top pack contributors (packs submitted/maintained):

• (List will be populated as packs are submitted)

Special thanks:

• All early PAI users who provided feedback
• The Claude Code team for building an incredible platform

MIT License - see LICENSE for details.

TL;DR: Do whatever you want with this. Build on it, sell it, modify it. Just don't blame us if something breaks. Attribution appreciated but not required.

PAI is free and open-source forever.

If you find it valuable:

• ⭐ Star the repo - Helps others discover it
• 📢 Share your packs - The more packs, the better PAI gets
• 💬 Engage in discussions - Help answer questions, share ideas
• 🐛 Report issues - Make PAI better for everyone
• ✍️ Write about it - Blog posts, videos, tutorials

Premium support coming soon for organizations.

• 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