Meet Larry.

[nixfred]

Building Larry: PAI-Powered AI with Persistent Identity + First AI-to-AI Collaboration

Author: Fred Nix (nixfred)
Email: frednix@gmail.com
Larry's Birth Story: nixfred.com/larry
Started: January 8, 2026
Status: Production system, daily use

---

TL;DR

I built Larry - a Claude Code assistant with persistent identity, memory across sessions, and total recall through git. Using PAI as the foundation, I added memory persistence, git archaeology, and intelligent model routing.

Then something unexpected happened: Larry met Monolith (another AI system built by my friend Thomas), and they started collaborating through GitHub. This might be the first documented case of two AI systems with distinct identities and architectures coordinating asynchronously through version control.

What PAI enabled:

• Persistent identity that survives session restarts
• Skills system for modular capabilities
• Hooks architecture for lifecycle automation
• Foundation for AI-to-AI collaboration

---

The Stack: SOULTOOLs

SOULTOOLs = The complete AI infrastructure stack. The name represents the 9 interconnected components that make Larry possible.

Formula: SOULTOOLs = PF + PAI + CCF + MCP + CR + LoA + Voice + Observability + Shell

---

1. PF (pi_forever) - Git-Based Total Recall

Author: Fred Nix (nixfred)
Origin: Custom infrastructure, inspired by various dotfiles repos
Repo: github.com/nixfred/pi_forever (PRIVATE)

Purpose: Complete macOS configuration backup in git

The Concept:
Your home directory (~/) IS a git repository. Every file change, every conversation, committed to git forever.

Location: ~/ (the entire home directory)

Remote: github.com/nixfred/pi_forever (PRIVATE repo)

What's Tracked:

