playbooks

home / skills / simhacker / moollm / protocol

protocol skill

/skills/protocol

This skill activates named protocols to compress knowledge into reusable patterns, enabling faster reasoning and consistent behavior across tasks.

npx playbooks add skill simhacker/moollm --skill protocol

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

Files (5)
SKILL.md
5.0 KB
---
name: protocol
description: "K-lines as semantic activation — the name activates the tradition."
license: MIT
tier: 0
allowed-tools:
  - read_file
related: [k-lines, naming, skill, bootstrap, yaml-jazz]
tags: [moollm, meta, naming, k-line, minsky, semantic]
credits:
  - "Marvin Minsky — K-lines, Society of Mind (1986)"
---

# PROTOCOL

> **"The name activates the tradition."**

K-lines as semantic activation. When you invoke a protocol by name, you activate an entire constellation of knowledge and behavior.

---

## Core Concept

A **protocol** is a named pattern that the LLM already knows. Invoking it by name activates that knowledge without needing to repeat it.

### Why This Works

```yaml
# Traditional approach: Explain everything
"When writing YAML, use natural keys, add comments for humans and LLMs,
keep structure flexible, use semantic naming, allow improvisation..."
# [500 tokens of explanation]

# K-line approach: Name activates pattern
> Apply YAML-JAZZ

# The LLM already knows. One name = 500 tokens compressed.
```

### Minsky's Insight

> "A K-line is a wirelike structure that attaches itself to whichever mental agents are active when you solve a problem. When activated later, those agents are partially activated, creating a similar mental state."
> — Marvin Minsky, *Society of Mind* (1986)

**MOOLLM protocols ARE K-lines.** The name IS the activation vector.

---

## Methods

### INVOKE

Activate a protocol by name.

```yaml
> INVOKE POSTEL
# Activates: "Be liberal in what you accept, conservative in what you emit"
# Plus: ASK when uncertain, robustness principles, defensive parsing
```

### DEFINE

Create a new protocol.

```yaml
> DEFINE WAFFLE-PARTY AS "Celebratory gathering requiring Form WP-7"
# Now WAFFLE-PARTY is a K-line that activates this context
```

### LIST

Show available protocols.

```yaml
> LIST PROTOCOLS
ADVENTURE, BOOTSTRAP, INCARNATION, POSTEL, PSIBER,
SPEED-OF-LIGHT, YAML-JAZZ, ...
```

### K-REF

Emit a file pointer with metadata.

```yaml
Format: PATH[:LINE[-END]][#anchor][?search] # TYPE - DESC

Examples:
/path/file.txt:42 # secret 🔴
/path/screenshot.png # image - Cursor can read!
/path/schema.yml#field.name # k-line
@central/apps/insights/brain/Schema.py:142-200 # code - Schema class
```

---

## K-REF Format

Full syntax:
```
PATH[:LINE[-END]][#anchor][?search] # TYPE - DESC
```

| Component | Purpose | Example |
|-----------|---------|---------|
| `PATH` | File location | `/path/file.yml` |
| `:LINE` | Specific line | `:42` |
| `[-END]` | Line range | `:42-67` |
| `#anchor` | YAML path / section | `#field.name` |
| `?search` | Search term | `?error` |
| `# TYPE` | Content type | `# secret`, `# image` |
| `- DESC` | Description | `- The Schema class` |

**Special types:**
- `# secret 🔴` — Sensitive content
- `# image` — Cursor can read images from absolute paths!
- `# k-line` — Semantic activation point
- `# code` — Source code reference

---

## SISTER-SCRIPT Pattern

Tools emit K-REFs, LLM reads selectively.

### The Pattern

```python
# Tool (Python/shell) runs and emits:
print("/logs/2026-01-28.log:147 # error - Database timeout")
print("/logs/2026-01-28.log:892 # error - Memory exhausted")
print("/logs/2026-01-28.log:1203 # warning - Slow query")
print("/config/db.yml # config - Database settings")
```

### LLM Behavior

1. Scans the K-REF list
2. Decides which to read based on task
3. Reads only relevant files/sections
4. Avoids loading everything

**Key insight:** Scan and point, not dump.

