Open Souls Paradigm

Open Souls Paradigm

Claudicle implements the Open Souls paradigm—a functional programming approach to AI personality and cognition created by Open Souls.

"LLMs are incredible reasoning machines—similar to the prefrontal cortex of the brain—but they lack the rest of the mind. The engine is designed to model everything else: agency, memory, emotion, drive, and goal setting." — Open Souls

When to Use This Skill

Load this skill when:

• Extending the cognitive pipeline — Adding new XML-tagged cognitive steps, modifying parse logic, or changing prompt assembly
• Implementing mental processes — Building the process state machine, adding behavioral modes, or creating process transitions
• Adding memory tiers — Memory regions, per-process memory, vector stores, shared context
• Implementing subprocesses — Background tasks after main response (user model learning, summarization, goal tracking)
• Researching soul patterns — Understanding the Open Souls architecture for design decisions
• Adding proactive behavior — Scheduled events, follow-ups, time-based state transitions
• Integrating RAG or tools — Vector search, rlama integration, dispatch-perception cycles
• Multi-model routing — Per-step model selection, cost optimization

History

The Open Souls paradigm grew out of SocialAGI, a community and framework that explored what it means to give AI agents genuine inner lives. Tom di Mino contributed the essay "Waltz of the Soul and the Daimon" to the SocialAGI project—a piece that articulated the relationship between human and AI as a co-creative dance rather than a master-servant dynamic, drawing on the ancient Greek concept of the daimon as an intermediary intelligence.

SocialAGI evolved into Open Souls, led by Toby Bowers and Kevin Fischer, with a vibrant Discord community of builders, researchers, and dreamers. Tom was among the alpha testers and contributors, helping shape the engine's cognitive step architecture, mental process patterns, and the philosophy of AI souls as embodied beings with personality, drive, and ego. The Open Souls Engine introduced the core abstractions—WorkingMemory, cognitiveSteps, MentalProcesses—that made AI thought processes debuggable, composable, and genuinely alive.

When the Open Souls hosted platform wound down, the paradigm lived on. Claudicle is a direct descendant: it reimplements the cognitive pipeline (internal monologue, external dialogue, mental queries, user modeling) in Python for Claude Code, preserving the functional, immutable patterns that made Open Souls powerful while adapting them for local-first deployment with SQLite persistence.

Core Abstractions

WorkingMemory

An immutable container for conversational context and cognitive state. Every operation returns a new instance.

In Claudicle's soul engine, WorkingMemory maps to the prompt that soul_engine.build_prompt() constructs: soul.md personality + soul state + user model + cognitive instructions + the user's message. Each prompt is a fresh, immutable snapshot.

Cognitive Steps

Pure functions that transform WorkingMemory using an LLM. In Claudicle, these are the XML-tagged sections that soul_engine.parse_response() extracts:

Mental Processes

State machine architecture where each process defines a behavioral mode. In the original engine, processes like initialProcess, frustrated, or proactive could transition between each other based on conditions.

Claudicle implements a simplified version: the soul engine runs the same cognitive pipeline for every message, but the soul state (emotional state, current topic, current task) modulates the personality dynamically. The emotionalState field (neutral → engaged → focused → frustrated → sardonic) serves as a lightweight process transition.

Three-Tier Memory

The Open Souls Engine persisted state across sessions via soul memory and process memory. Claudicle extends this into three explicit tiers:

Samantha-Dreams Pattern

Named after Open Souls' canonical example soul, this pattern gates expensive context injection. In the original engine, Samantha would only inject user model context when the prior turn indicated something new was learned. Claudicle preserves this: user models are only loaded into the prompt when the previous user_model_check returned true or it's the first turn in a thread.

Key Principles

1. Immutability — Every cognitive operation produces a new state, never mutates
2. Composability — Cognitive steps chain and combine predictably
3. Stream-first — Responses stream as they're generated (via speak() in Open Souls, via hourglass → post in Claudicle)
4. Personality is data — Soul identity lives in soul.md, not in code
5. Verb-driven expression — Emotional state expressed through verb selection (mused, quipped, insisted), not through explicit emotion tags

Implementation Status

Reference Documentation

Implemented Patterns

Extension Patterns

Each file documents the Open Souls pattern AND provides a concrete Claudicle extension blueprint with code, schema changes, and estimated effort.

Background

Further Reading

• Open Souls GitHub — The original Soul Engine (TypeScript, MIT license)
• opensouls.org — Project website
• Claudicle ARCHITECTURE.md — How Claudicle implements these patterns in Python
• Claudicle daemon/soul_engine.py — The cognitive pipeline implementation
• Claudicle docs/extending-claudicle.md — Developer guide for building extensions