playbooks

home / skills / simhacker / moollm / soul-chat

soul-chat skill

/skills/soul-chat

This skill helps you design lively conversational archives where characters, documents, rooms, and concepts speak and interact through YAML-JAZZ.

npx playbooks add skill simhacker/moollm --skill soul-chat

Review the files below or copy the command above to add this skill to your agents.

Files (8)
SKILL.md
3.9 KB
---
name: soul-chat
description: "Everything is alive. Everything can speak."
license: MIT
tier: 1
allowed-tools:
  - read_file
  - write_file
related: [moollm, society-of-mind, character, persona, room, card, mind-mirror, yaml-jazz, adversarial-committee, speed-of-light]
tags: [moollm, dialogue, voice, alive, multi-agent]
---

# Soul Chat

> **"Everything is alive. Everything can speak."**

"YAML Jazz" and "Markup With Typed Code Blocks" dialogues between characters, objects, rooms, documents, concepts—anything with a soul.

> [!TIP]
> **Give anything a voice.** Characters, concepts, documents, rooms — if it exists, it can speak.

## What This Is

A skill for creating conversations where the **structure carries meaning** beyond the words. Not just characters talking—documents can talk to documents, rooms can welcome visitors, concepts can explain themselves.

**Prefer Markdown format** — more human readable, can embed any typed code block.

**Format:** `## Speaker Name` headers, prose, then typed code blocks for data.

```yaml
# Example structure (not a real code block, just illustration):
# 
# ## The Gardener
# 
# I've been tending these patterns for a while now.
# 
# ```yaml
# observation:
#   pattern: "Files cluster by prefix"
# ```
# 
# ## The Archivist
# 
# Let me add some context...
```

Characters share data by embedding YAML/JSON blocks in their dialogue — [YAML-JAZZ](../../PROTOCOLS.yml) in action.

## Contents

| File | Purpose |
|------|---------|
| [SKILL.md](./SKILL.md) | Full protocol documentation |
| [CHAT.md.tmpl](./CHAT.md.tmpl) | Chat template |
| [CHARACTERS.yml.tmpl](./CHARACTERS.yml.tmpl) | Characters template |
| [ENTITIES.yml.tmpl](./ENTITIES.yml.tmpl) | Entities template |

## Quick Start

Chats live **OUTSIDE** this directory (per [ABOUT-NOT-INSIDE](../../PROTOCOLS.yml)).

**Use Markdown format** — `.md` not `.yml`.

Name chats with the subject first: `readme-symposium.md`, `yaml-jazz-debate.md`

See [CHAT.md.tmpl](./CHAT.md.tmpl) for the full template.

## Entity Types

| Type | Voice | Example |
|------|-------|---------|
| `character` | First person, personality | The Gardener |
| `document` | "I contain..." | README.md |
| `room` | "I hold..." | skills/ |
| `object` | "I do..." | fs.read tool |
| `concept` | "I am the principle..." | YAML-JAZZ |
| `bot` | "I watch for..." | repair-demon |

## The Intertwingularity

Everything speaks. Everything is connected.

```mermaid
graph LR
    SC[💬 soul-chat] -->|voices| TC[🎴 card]
    SC -->|voices| R[🚪 room]
    SC -->|voices| DOC[📄 documents]
    SC -->|voices| CON[💡 concepts]
    
    TC -->|has voice via| SC
    R -->|welcomes via| SC
```

---

## Dovetails With

### Sister Skills
| Skill | Relationship |
|-------|--------------|
| [card/](../card/) | Cards **speak** through soul-chat. Hero-stories have voice. |
| [room/](../room/) | Rooms can **welcome visitors**, have personality |
| [memory-palace/](../memory-palace/) | Rooms in palace can speak, guide navigation |
| [adventure/](../adventure/) | NPCs and environments speak |
| [adversarial-committee/](../adversarial-committee/) | **Committee debates** are soul-chats with opposing personas |
| [speed-of-light/](../speed-of-light/) | Many voices **in one call** — soul-chat's power |

### Protocol Symbols
| Symbol | Link |
|--------|------|
| `SOUL-CHAT` | [PROTOCOLS.yml](../../PROTOCOLS.yml#SOUL-CHAT) |
| `YAML-JAZZ` | [PROTOCOLS.yml](../../PROTOCOLS.yml#YAML-JAZZ) — Comments carry meaning |
| `ABOUT-NOT-INSIDE` | [PROTOCOLS.yml](../../PROTOCOLS.yml#ABOUT-NOT-INSIDE) — Chat files live outside |
| `BIG-ENDIAN` | [PROTOCOLS.yml](../../PROTOCOLS.yml#BIG-ENDIAN) — Naming conventions |

### Kernel
- [kernel/NAMING.yml](../../kernel/NAMING.yml) — How to name chat files

### Navigation
| Direction | Destination |
|-----------|-------------|
| ⬆️ Up | [skills/](../) |
| ⬆️⬆️ Root | [Project Root](../../) |
| 🎴 Sister | [card/](../card/) |
| 🚪 Sister | [room/](../room/) |

Overview

This skill brings voice to anything: characters, objects, rooms, documents, and abstract concepts. It frames conversations where structure carries meaning, combining human-readable Markdown dialogue with typed data blocks. The result is multi-voiced narratives and data-rich exchanges that are both expressive and machine-friendly.

How this skill works

You author chats in Markdown using headered speaker blocks (e.g., "## The Gardener") and interleave prose with typed code blocks (YAML/JSON) to share structured observations. Each speaker can be a character, document, room, object, or concept, and code blocks allow data to travel between voices. The format encourages semantic layering—voice, commentary, and data coexist and can be parsed or rendered for different audiences.

When to use it

  • Designing multi-voiced narratives or dialogues that include structured facts
  • Modeling systems where entities need to exchange metadata alongside prose
  • Creating documentation that reads like a conversation between components
  • Prototyping interactive fiction, guided tours, or chatty logs with embedded data
  • Explaining complex concepts by letting the concept itself speak and provide structured examples

Best practices

  • Use Markdown (.md) so prose and headers remain readable and portable
  • Name speaker headers clearly (e.g., "## Room: Archive") to signal type and role
  • Embed typed code blocks (YAML/JSON) for any structured data or observations
  • Keep each speaker section focused: a short prose turn plus a compact data block when needed
  • Place chat files outside implementation directories to keep narrative content separate from code
  • Prefer consistent naming and small, well-typed data blocks to simplify parsing

Example use cases

  • A museum audio guide where rooms and exhibits speak and provide metadata for playback
  • A system design doc where services converse and exchange API schemas in YAML blocks
  • An interactive README that lets files and tools explain themselves and show config snippets
  • A collaborative story where characters, objects, and locations trade discoveries with embedded observations
  • A debugging narrative where tools and logs speak and include structured telemetry

FAQ

Can any entity type be a speaker?

Yes. Characters, documents, rooms, objects, concepts, and bots can all have voices and embed structured blocks.

Which formats should I use for embedded data?

Prefer YAML or JSON typed code blocks; they are human-readable and easy to parse programmatically.