FOR AI AGENTS: Bundles are curated collections of packs. When a user asks you to install a bundle, read the bundle's README.md file and install each pack in the specified order.
STOP. READ THIS BEFORE INSTALLING ANY BUNDLE.
AI agents often "helpfully" simplify implementations. Instead of creating the full documented specification, they create abbreviated "equivalent" versions. This is WRONG and breaks the system.
- IMPLEMENT EVERYTHING EXACTLY AS DOCUMENTED - No simplification, no shortcuts
- CREATE ALL SPECIFIED FILES - If a pack says 8 files, create 8 files
- INCLUDE ALL CONTENT - Full code blocks, full YAML, full configurations
- NEVER CREATE "EQUIVALENTS" - The exact documented version is required
- COMPLETE THE CHECKLIST - Every bundle installation MUST end with verification
After installing ALL packs in a bundle, complete this checklist:
## Bundle Installation Verification
### Pack Installation Status
- [ ] Pack 1: [name] - ALL files created, ALL code complete
- [ ] Pack 2: [name] - ALL files created, ALL code complete
- [ ] Pack 3: [name] - ALL files created, ALL code complete
- [ ] (continue for each pack...)
### Integration Verification
- [ ] Directory structure matches bundle specification
- [ ] All hooks registered in settings.json
- [ ] All dependencies between packs satisfied
- [ ] Verification commands from EACH pack passed
### Final Confirmation
- [ ] No "simplified" or "equivalent" implementations used
- [ ] Line counts approximately match documented code
- [ ] User informed of any customization neededIf ANY checkbox fails, the bundle is NOT installed.
Curated collections of packs that work together to achieve a larger goal.
A bundle is a curated collection of PAI packs designed to work together as a harmonious system.
Packs are directories containing complete subsystems organized around a single capability. Each pack contains:
README.md- Overview, architecture, what it solvesINSTALL.md- Step-by-step installation instructionsVERIFY.md- Mandatory verification checklistsrc/- Actual source code files (TypeScript, YAML, etc.)
For example, pai-hook-system provides an entire event-driven automation framework with all code files ready to copy.
Bundles are combinations of packs that work exceptionally well together—a harmonious system from a single author or unified around a single theme. The packs in a bundle were designed to integrate seamlessly, creating emergent capabilities greater than the sum of their parts.
Bundles can be organized around different purposes:
| Bundle Type | Description | Example |
|---|---|---|
| Creator Bundle | All packs from a specific creator | "The Official PAI (Kai) Bundle" - Daniel Miessler's complete system |
| Functionality Bundle | Packs that serve a specific purpose | "Research Bundle" - tools for investigation |
| Domain Bundle | Packs for a specific field | "Security Bundle" - security-focused tools |
| Starter Bundle | Minimal set to get started | "Kai Lite" - essential packs only |
While you can install packs individually, bundles provide:
| Value | Description |
|---|---|
| Curation | Tested combinations that work well together |
| Order | Proper installation sequence for dependencies |
| Synergy | Documentation of how packs interact |
| Completeness | Everything needed for a particular goal |
| Bundle | Description | Tier | Status |
|---|---|---|---|
| The Official PAI Bundle | Complete personal AI infrastructure from Daniel Miessler's Kai system | Complete | Active |
More bundles coming soon
- Open the bundle's directory (the README displays automatically)
- Give it to your DA
- Say: "Install this bundle into my system"
Your DA will:
- Analyze first - Review all packs that need to be installed and their dependencies
- Run the wizard - If the bundle includes a setup wizard, walk you through it to collect personalization data (DA name, personality, contacts, technical preferences, etc.)
- Install in order - Install packs in the correct sequence based on dependencies
- Configure connections - Set up integrations between packs
- Verify installation - Confirm each pack works and validate the bundle as a whole
Follow the bundle's README file:
- Install prerequisite packs first
- Install core packs in listed order
- Install optional packs as desired
- Run bundle verification
Bundles are collections - you can install just the packs you want from a bundle.
| Aspect | Pack | Bundle |
|---|---|---|
| Scope | Complete subsystem around one theme | Harmonious combination of subsystems |
| Structure | Directory with README.md, INSTALL.md, VERIFY.md, src/ | Directory with README.md referencing packs |
| Code | Contains actual source files in src/ | References pack directories |
| Installation | Can be standalone | Ordered sequence with dependencies |
| Value | Complete functionality for one domain | Integrated experience across domains |
Create a bundle when:
- Multiple packs serve a unified purpose
- Packs have installation order dependencies
- The combination creates emergent capabilities
- You want to share a curated experience
Bundles/
└── YourBundle/
├── README.md # Bundle specification (required, auto-displays on GitHub)
└── your-bundle-icon.png # Bundle icon (optional)
Use the following structure for your bundle's README.md:
---
name: {Bundle Name}
bundle-id: {author}-{bundle-name}-v{version}
version: 1.0.0
author: {github username}
description: {Brief description - 128 words max}
type: bundle
purpose: {One sentence - what this bundle achieves}
tier: {starter|intermediate|advanced|complete}
platform: {agnostic|claude-code|opencode|cursor}
pack-count: {number of packs included}
dependencies: []
keywords: [searchable, tags]
---- Why This Is Different - (128 words max) Opens with "This sounds similar to [ALTERNATIVE] which also does [CAPABILITY]. What makes this approach different?" followed by a 64-word paragraph and four 8-word bullets
- Purpose - What the bundle achieves as a whole
- Philosophy - Principles behind the curation
- Contents - Complete pack listing with installation order
- Pack Relationships - How packs interact and depend on each other
- Installation - Combined installation steps
- Verification - How to verify the bundle is working
- What You Get - Capabilities after full installation
- Credits - Attribution
- Related Bundles - Similar or complementary bundles
- Changelog - Version history
List packs in installation order:
### Required Packs (Install in Order)
| # | Pack | Type | Purpose | Status |
|---|------|------|---------|--------|
| 1 | pack-name | feature | What it does | Available |
| 2 | another-pack | hook | What it does | Coming Soon |
### Recommended Packs
| Pack | Type | Purpose | Status |
|------|------|---------|--------|
| optional-pack | tool | Enhancement | Available |
### Optional Packs
| Pack | Type | Purpose | Status |
|------|------|---------|--------|
| extra-pack | integration | Nice to have | Available || Tier | Description | Typical Size |
|---|---|---|
| Starter | Minimal viable collection | 2-3 packs |
| Intermediate | Core functionality | 4-6 packs |
| Advanced | Extended capabilities | 7-10 packs |
| Complete | Full experience | 10+ packs |
A bundle must:
- Include only packs that serve the stated purpose
- Document installation order clearly
- Explain pack relationships and dependencies
- Provide bundle-level verification steps
- Have a clear, unified purpose
- Mark pack availability status (Available/Coming Soon)
- Follow the bundle template structure
Individual packs are powerful, but:
- Users may not know which packs work well together
- Installation order matters for dependencies
- Some capabilities emerge only from combinations
- Curation provides tested, production-ready setups
A well-designed bundle is more than the sum of its packs. It provides:
- Coherent Vision - Packs selected for a unified goal
- Tested Integration - Known to work together
- Documented Synergies - How capabilities combine
- Reduced Friction - No guessing about compatibility
Yes. Bundles are documentation of curated collections. You can install any subset of packs you want.
Bundle listings show pack status (Available/Coming Soon). Install available packs first; others will be added as they're released.
Absolutely. Fork the repo, create a new directory in Bundles/, and follow the template.
Bundles reference packs by name. When a pack is updated, reinstall it to get the latest version.
- PAI Repository
- Pack System
- The Official PAI Bundle - Reference implementation
PAI Bundle System v2.0 - Curated experiences with directory-based packs.