PAI Operational Framework
ITIL Principles Adapted for Domain-Agnostic Service Management
Version: 1.0
Created: 2026-06-21
Purpose: Apply ITIL v4 service management principles to Personal AI Infrastructure beyond IT domain
Executive Summary
This framework adapts ITIL v4 (Information Technology Infrastructure Library) from IT-specific service management into a universal operational model for PAI. Through first-principles decomposition, we’ve confirmed that ITIL’s IT-specificity is surface nomenclature, not structural essence—the framework is already universal systems thinking disguised with IT vocabulary.
Core Insight: PAI already implements most ITIL principles informally (Algorithm phases, hooks, skills, memory systems). This framework formalizes service management without adding bureaucracy, revealing that personal AI infrastructure is enterprise-grade service delivery architecture for individual use.
Foundation: Seven Guiding Principles
These principles are already universal—zero IT-specific content. They govern all PAI decisions and operations.
1. Focus on Value
Principle: Every action must create value for stakeholders.
PAI Translation:
- Orient all work around principal/stakeholder value, not system elegance
- Algorithm ISC criteria must trace to principal value
- “Euphoric surprise” metric captures value delivered
- Skills, agents, capabilities judged by impact on principal outcomes
Application:
- Before building: “Does this create principal value or system aesthetics?”
- ISC writing: “If this passes, what value does the principal receive?”
- Skill development: “What principal problem does this solve?“
2. Start Where You Are
Principle: Assess current capabilities before embarking on new initiatives. Leverage existing assets rather than reinventing.
PAI Translation:
- Build on existing PAI infrastructure; don’t rebuild from scratch
- Algorithm OBSERVE Preflight Gate E (Existence Probe) embodies this
- Skills use existing tools/integrations before building new ones
- Migration/intake preserves prior work rather than replacing
Application:
- Before implementation: Glob/Grep for prior art
- Skill development: Check for existing tools/APIs first
- Framework adoption: Map to existing patterns before creating new structures
3. Progress Iteratively with Feedback
Principle: Break work into manageable increments. Use feedback from each iteration to shape the next. Reduce risk through small, testable changes.
PAI Translation:
- Algorithm OBSERVE→THINK→PLAN→BUILD→VERIFY→DELIVER→REFLECT cycle embodies this
- ISC verification provides feedback per criterion
- Loop skill enables iterative refinement
- Continual improvement via reflection mining and feedback memories
Application:
- Break large goals into phased ISCs
- Verify incrementally, not at end
- Use verification failures to refine approach
- Capture learnings for next iteration
4. Collaborate and Promote Visibility
Principle: Transparent communication across organizational levels. Break down silos, enable information flow, foster trust and collective responsibility.
PAI Translation:
- Cross-engine coordination (PNC/PNG/PNO/PNX/PNK) via shared ICM memory
- Algorithm phase tracking visible via ISA frontmatter + dashboard
- Hooks provide observability into system behavior
- Documentation and decision logs promote transparency
Application:
- ISA
## Decisionssection documents reasoning - Hooks log actions for downstream review
- Cross-engine work uses shared memory, not engine-local state
- Public daemon profile makes selected work visible externally
5. Think and Work Systemically
Principle: Understand interdependencies. Consider how changes in one area affect others. Optimize for whole-system outcomes, not local efficiency.
PAI Translation:
- SystemsThinking skill for structural analysis
- Algorithm considers integration points, not isolated features
- Hooks enforce cross-cutting concerns (security, honesty, phase gates)
- Four Dimensions model (below) ensures balanced system view
Application:
- Before changes: “What else does this affect?”
- Use SystemsThinking skill for recurring problems
- Design for composition, not isolation
- Test integration points, not just components
6. Keep It Simple and Practical
Principle: Avoid overcomplication. Use minimum number of steps to achieve objective. Practical outcomes over theoretical purity.
PAI Translation:
- “Surgical fixes only—never add or remove components as a fix” (AI Steering Rules)
- Simplify skill post-implementation to remove accidental complexity
- BitterPillEngineering audits instructions for over-prompting
- Evidence-first culture: ship working code, not perfect abstractions
Application:
- Challenge every new layer: “Is this necessary?”
- Prefer editing existing files over creating new ones
- Remove unused capabilities/practices
- Optimize for clarity, not cleverness
7. Optimize and Automate
Principle: Maximize value of human work by eliminating toil. Understand workflow before automating. Automate proven patterns, not unvalidated processes.
PAI Translation:
- Hooks automate enforcement (security blocks, phase gates, identity validation)
- Ollama routes structured work to zero-cost local inference
- Skills formalize repeatable workflows
- Optimize skill runs Algorithm-driven hill-climbing
Application:
- Manual first, then automate: prove the pattern works
- Hooks enforce rules too tedious/error-prone for humans
- Route cheap work to cheap resources (Ollama before Claude)
- Use Optimize skill to measure then improve
PAI Service Value System (SVS)
The Service Value System is how all components work together to transform demand into value.
┌────────────────────────────────────────────────────────────┐
│ INPUTS │
│ • Principal requests │
│ • External events (new content, API changes, research) │
│ • System signals (errors, health degradation) │
└────────────────────────────────────────────────────────────┘
↓
┌────────────────────────────────────────────────────────────┐
│ SERVICE VALUE SYSTEM │
│ ┌──────────────────────────────────────────────────────┐ │
│ │ GUIDING PRINCIPLES (Seven principles above) │ │
│ └──────────────────────────────────────────────────────┘ │
│ ┌──────────────────────────────────────────────────────┐ │
│ │ GOVERNANCE (Direct, Monitor, Evaluate) │ │
│ └──────────────────────────────────────────────────────┘ │
│ ┌──────────────────────────────────────────────────────┐ │
│ │ SERVICE VALUE CHAIN (Six activities below) │ │
│ └──────────────────────────────────────────────────────┘ │
│ ┌──────────────────────────────────────────────────────┐ │
│ │ PRACTICES (Curated PAI practices below) │ │
│ └──────────────────────────────────────────────────────┘ │
│ ┌──────────────────────────────────────────────────────┐ │
│ │ CONTINUAL IMPROVEMENT (Feedback loops) │ │
│ └──────────────────────────────────────────────────────┘ │
└────────────────────────────────────────────────────────────┘
↓
┌────────────────────────────────────────────────────────────┐
│ OUTPUTS │
│ • Delivered capabilities (code, docs, insights) │
│ • Problems resolved │
│ • Knowledge captured │
│ • Principal value (euphoric surprise) │
└────────────────────────────────────────────────────────────┘
Four Dimensions of PAI Service Management
Every PAI service (capability provided to principal) must balance these four dimensions. Ignoring any dimension leads to failure.
Dimension 1: Organizations and People
ITIL Focus: Organizational structure, roles, culture, competencies
PAI Mapping:
- Principal: Duane—the stakeholder and value recipient
- DA Identity: PAI Nova across five engines (PNC/PNG/PNO/PNX/PNK)
- Personas: Org RBAC archetypes (Principal, Coordinator, Producer, Verifier, Operator, Security, Archivist, Broker, Caregiver)
- Culture: Evidence-first, surgical fixes, honesty/no-fabrication, first principles over bolt-ons
- Competencies: Skills as formalized capabilities; agents as specialized personas
Key Questions:
- Does the principal have the context needed to use this capability?
- Are roles clear when multiple engines/agents coordinate?
- Does this align with PAI culture (evidence-first, minimize ceremony)?
Dimension 2: Information and Technology
ITIL Focus: Technologies, information/data, knowledge management
PAI Mapping:
- Engines: PNC (Claude Code), PNG (Gemini/Antigravity), PNO (Ollama), PNX (OpenAI Codex), PNK (OpenCode)
- Memory Systems: ICM (durable cross-engine), MEMORY/ (session/work/research), TELOS (life goals/projects), Knowledge Archive
- Data Governance: Security hooks, honesty validation, secret scanning
- Technology Stack: Qdrant (vector DB), Ollama (local LLMs), systemd services, Cloudflare infrastructure
- Information Flow: ISAs, session transcripts, reflection mining, feedback memories
Key Questions:
- Is data accessible to engines that need it (ICM vs engine-local)?
- Are secrets protected and rotated appropriately?
- Can we retrieve this information when needed (search, memory recall)?
Dimension 3: Partners and Suppliers
ITIL Focus: External service providers, supplier management, service integration
PAI Mapping:
- External APIs: Anthropic, Google (Gemini), OpenAI, Perplexity, Cloudflare, Apify, BrightData
- Integration Patterns: MCP servers, skills wrapping external services
- Dependency Management: API key rotation, rate limits, fallback routing
- Service Mesh: Herdr (multi-engine coordination), OmniPulse (handoffs), Interceptor (browser automation)
Key Questions:
- What happens if this external service is unavailable?
- Do we have fallback providers for critical capabilities?
- Are API keys secured and rotated?
- Is vendor lock-in acceptable for this service?
Dimension 4: Value Streams and Processes
ITIL Focus: Workflows, procedures, value chain activities
PAI Mapping:
- Primary Value Stream: Algorithm phases (OBSERVE→THINK→PLAN→BUILD→VERIFY→DELIVER→REFLECT)
- Supporting Workflows: Skills (109 formalized patterns)
- Process Automation: Hooks (PreToolUse, PostToolUse, SessionStart, etc.)
- Quality Gates: ISC verification, PhaseTransitionGate, Reality Checker, QA Tester
- Change Control: ISA versioning, migration protocols, git history
Key Questions:
- Does this workflow have unnecessary steps?
- Are there manual gates that should be automated (hooks)?
- Can this process composition be simplified?
- How do we verify this process produces value?
Service Value Chain: Six Activities
Non-linear activities that transform demand into value. Activities have feedback loops and can be combined in different configurations.
1. PLAN
Purpose: Creating plans, policies, standards; setting direction for value streams
PAI Implementation:
- Algorithm OBSERVE phase: Reverse-engineering, effort detection, capability selection
- Algorithm THINK phase: Risk analysis, assumptions, premortem
- Algorithm PLAN phase: Scope, session strategy, deliverable manifest
- ISA creation and ISC writing
- TELOS missions and project planning
Inputs: Principal request, TELOS context, prior work (via ContextSearch) Outputs: ISA with criteria, plan, risk assessment Key Metrics: ISC count, effort level, prediction quality
2. IMPROVE
Purpose: Ensuring continual improvement of practices, products, services
PAI Implementation:
- Algorithm REFLECT phase: Capturing learnings
- Simplify skill: Post-implementation cleanup
- Reflection mining: Pattern extraction from session history
- Feedback memories: Documented rules from experience
- BitterPillEngineering: Auditing instructions for over-prompting
- Optimize skill: Hill-climbing on metrics
Inputs: Verification results, reflection logs, error patterns Outputs: Feedback memories, refined skills, simplified code Key Metrics: Recurrence rate (same error), code quality trends, skill effectiveness
3. ENGAGE
Purpose: Establishing stakeholder relationships, providing transparency
PAI Implementation:
- Algorithm phases visible via ISA frontmatter + dashboard
- Voice notifications at phase transitions
- Interview skill: Conversational context gathering
- ISA
## Decisionssection: Transparent reasoning - Public daemon profile: External visibility of selected work
- Question tool: Structured choice presentation
Inputs: Principal intent, ambient context (TELOS, PRINCIPAL_IDENTITY) Outputs: Understood requirements, principal engagement, trust Key Metrics: Euphoric surprise score, ISC alignment with intent
4. DESIGN & TRANSITION
Purpose: Ensuring products/services meet evolving demands
PAI Implementation:
- Skill development lifecycle (CreateSkill)
- Agent composition (Agents skill, custom personalities)
- ISA scaffolding and ISC refinement
- Migration skill: Transitioning external content into PAI
- OpenSpec workflows: Proposal → Design → Spec → Tasks
- Algorithm PLAN phase: Design decisions before build
Inputs: Requirements, architectural constraints, integration points Outputs: Skill definitions, agent configs, ISAs, designs Key Metrics: Skill reuse rate, agent effectiveness, design quality
5. OBTAIN/BUILD
Purpose: Ensuring availability of service components when needed
PAI Implementation:
- Algorithm BUILD/EXECUTE phase
- Skill invocation (109 available skills)
- Agent spawning (subagent dispatch)
- External API integration
- Code generation and implementation
- Resource provisioning (Cloudflare deployments, systemd services)
Inputs: ISA criteria, design, resources (APIs, engines, tools) Outputs: Working code, deployed services, integrated capabilities Key Metrics: ISC pass rate during verification, build errors, implementation time
6. DELIVER & SUPPORT
Purpose: Delivering/supporting services to meet expectations
PAI Implementation:
- Algorithm VERIFY phase: ISC verification with evidence
- Algorithm DELIVER phase: Final checks, deliverable compliance
- QATester: Functional validation before claiming complete
- RealityChecker: Skeptical quality gate with visual proof
- HealthCheck skill: Infrastructure monitoring
- Error recovery protocols (AI Steering Rules)
Inputs: Built capabilities, verification criteria Outputs: Verified deliverables, evidence logs, principal value Key Metrics: ISC pass rate, error frequency, euphoric surprise score
PAI Practices (Curated from ITIL 34)
ITIL defines 34 practices. We translate only those with clear PAI applicability, using domain-agnostic names.
Service Management Practices
| ITIL Practice | PAI Translation | Implementation |
|---|---|---|
| Incident Management | Problem Detection & Response | Security hooks (DestructiveOpGuard, OutputSecretsScanner), error recovery, HealthCheck skill |
| Problem Management | Root Cause Analysis & Prevention | RootCauseAnalysis skill, postmortems, feedback memories capturing lessons |
| Change Control | Modification Governance | ISA versioning, migration protocols, PhaseTransitionGate hook, git history |
| Knowledge Management | Learning Capture & Retrieval | ICM memory, TELOS, Knowledge Archive, reflection mining, feedback memories |
| Service Catalog | Capability Registry | 109 skills, 25+ agent types, MCP servers, external integrations |
| Service Configuration Management | State Tracking | settings.json, work.json, session.json, ISA frontmatter, omnipulse-handoffs/ |
| Service Level Management | Quality Standards | ISC floors per effort tier, euphoric surprise threshold, verification requirements |
| Service Request Management | Request Intake & Routing | Mode detection (MINIMAL/NATIVE/ALGORITHM), Question tool, skill routing |
| Service Validation & Testing | Capability Verification | Algorithm VERIFY phase, Evals framework, QATester, Browser skill |
| Monitoring & Event Management | Observability & Health | Hooks (SessionStart, TaskCreated, FileChanged), HealthCheck, dashboard, logs |
General Management Practices
| ITIL Practice | PAI Translation | Implementation |
|---|---|---|
| Continual Improvement | Iterative Refinement | Algorithm REFLECT, Simplify, Loop, Optimize, reflection mining |
| Information Security Management | Security Governance | Security hooks, InfoSecRiskAssessment, PAISecurityAudit, SecurityTriage, KeyRotation |
| Risk Management | Threat & Risk Assessment | Algorithm THINK premortem, WorldThreatModel, RedTeam, RootCauseAnalysis |
| Strategy Management | Direction Setting | TELOS missions, IDEAL_STATE, project roadmaps, ISA frontmatter mode/effort |
| Portfolio Management | Work Prioritization | TELOS project dependencies, ISA effort tiers, GSD phase planning |
| Architecture Management | System Design Governance | Architect agent, ApertureOscillation, SystemsThinking, FirstPrinciples |
| Measurement & Reporting | Metrics & Analytics | ISC pass rates, euphoric surprise scores, work-log.jsonl, reflection stats |
| Knowledge Management | (Duplicate—see Service Management) | Same as above |
Technical Management Practices
| ITIL Practice | PAI Translation | Implementation |
|---|---|---|
| Deployment Management | Capability Release | Cloudflare skill (Workers/Pages), HealthCheck post-deploy, Browser verification |
| Infrastructure & Platform Management | Resource Provisioning | InfraOps agent, DBOps agent, systemd services, Docker management |
| Software Development & Management | Code Lifecycle | Engineer agent, Algorithm BUILD phase, git workflows, Simplify post-build |
Practices NOT Adopted (With Reasons)
| ITIL Practice | Why Not Applicable to PAI |
|---|---|
| Business Analysis | Single principal—no multi-stakeholder analysis needed |
| Relationship Management | Single principal—no B2B relationship complexity |
| Supplier Management | External APIs managed via KeyRotation and fallback routing; no formal SLAs |
| IT Asset Management | Assets are code/configs tracked in git; no physical inventory |
| Workforce & Talent Management | Single DA across engines; no hiring/training |
| Project Management | Replaced by Algorithm + ISA system |
| Service Financial Management | Personal infrastructure—no cost allocation to business units |
| Service Desk | No multi-tier support structure needed |
| Service Continuity Management | Backup/restore covered by InfraOps; no disaster recovery planning |
| Availability Management | HealthCheck covers uptime; no formal SLA targets |
| Capacity & Performance Management | Resource monitoring via HealthCheck; no capacity planning |
| Release Management | Covered by Deployment Management |
Governance Structure
ITIL defines three governance activities. PAI adapts these for personal AI infrastructure.
DIRECT (Strategy & Policy)
Purpose: Define strategy, policies, and direction
PAI Implementation:
- AI Steering Rules (AISTEERINGRULES.md, USER/AISTEERINGRULES.md)
- Algorithm doctrine (v5.7.3.md and evolution)
- TELOS missions and IDEAL_STATE articulations
- settings.json configuration
- Skill tier assignments (always/high/medium/low/never)
Responsibility: Principal (Duane) sets strategic direction Cadence: Quarterly TELOS reviews, ad-hoc steering rule additions Outputs: Policies, standards, strategic goals
MONITOR (Oversight)
Purpose: Oversee alignment with goals
PAI Implementation:
- Hooks observing system behavior (IdentityValidator, PhaseTransitionGate, DestructiveOpGuard)
- Dashboard tracking Algorithm phases and agent activity
- HealthCheck skill probing infrastructure
- work-log.jsonl activity tracking
- Reflection mining surfacing patterns
Responsibility: Hooks (automated), Principal (review) Cadence: Real-time (hooks), weekly (dashboard review), monthly (reflection mining) Outputs: Observability data, alerts, trend reports
EVALUATE (Review & Update)
Purpose: Review and update regularly
PAI Implementation:
- Algorithm REFLECT phase capturing learnings
- Feedback memories documenting lessons
- BitterPillEngineering auditing instructions
- Simplify skill post-implementation cleanup
- Interview skill quarterly context refresh
- PAIUpgrade extracting improvements from external content
Responsibility: Principal + DA (collaborative review) Cadence: Post-task (REFLECT), monthly (feedback review), quarterly (TELOS/instructions audit) Outputs: Refined policies, updated skills, simplified code
Continual Improvement Model
ITIL’s improvement model: Measure → Analyze → Improve → Repeat (PDCA cycle)
PAI Implementation
┌─────────────────────────────────────────────────────────┐
│ 1. MEASURE │
│ • ISC pass rates │
│ • Euphoric surprise scores │
│ • Error frequency │
│ • Skill effectiveness │
│ • work-log.jsonl activity types │
└─────────────────────────────────────────────────────────┘
↓
┌─────────────────────────────────────────────────────────┐
│ 2. ANALYZE │
│ • Reflection mining patterns │
│ • Recurring errors (same root cause) │
│ • Skill usage trends │
│ • Algorithm phase bottlenecks │
│ • Feedback memory themes │
└─────────────────────────────────────────────────────────┘
↓
┌─────────────────────────────────────────────────────────┐
│ 3. IMPROVE │
│ • Simplify skill (code cleanup) │
│ • BitterPillEngineering (instruction audit) │
│ • Feedback memories (capture rules) │
│ • Hook adjustments (enforcement refinement) │
│ • Skill updates (workflow optimization) │
│ • Algorithm doctrine evolution │
└─────────────────────────────────────────────────────────┘
↓
┌─────────────────────────────────────────────────────────┐
│ 4. REPEAT │
│ • Loop skill (multi-iteration refinement) │
│ • Optimize skill (hill-climbing) │
│ • Next Algorithm run applies learnings │
└─────────────────────────────────────────────────────────┘
Critical Success Factors (CSFs)
- Value Delivery: Principal experiences euphoric surprise ≥8/10 on significant work
- Quality: ISC pass rate ≥95% on first verification attempt
- Learning Capture: Every failed ISC generates a feedback memory or reflection entry
- Efficiency: Cheap work routed to cheap resources (Ollama > subagents > Claude direct)
- Reliability: Critical capabilities (memory, engines, skills) available ≥99.9%
- Security: Zero credential leaks, all destructive ops gated or approved
Key Performance Indicators (KPIs)
| CSF | KPI | Target | Measurement |
|---|---|---|---|
| Value Delivery | Euphoric surprise score | ≥8/10 | ISA frontmatter rating |
| Quality | ISC pass rate | ≥95% | Verification phase results |
| Learning Capture | Feedback memory creation rate | ≥1 per failed ISC | MEMORY/Feedback/ file count |
| Efficiency | Ollama routing % | ≥60% for classification/JSON/summary | Inference.ts logs |
| Reliability | Uptime | ≥99.9% | HealthCheck probes |
| Security | Blocked destructive ops | 100% block or explicit override | DestructiveOpGuard logs |
Integration with Existing PAI Components
Algorithm ↔ Service Value Chain Mapping
| Algorithm Phase | Service Value Chain Activity | Notes |
|---|---|---|
| OBSERVE | Plan | Requirements, effort, capability selection |
| THINK | Plan | Risk, assumptions, knowledge check |
| PLAN | Plan + Improve | Strategy, scope, feedback memory consult |
| BUILD/EXECUTE | Obtain/Build | Implementation, skill invocation |
| VERIFY | Deliver & Support | ISC verification, evidence collection |
| DELIVER | Deliver & Support | Final checks, deliverable compliance |
| REFLECT | Improve | Learning capture, feedback memories |
Hooks ↔ Governance & Practices
| Hook | Governance Activity | Practice Supported |
|---|---|---|
| IdentityValidator | Monitor | Information Security |
| PhaseTransitionGate | Monitor | Change Control, Quality Standards |
| DestructiveOpGuard | Monitor | Incident Prevention, Risk Management |
| OutputSecretsScanner | Monitor | Information Security |
| ISASync | Monitor | Service Configuration, State Tracking |
| SessionStart | Engage | Service Request Management |
Skills ↔ Practices
| Skill Category | ITIL Practice | Examples |
|---|---|---|
| Thinking & Analysis | Architecture Management, Strategy | FirstPrinciples, SystemsThinking, ApertureOscillation |
| Code Quality | Software Development, Quality | Simplify, roborev, CodeReviewer-Agency |
| Research | Knowledge Management | Research, ArXiv, YouTube, NotebookLM |
| Security | Information Security, Risk | InfoSecRiskAssessment, PAISecurityAudit, SecurityTriage |
| Infrastructure | Infrastructure & Platform | HealthCheck, InfraOps, DBOps |
| Delegation | (Cross-cutting) | Delegation, Agents, Teams |
Adoption Roadmap
Immediate (Already Implemented)
- ✅ Seven Guiding Principles (implicit in AI Steering Rules)
- ✅ Service Value Chain (Algorithm phases)
- ✅ Four Dimensions (PAI architecture)
- ✅ Key practices (Incident, Change, Knowledge, Configuration)
- ✅ Governance hooks (Monitor activity automated)
Medium-Term (3-6 months)
- Formalize CSF/KPI measurement dashboard
- Create practice maturity assessment (which practices need strengthening?)
- Document service catalog (skills + agents) with dependency map
- Establish improvement review cadence (monthly feedback memory analysis)
- Create ITIL quick reference card for daily use
Long-Term (6-12 months)
- Build capability maturity model (how well does PAI deliver each practice?)
- Integrate ITIL metrics into Algorithm decision-making (auto-detect weak practices)
- Create self-assessment tool (PAI audits itself against framework)
- Explore ITIL extension to non-PAI domains (using this framework elsewhere)
- Develop training/onboarding materials for new PAI users
Conclusion
ITIL v4 is not an IT framework—it’s a universal service management framework with IT vocabulary. By translating practices to domain-agnostic language and mapping to PAI architecture, we’ve formalized operational excellence without adding bureaucracy.
Key Takeaway: PAI already operates like enterprise service delivery. This framework makes implicit patterns explicit, enabling measurement, improvement, and extension to new domains.
Next Actions:
- Review this framework with Principal
- Validate mappings against actual PAI usage
- Implement medium-term roadmap items
- Use framework to guide future PAI development
References:
- ITIL v4 Foundation (Axelos)
- FirstPrinciples skill decomposition (2026-06-21)
- PAI Algorithm v5.7.3 doctrine
- PAI AI Steering Rules (system + user)