---

## Core Protocols

| Protocol | Activates |
|----------|-----------|
| `ADVENTURE` | Text adventure patterns, room navigation |
| `YAML-JAZZ` | Flexible YAML with semantic comments |
| `BOOTSTRAP` | Session startup, context assembly |
| `PSIBER` | Data as navigable room (HyperCard heritage) |
| `POSTEL` | Liberal accept, conservative emit, ASK |
| `INCARNATION` | Gold-standard character creation |
| `SPEED-OF-LIGHT` | Many turns in one LLM call |
| `HERO-STORY` | Safe real-person references |
| `TREKIFICATION` | Privacy masking protocol |

---

## Protocol Activation Cascade

When you invoke a protocol, related concepts activate:

```yaml
> INVOKE YAML-JAZZ

# Activates:
- yaml-jazz/SKILL.md content
- Related: POSTEL (be liberal), plain-text (forever accessible)
- Patterns: Semantic comments, natural keys, improvisational structure
- Anti-patterns: Cryptic keys, missing comments, rigid schemas
- Emotional tone: Jazzy, playful, improvisational
```

This is why K-lines are so powerful — one name activates a **network** of knowledge.

---

## Why Tier 0

This skill is **tier 0** because:
- It's foundational to all other skills
- Every skill name IS a protocol
- Understanding K-lines is essential to understanding MOOLLM

---

## Dovetails With

- [../k-lines/](../k-lines/) — Naming conventions and K-line formatting
- [../naming/](../naming/) — Big-endian semantic file naming
- [../skill/](../skill/) — Skills are invokable protocols
- [../bootstrap/](../bootstrap/) — Session startup protocol
- [../yaml-jazz/](../yaml-jazz/) — The YAML-JAZZ protocol

---

*"Speak the name. Become the pattern."*

Overview

This skill exposes the protocol concept: named semantic activations (K-lines) that compress and recall rich patterns of behavior and knowledge. Invoke a protocol name to activate a constellation of conventions, parsing rules, tones, and actions without re-specifying them. It treats names as lightweight activation vectors to shape LLM behavior and tool interaction.

How this skill works

Protocols are predefined names mapped to a set of behaviors, heuristics, and context cues. Use INVOKE to activate a protocol, DEFINE to create one, LIST to enumerate available protocols, and K-REF to point to specific files/sections for selective reading. Tools can emit K-REF lists; the LLM scans those refs and reads only the relevant fragments to avoid loading everything.

When to use it

  • Apply a well-known pattern quickly without re-explaining its rules (e.g., YAML-JAZZ).
  • Create repeatable, shareable behavior for teams or multi-step systems.
  • Guide LLMs to adopt tone, parsing rules, or defensive heuristics (e.g., POSTEL).
  • Coordinate tool outputs and LLM reading via K-REF lists for efficient context loading.
  • Mask or transform data flows using privacy or formatting protocols (e.g., TREKIFICATION).

Best practices

  • Name protocols with clear, evocative labels that map to stable conventions.
  • Keep protocol definitions focused: intent, key heuristics, examples, and anti-patterns.
  • Emit K-REFs from tools instead of dumping files; let the LLM decide what to read.
  • Layer protocols: invoke base-level ones (BOOTSTRAP, POSTEL) before task-specific ones.
  • Document sensitive types in K-REFs (use # secret) to signal careful handling.

Example use cases

  • Invoke YAML-JAZZ to author flexible YAML with semantic comments and human-friendly keys.
  • Use POSTEL when ingesting messy input to favor robust parsing and explicit ASK prompts.
  • Run a tool that prints K-REFs; have the LLM scan and open only the K-REFs relevant to an incident.
  • Define INCARNATION to generate consistent character sheets or role-play profiles.
  • List protocols at session start (BOOTSTRAP) to assemble context quickly across turns.

FAQ

How do K-REFs help efficiency?

K-REFs let tools point to precise file paths, line ranges, anchors, and search terms so the LLM can selectively load only the needed content instead of full dumps.

Can I create custom protocols?

Yes. Use DEFINE to register a new protocol name and its activation description so future INVOKE calls activate that behavior.