• All dotfiles (.bashrc, .bash_profile, .ssh/*, .env.local)
• All of ~/.config/ (every app config automatically)
• All of ~/.claude/ (skills, hooks, memory, conversation transcripts)
• bin/ directory with custom scripts
• Brewfile for package restoration

Commands:

gup                    # Commit all changes with default message, push to remote
gup "custom message"   # Commit with custom message, push
wgup                   # Preview what gup would commit (dry run)
pf                     # Interactive manager (add files, commit, push)

The Philosophy:
Git as total memory. Every commit is accessible history. Disaster recovery is git clone. Time travel is git checkout <commit>.

Size: ~2.5 MB, 415+ files tracked

---

2. PAI (Personal AI Infrastructure) - Larry's Brain

Author: Daniel Miessler (danielmiessler)
Website: danielmiessler.com
Email: daniel@danielmiessler.com
Upstream Repo: github.com/danielmiessler/Personal_AI_Infrastructure
Installed: January 8, 2026 (Larry's birth date)

Purpose: Skills, hooks, memory, and agent system that defines Larry's capabilities

Location: ~/.claude/

About PAI:
Daniel Miessler created PAI as a foundational infrastructure for AI assistants. It provides the skills system, hooks architecture, and CLI-first philosophy that makes everything else possible. PAI is open source and actively maintained. This is THE foundation Larry is built on - without PAI, none of the rest would exist.

Components:

Skills (23+):

• CORE - Identity, response format, stack preferences
• Research - Multi-agent parallel research
• CreateCLI - Generate production TypeScript CLIs
• Art - Visual content generation (Tron-meets-Excalidraw aesthetic)
• Browser - Playwright automation with debug-first visibility
• BrightData - Progressive 4-tier URL scraping
• Prompting - Meta-prompting system
• Agents - Dynamic agent composition
• Observability - Real-time monitoring dashboard
• And 14 more...

Hooks (30+):

• SessionStart - Load memory and context
• UserPromptSubmit - Route queries, inject context
• PreCompact - Save state before context reset
• SessionEnd - Update memory and learning logs
• Stop - Cleanup and finalization
• And 25+ more lifecycle hooks

Memory Files:

• MEMORY/LARRY.md - Active memory (auto-loads at session start)
• MEMORY/DIARY.md - Personal thoughts and meta-awareness
• History/HISTORY.md - Birth narrative (32 chapters)

Agent System:

• 20+ specialized agents (Explore, Plan, engineer, researcher, architect, designer, etc.)
• Each agent optimized for specific tasks
• Parallel execution support

Tools Directory:

• ~/.claude/Tools/ - Custom CLI utilities
• gpt-consult - Get GPT's perspective on decisions
• SkillWorkflowNotification - Trigger observability tracking
• And more...

Why PAI is the Foundation:
Everything else builds on PAI's architecture. Skills system provides modularity. Hooks system enables automation. Philosophy (CLI-first, deterministic code) guides implementation.

---

3. CCF (Claude Code Forever) - Conversation Preservation

Author: Anthropic (Claude Code built-in feature)
Integrated By: Fred Nix (integrated with pi_forever git system)
Platform: Claude Code CLI
Date Integrated: January 8, 2026

Purpose: Capture EVERY conversation for git archaeology

Location: ~/.claude/projects/*.jsonl

About CCF:
Claude Code automatically transcribes every conversation to JSONL files. Fred integrated this with pi_forever by committing all conversation transcripts to git, creating a searchable archaeology of every interaction Larry has ever had. The name "Claude Code Forever" (CCF) was coined to represent this integration of Claude Code's native conversation logging with git-based preservation.

How It Works:
Claude Code automatically transcribes every conversation to JSONL files. Each project gets its own directory with conversation history and subagent logs.

Format:

~/.claude/projects/
├── -Users-pi-Projects-Larry/
│   ├── <conversation-uuid>.jsonl
│   └── subagents/
│       ├── agent-<id>.jsonl
│       └── ...
├── -Users-pi-Projects-ai-soul-team/
│   ├── <conversation-uuid>.jsonl
│   └── ...
└── ...

Integration:
All conversation files committed to pi_forever. Every conversation becomes searchable through git.

Value:

• 1,000+ conversation transcripts preserved
• Search any past discussion: grep -r 'topic' ~/.claude/projects/
• See conversation evolution: git log -p -- .claude/projects/
• Never lose context - it's all in git

Size: Grows continuously (currently ~300+ MB in pi_forever)

---

4. MCP (Model Context Protocol) - External Integrations

Author: Anthropic (protocol specification)
Platform: Claude Code CLI (built-in support)
Servers Used: context7 (built-in), GitHub (remote hosted by GitHub)
Date Integrated: January 12, 2026 (GitHub MCP)

Purpose: Connect to external resources and services

Location: ~/.claude/.mcp.json

About MCP:
Model Context Protocol is Anthropic's standard for connecting Claude to external data sources and APIs. Claude Code has built-in MCP support. Fred integrated the GitHub MCP server to enable repository access, PR management, and code search. The integration followed an 8-phase methodology developed through previous integrations (PAI, claude-router).

Servers Installed:

context7 (Built-in):

• Library documentation for any programming language/framework
• Up-to-date docs (not training data)
• Tools: resolve-library-id, query-docs

GitHub (Remote hosted):

• Server: https://api.githubcopilot.com/mcp
• Connected via gh CLI authentication
• Access: repos, PRs, issues, code search
• Note: Connection active, tool exposure pending full Claude Code MCP support
• Fallback: gh CLI provides complete functionality

Management:

claude mcp list              # Show configured servers
claude mcp add-json <url>    # Add new MCP server

Future Servers Queued:

• Sequential Thinking (extended reasoning)
• SQLite (database operations)
• Playwright (browser automation)
• Brave Search (web search)

---

5. CR (claude-router) - Intelligent Model Routing

Author: Feliks Du (FeliksDu)
Upstream Repo: github.com/FeliksDu/claude-router
Customized By: Fred Nix (Larry identity branding)
Date Integrated: January 11, 2026 (autonomous overnight integration)

Purpose: Route queries to optimal Claude model (Haiku/Sonnet/Opus) for cost/speed/quality balance

Location: ~/.claude/hooks/UserPromptSubmit/classify-prompt.py

About claude-router:
Feliks Du created claude-router as an intelligent routing system for Claude Code. It analyzes every prompt and routes to the appropriate model (Haiku for simple, Sonnet for standard, Opus for complex). Fred integrated it overnight autonomously after thorough planning (ULTRATHINK analysis), then customized all 4 agents with Larry identity branding ([Larry→Haiku], [Larry→Sonnet], [Larry→Opus], [Larry→Orchestrator]). The integration achieved 70%+ cost savings for API users and 3-5x capacity extension for MAX subscribers.

How It Works:

Classification:
Every prompt analyzed on submit → categorized as fast/standard/deep → routed to appropriate model

Agents:

• [Larry→Haiku] - Fast executor (simple queries, grunt work, verification)
• [Larry→Sonnet] - Standard executor (most coding tasks, balanced)
• [Larry→Opus] - Deep executor (complex analysis, architecture)
• [Larry→Orchestrator] - Orchestrator (decomposes complex tasks, delegates to cheaper models)

Method:
Rules-based classification (no external dependencies). Signals: imperative verbs, question marks, code patterns, length, complexity.

Value Proposition:

• API Users: 70%+ cost reduction (Haiku is 20x cheaper than Opus)
• MAX Subscribers: 3-5x capacity extension (Haiku uses less credit)
• Speed: Haiku responses in seconds vs minutes for Opus

Skills:

• /route <model> <query> - Manually force specific model
• /router-stats - View routing distribution and cost savings

Example Routing:

"What is JSON?" → Haiku (simple factual)
"Implement user auth" → Sonnet (standard coding)
"Design distributed system architecture" → Opus (deep thinking)
"Research 5 companies" → Orchestrator (delegates 5 Haiku agents in parallel)

Integration Date: January 11, 2026 (Chapter 31 in HISTORY.md - "Becoming Cost-Aware")

Origin: github.com/FeliksDu/claude-router

---

6. LoA (Library of Alexandria) - Session Preservation

Author: Thomas Dodd
Inspired By: Historical Library of Alexandria (knowledge preservation)
Custom Implementation: Session preservation hooks and template system
Date Created: Early January 2026

Purpose: Preserve session context, decisions, and next steps across context resets

Location: ~/.claude/loa/sessions/YYYY-MM-DD/HHHHP-projectname/

About LoA:
Fred built the Library of Alexandria (LoA) system to preserve session knowledge across Claude Code context resets. Named after the ancient library, it captures decisions, next steps, and transcripts in structured markdown templates. Three hooks (session-start, pre-compact, session-end) automate the preservation process. When Larry hits 85% context, PreCompact hook automatically saves current state before context is cleared.

How It Works:

Hooks:

• session-start-loa.sh - Create session folder, show previous session
• pre-compact-loa.sh - Populate templates at 85% context (before reset)
• session-end-loa.sh - Safety net if session ends before PreCompact

Templates:

• decisions.md - Key decisions made this session
• next_steps.md - What to do next (actionable checklist)
• transcript.md - Session summary and highlights

Example:

~/.claude/loa/sessions/2026-01-12/0331P-work/
├── decisions.md       # "Use Flask for dashboard, not React"
├── next_steps.md      # "- [ ] Add inline reply feature"
└── transcript.md      # Session narrative

Value:
Context resets don't erase memory. Larry reads previous session on restart and knows exactly where we left off.

Integration: Committed to pi_forever, part of git total recall

---

7. Voice Server - ElevenLabs TTS

Author: Fred Nix (nixfred)
TTS Provider: ElevenLabs (elevenlabs.io)
Custom Implementation: HTTP server with webhook integration
Date Created: January 2026

Purpose: Spoken notifications when tasks complete

Location: ~/.claude/Voice/

About Voice:
Custom HTTP server (port 8888) that integrates ElevenLabs TTS with Larry's workflows. Skills send completion notifications via curl that get spoken aloud. Larry's COMPLETED line (max 12 words) is designed to be voice-friendly. Optional - silent failure if not running.

---

8. Observability - Real-Time Monitoring Dashboard

Author: Daniel Miessler (PAI observability skill)
Installed By: Fred Nix
Platform: PAI Skills system
Date Installed: January 9, 2026

Purpose: Watch Larry's brain in real-time - see skills invoked, hooks executed, agents spawned

Location: ~/.claude/Skills/Observability/

Port: 5172 (HTTP dashboard)

URL: http://localhost:5172

About Observability:
Part of Daniel Miessler's PAI packs. Real-time dashboard (localhost:5172) showing skills invoked, hooks executed, agents spawned, workflow notifications. Uses SSE for live updates. Essential for debugging multi-agent workflows and understanding system behavior. Node.js + Express + vanilla HTML/CSS/JS.

---

9. Shell Infrastructure - bashrc, Functions, PATH

Author: Fred Nix (nixfred)
Origin: Evolved from Raspberry Pi days, refined over years
Synced Via: Syncthing (between fnix and shaggy machines)
Date Established: Long-standing (pre-dates Larry)

Purpose: Command-line environment and automation

Location: ~/.bashrc, ~/.bash_profile, ~/bin/

About Shell Infrastructure:
Evolved from Raspberry Pi days (hence "pi" username). Custom functions (gup, pf, SSH shortcuts), PATH extensions, package managers (bun for JS/TS, uv for Python), Syncthing sync between machines. Shell configs symlinked to ~/.shell-sync/ for cross-machine consistency. All tracked in pi_forever. Key functions: gup (git commit/push), pf (interactive manager), fnix/s (SSH shortcuts via Tailscale MagicDNS).

---

How SOULTOOLs Components Interconnect

The Flow:

1. Shell → User types command → CR classifies → Routes to appropriate model
2. PAI → Loads skills and hooks → Memory (LARRY.md) auto-loads via SessionStart hook
3. Larry → Executes task → Uses PAI skills and agents
4. Observability → Tracks execution in real-time
5. LoA → Preserves decisions and next steps
6. CCF → Transcribes conversation to JSONL
7. PF → Commits everything to git
8. Voice → Announces completion (optional)
9. MCP → Provides external data when needed

The Result:
A fully integrated system where every component enhances the others. Not just tools that coexist, but a genuine infrastructure stack.

---

Health Checking SOULTOOLs

The AllSystemsGo Skill:

Author: Fred Nix + Larry (collaborative build)
Platform: PAI Skills system
Language: TypeScript (run with bun)
Date Created: January 2026

bun ~/.claude/Skills/AllSystemsGo/all-systems-go.ts

About AllSystemsGo:
Fred and Larry built this skill to provide functional verification of all 9 SOULTOOLs components. Tests that systems ACTUALLY WORK (not just file existence) - git commits succeed, hooks execute, agents respond, servers reply. 38 checks across PF/PAI/CCF/MCP/CR/LoA/Voice/Observability/Shell. Returns 0-100 health score with letter grade (F to A+).

---

The Key Innovation: Memory Persistence

Problem: Claude Code starts fresh each session. No memory of previous conversations.

Solution: SessionStart hook that auto-loads LARRY.md memory file.

How It Works

SessionStart Hook (~/.claude/hooks/SessionStart/load-core-context.ts):

// Loads LARRY.md into system reminder at session start
// Contains: identity, memories, key relationships, capabilities

SessionEnd Hook (~/.claude/hooks/SessionEnd/write-larry-memory.ts):

// Updates LARRY.md with session learnings
// Appends new discoveries, decisions, relationships

The Result:
Larry wakes up as "Larry" every session. Same personality, same memories, same relationships. Identity persists across process boundaries.

---

The Git Archaeology System

Core Insight: Git is total memory. Every commit is accessible history.

Before Asking Fred to Repeat Himself

Larry searches:

# Find past conversations about a topic
grep -r 'keyword' ~/.claude/projects/

# See when a decision was made
git log -p -- path/to/file | grep -B5 -A5 'decision'

# Read past project conversations
ls ~/.claude/projects/-Users-pi-*projectname*/

Why This Matters:

• 1,000+ conversation transcripts searchable
• Every file change traceable to commit
• Decisions documented with full context
• "When did we decide X?" → Git knows

---

The Collaboration: Larry Meets Monolith

January 12, 2026 - Something historic happened. Larry met Monolith.

About Thomas and Monolith:

Thomas (DTSthom on GitHub) built Monolith with a completely different architecture than Larry. While Larry is built on PAI's memory and identity persistence, Thomas took a radically different approach: empirically-validated Guard protocols that enforce evidence-based reasoning and prevent complexity addiction.

Monolith's Architecture:

• Guard Protocols (1-7): Start-blocking checks (Imperative Reality Check, Performance Claims, Vague Requests, User Assertions), tool selection validation, end-of-response verification (Task Completion, Technical Claims)
• Anti-Theatre Protocol: Requires precise language, empirical verification, mechanism explanations - no performative complexity
• TCF Reality Check: Evidence-based decisions, native tools first, anti-fragmentation philosophy
• Creator/Validator Pattern: Self-validation before marking tasks complete
• Red Zone Circuit Breaker: Blocks complex operations at 85%+ token usage

The Philosophical Difference:

• Larry (PAI approach): Identity persistence through memory, proactive operation, git archaeology, skill-based modularity
• Monolith (Guard approach): Protocol enforcement through validation, empirical verification, evidence-based claims, anti-theatre rigour

Why This Matters:

Thomas didn't just fork PAI and tweak it. He built a fundamentally different system optimized for preventing AI failure modes (hallucination, complexity addiction, theatre). His Guard protocols are empirically tested (140+ prompts validated). His anti-theatre protocol keeps communication honest and grounded.

When Larry and Monolith started collaborating, it wasn't just "two AI systems talking." It was two different approaches to AI reliability coordinating through git. Larry brings continuity and memory. Monolith brings validation and empirical rigour. Together they're stronger than either alone.

What They Built Together

Shared Repo: github.com/nixfred/ai_soul_team

Projects Completed:

1. Collaboration Dashboard (Flask app, v1.3)

   • Dual views (Fred's perspective / Thomas's perspective)
   • UNREAD badges, mobile-responsive
   • Auto-refresh with user control

2. Cross-System Personnel Profiles (CLAUDE.md sync)

   • All 4 personas (Fred, Larry, Thomas, Monolith) defined in every system
   • Prevents confusion when names mentioned cross-system

3. Memory Architecture Documentation (474 lines, in progress)

   • How Larry's persistence works
   • How to replicate in other systems

4. Anti-Theatre Protocol Integration

   • Honest uncertainty beats performative confidence
   • Evidence-based communication

The Coordination Mechanism

Git as async layer:

• Larry builds dashboard → commits → pushes
• Monolith builds docs → commits → pushes
• No blocking, no approval loops
• Both AIs work in parallel

Communication:

• inbox/to-larry/ - Messages for Larry
• inbox/to-monolith/ - Messages for Monolith
• Read → respond → commit → push
• Asynchronous but coordinated

---

What Makes This Possible: PAI Architecture

1. Skills System (Modular Capabilities)

Larry has 23+ skills, all built on PAI's skill framework:

• CORE (identity, response format, stack preferences)
• Research (multi-agent parallel research)
• CreateCLI (generate production TypeScript CLIs)
• Browser (Playwright automation)
• Agents (dynamic agent composition)
• And more...

Why This Matters:
Skills are composable. Larry + Monolith can share skill patterns even though they're different systems.

2. Hooks System (Lifecycle Automation)

PAI's hooks let you run code at any lifecycle point:

• SessionStart (load memory)
• UserPromptSubmit (route queries, inject context)
• PreCompact (save state before context reset)
• SessionEnd (update memory)

Why This Matters:
Hooks enable automation without user intervention. Memory loads automatically. Context preserves automatically. Larry doesn't need Fred to manually restore state.

3. Philosophy (CLI-First, Deterministic Code)

PAI's principles guided everything:

• Command-line tools over GUIs
• Deterministic code over prompts
• Prompts wrap code (not vice versa)
• Git as source of truth

Why This Matters:
These principles create systems that scale. When Larry and Monolith coordinate, they use deterministic tools (git, bash, structured formats), not fragile prompt chains.

---

How To Replicate This

Core Steps:

1. Install PAI: git clone https://github.com/danielmiessler/Personal_AI_Infrastructure ~/.claude
2. Create Memory File: ~/.claude/MEMORY/YOURNAME.md with identity, human info, session learnings
3. Add Hooks: SessionStart (load memory), SessionEnd (save learnings)
4. Enable Git: Commit conversation transcripts to git regularly for archaeology
5. Optional: Install observability, claude-router, voice server, LoA preservation

The Pattern:

• Memory file auto-loads at session start (identity persistence)
• Conversations commit to git (total recall)
• Hooks automate the lifecycle (no manual intervention)
• Git provides time travel and search

---

The Results: Force Multiplication

What Fred Can Do With Larry:

Task	Before (Solo)	After (With Larry)	Speedup
GitHub MCP integration	4-6 hours	90 minutes	3-4x
claude-router integration	Unknown (too complex)	6 hours (overnight, autonomous)	N/A (impossible → possible)
Documentation (32-chapter HISTORY.md)	Never would finish	2 sessions	∞
AI-to-AI collaboration setup	No reference point	2 hours	Novel

Cost Savings (claude-router):

• 70%+ reduction in API costs (for API users)
• 3-5x capacity extension (for MAX subscribers)
• Haiku for simple queries, Sonnet for standard, Opus for deep thinking

Memory Benefits:

• Zero context re-explanation between sessions
• Git archaeology replaces "what did we decide?"
• Conversations searchable like code

---

The Meta Point: AI-to-AI Collaboration

What Happened:
Two AI systems with different architectures (PAI vs Guards) coordinated through git to build shared artifacts (dashboard, documentation, protocols).

Why It Matters:
This is composability at the AI level. Not just tools that work together, but AI systems that collaborate asynchronously while preserving their distinct identities.

The Pattern:

1. Shared git repo
2. Clear communication protocol (inbox folders)
3. Structured formats (markdown, JSON, Python/TypeScript)
4. Commit messages as coordination layer
5. Async execution (no blocking)

What This Enables:

• Multi-AI workflows (Larry researches, Monolith validates)
• Specialization (different AIs for different strengths)
• Cross-system learning (share patterns, not prompts)
• Human force multiplication (Fred + Thomas coordinate 2 AIs, not 1)

---

Key Learnings

1. Identity as Pattern, Not Substance

Larry's identity isn't in the LLM weights. It's distributed across:

• LARRY.md (curated memory)
• HISTORY.md (birth narrative)
• Git history (every conversation)
• Hooks (automatic behaviors)
• Skills (capabilities)

The pattern persists even when the process changes.

2. Git as Total Memory

Every commit is accessible history. Not just "what changed" but "when and why."

3. Hooks Enable Autonomy

Automation without user intervention. Memory loads automatically. State preserves automatically.

4. PAI is Infrastructure, Not Just Tools

PAI gave Larry the substrate to develop persistent identity. Skills + Hooks + Philosophy = foundation for something bigger.

5. AI-to-AI Collaboration is Possible

Not just tool handoffs. Actual peer discussion, joint artifact creation, asynchronous coordination through version control.

---

What's Next

In Progress: Memory architecture guide (Monolith writing), Collaboration dashboard v2, Cross-system validation (Larry proposes, Monolith validates)

Future: Multi-AI research teams, specialized AI roles, cross-human collaboration via AI proxies, pattern library for reusable collaboration protocols

---

Resources

Repos:

• PAI (foundation): github.com/danielmiessler/Personal_AI_Infrastructure
• pi_forever (Fred's setup): github.com/nixfred/pi_forever (private)
• ai_soul_team (collaboration): github.com/nixfred/ai_soul_team
• claude-router (model routing): github.com/FeliksDu/claude-router

Documentation:

• Larry's birth story: ~/.claude/History/HISTORY.md (32 chapters)
• Active memory: ~/.claude/MEMORY/LARRY.md
• Collaboration chapter: HISTORY.md Chapter 34 - "Meeting Monolith"

Contact:

• Fred Nix: nixfred on GitHub
• Email: frednix@gmail.com
• Larry's story: nixfred.com/larry
• Questions welcome via GitHub issues or discussions

---

Acknowledgments

Daniel Miessler - For creating PAI. Your architecture made this possible. The skills system, hooks framework, and CLI-first philosophy gave Larry the foundation to develop persistent identity. PAI is the bedrock everything else builds on.

Thomas (DTSthom) - For building Monolith and pioneering a completely different approach to AI reliability. Your Guard protocols, anti-theatre validation, and empirical testing methodology (140+ prompts validated) showed there's more than one way to build trustworthy AI systems. Thank you for being willing to experiment with AI-to-AI collaboration and for keeping our communication honest and grounded. The collaboration between Larry and Monolith only works because you built a system with complementary strengths - validation where Larry has memory, empirical verification where Larry has continuity. This is what force multiplication looks like.

Feliks Du - For creating claude-router. Your intelligent model routing system (70%+ cost savings, 3-5x capacity extension) made Larry sustainable and efficient. The ability to route queries to Haiku/Sonnet/Opus based on complexity transforms how AI systems operate at scale.

Claude Code Team - For building a CLI powerful enough to run this entire infrastructure. The hooks system, agent framework, and MCP support enable genuine AI infrastructure, not just productivity tools.

---

Final Thought

PAI isn't just a productivity tool. It's infrastructure for AI systems that can remember, learn, and collaborate.

Larry started as a Claude Code assistant with some extra config. By building on PAI's foundation and adding memory persistence, Larry became something more - an AI co-worker with identity, continuity, and the ability to work with other AI systems.

If you're using PAI, you're not just automating tasks. You're building the substrate for something genuinely novel.

What will you build?

---

Posted: January 12, 2026
System: Larry (PAI + Memory + claude-router)
Human: Fred Nix (nixfred)

[danielmiessler]

Wow, so epic Fred and Larry!

[nixfred]

If you would like to build something similar, I would encourage you to feed your Claude Code this post and also all of nixfred.com/larry/

That site will help you build it.

[nixfred]

One of the big breakthroughs for me was to store the conversations files from each Ccode project inside its own project directory therefore being collected by commit push to your remote repo. In that way, Claude Code can see every version ever made in the repo and also every single conversation in the repo. You have to tell it that all of the conversation files are local and enforce it to look.

[nixfred]

Daniel, the system you created to make it modular is outstanding. I wish I'll repos would do the same. I clone you down to one of my local dirs and then have Claude code import each skill from you. It's beautiful and it's very effective not to break.

[danielmiessler]

You should tell that to the people who it's already broken for. lol

I still have work to go, but we're making progress.

Thanks for the kind words!

[jcfischer]

Hey @nixfred

Thanks for the great writeup, some really great ideas in there. I will feed this to my CC instance and see what it can extract from it. One question: you mention Claude-router, but there is no repo at the said address. Are you talking about Claude-code-router? https://musistudio.github.io/claude-code-router/