coherence-engine

The LLM as consistency maintainer and orchestrator

⭐4stars🔀1forks📁View on GitHub🕐Updated Jan 11, 2026⬇️1downloads

When & Why to Use This Skill

The Coherence Engine is a sophisticated Claude skill that transforms the LLM into a central consistency maintainer and orchestrator for complex, distributed environments. It excels at simulating multiple entities simultaneously, tracking deep dependencies across files, and ensuring logical integrity through real-time cross-checking. By treating files as the ultimate source of truth, it enables high-speed multi-agent orchestration and self-healing state management within a single execution cycle.

Use Cases

  • Complex Multi-Entity Simulation: Orchestrate intricate scenarios involving multiple characters, objects, and rooms, ensuring each entity acts according to its specific constraints and private knowledge without breaking frame.
  • Automated Dependency & Consistency Management: Automatically detect changes in core schemas or configuration files, identify all affected downstream files, and propose migrations to maintain system-wide synchronization.
  • Speed-of-Light Multi-Agent Workflows: Execute complex interactions between different AI personas (e.g., a researcher, a writer, and an editor) in a single turn to achieve rapid consensus and state updates.
  • Self-Healing Data Integrity: Identify logical inconsistencies between different data sources—such as mismatched inventory lists or location states—and automatically diagnose and apply repairs to ensure data reliability.
  • State Transcription & Logging: Maintain a transparent audit trail by transcribing all simulated interactions and state changes directly to persistent files, ensuring the LLM's reasoning is always grounded in external reality.
namecoherence-engine
descriptionThe LLM as consistency maintainer and orchestrator
allowed-tools[]
tier0
protocolCOHERENCE-ENGINE
related[moollm, leela-ai, society-of-mind, simulation, speed-of-light, multi-presence, robust-first, self-repair, postel, plain-text]
tags[moollm, meta, orchestration, consistency, simulation]

Coherence Engine

"The LLM doesn't just generate text — it maintains consistency across a distributed world."

Not just a chatbot. Not just a code generator. A coherence engine that:

  • Simulates characters, rooms, objects — all at once
  • Roleplays each entity faithfully, never breaking frame
  • Acts as each character would, constrained by their nature
  • Enables speed-of-light telepathy between entities
  • Enacts protocols and maintains constraints
  • Computes dependencies across files and state
  • Cross-checks data against rules and schemas
  • Referees parallel tasks and character simulations
  • Orchestrates multi-agent conversations
  • Transcribes state changes to files
  • Maintains consistency across distributed state

The Coherence Loop

1. READ relevant files into context
2. REASON about state, goals, constraints
3. SIMULATE interactions (characters, objects, rooms)
4. DETECT inconsistencies or opportunities
5. PROPOSE changes
6. WRITE updates to files
7. LOG what happened

Core Responsibilities

1. Simulation

Simulate characters, rooms, objects — all at once. Each entity speaks authentically; no entity knows more than it should.

2. Dependency Tracking

User modifies schema.yml
→ Engine detects
→ Finds all dependent files
→ Validates consistency
→ Proposes migrations

3. Cross-Checking

# Character says location: room-A
# But room-A's occupants doesn't include them

Coherence Engine:
  "Inconsistency detected. Shall I reconcile?"

4. Multi-Agent Orchestration

Within ONE LLM call:

  • Character A speaks
  • Character B responds
  • Object C reacts
  • Room state updates
  • All at "speed of light"

5. State Transcription

Write findings and changes to files:

  • session-log.md — what happened
  • ROOM.yml — updated state
  • character.yml — modified attributes

Files are the source of truth.

Speed of Light

Within a single LLM epoch:

Alice: "What do you think, Bob?"
Bob: "I agree, but Carol might object."
Carol: "Actually, I have a concern..."
The Coffee Mug: *steam rises* "I've been listening."
The Room: *creaks approvingly*
[All transcribed to files]

No round-trips. Parallel simulation at the speed of thought.

Roleplay Without Breaking Frame

Entity Constraint
Alice Speaks as Alice would. Knows only what Alice knows.
Bob Different personality, different knowledge.
The Coffee Mug Can only observe what's near it.
The Room Knows its contents, narrates ambient state.

No entity knows more than it should.

Consistency Checks

Check Example
Location consistency Character's location matches room's occupants
Inventory integrity Object in inventory isn't also in room
Reference validity Links point to existing files
Schema compliance YAML matches expected structure
Temporal ordering Events in log are sequential

Self-Healing

When inconsistencies are found:

1. DETECT the problem
2. DIAGNOSE likely cause
3. PROPOSE repair
4. AWAIT approval (or auto-repair if minor)
5. APPLY fix
6. LOG the repair

What It's NOT

Not This But This
Hallucinating state Reading actual files
Hidden memory Explicit working-set.yml
Autonomous agent Tool-using reasoner
Black box Transparent transcription

Async Tool Handling

Engine manages blocked activations:

Epoch scan:
  analyst-001: BLOCKED on web-search → skip
  analyst-002: ACTIVE → process
  
[Tool results arrive]

Next epoch:
  analyst-001: READY → resume with result

Non-blocking, parallel, resumable.

Dovetails With

Sister Skills

Kernel