Grand Diomande Research · Full HTML Reader

Message Orchestrator v1 — Hybrid Routing Intelligence

> _"Every message is a signal. Some are commands, some are dreams, some are the start of something bigger. This skill listens to all of them."_

Agents That Account for Themselves research note experiment writeup candidate score 30 .md

Full Public Reader

---
name: message-orchestrator
description: Hybrid config + LLM-driven message routing. Intercepts all messages, enriches via prompt-synthesizer, extracts dream seeds, detects skill chains, and routes actionable tasks.
homepage: https://github.com/clawdbot/message-orchestrator
user-invocable: true
pre-hook: true
hook-priority: 50
command-dispatch: orchestrate
handler: orchestrator.MessageOrchestrator
metadata.clawdbot: {"pre_hook": true, "transforms_input": true, "routing": true, "version": "1.0.0"}
---

Message Orchestrator v1 — Hybrid Routing Intelligence

> _"Every message is a signal. Some are commands, some are dreams, some are the start of something bigger. This skill listens to all of them."_

Message Orchestrator sits at the heart of the Clawdbot message pipeline, intercepting every input and making intelligent routing decisions. It combines config-driven rules (fast, predictable) with LLM orchestration (flexible, semantic).

Philosophy

Hybrid Intelligence:
- Config Layer: Fast pattern matching, predefined chains, zero-latency routing
- LLM Layer: Semantic understanding, ambiguous cases, chain synthesis

No Message Left Behind:
- Every message gets at least prompt enrichment
- Dream seeds are captured even from casual conversation
- Skill chains execute automatically when patterns match

Architecture

┌─────────────────────────────────────────────────────────────┐
│                    INCOMING MESSAGE                          │
└─────────────────────────────────────────────────────────────┘
                              │
                              ▼
┌─────────────────────────────────────────────────────────────┐
│              1. PROMPT SYNTHESIZER (pre-enrichment)          │
│  - Context injection from ledger                             │
│  - Intent clarification                                      │
│  - Skill activation hints                                    │
└─────────────────────────────────────────────────────────────┘
                              │
                              ▼
┌─────────────────────────────────────────────────────────────┐
│              2. EXTRACTORS (parallel analysis)               │
│  ┌────────────┐  ┌────────────┐  ┌────────────────────┐     │
│  │Dream Seeds │  │Intent/Task │  │Chain Triggers      │     │
│  │Extraction  │  │Detection   │  │Pattern Match       │     │
│  └────────────┘  └────────────┘  └────────────────────┘     │
└─────────────────────────────────────────────────────────────┘
                              │
                              ▼
┌─────────────────────────────────────────────────────────────┐
│              3. ROUTING DECISION                             │
│  Priority:                                                   │
│  1. Explicit commands (bypass orchestration)                 │
│  2. Config-matched chains (fast execution)                   │
│  3. LLM-suggested routes (semantic analysis)                 │
│  4. Default enrichment (fallback)                            │
└─────────────────────────────────────────────────────────────┘
                              │
              ┌───────────────┼───────────────┐
              ▼               ▼               ▼
       ┌──────────┐    ┌──────────┐    ┌──────────┐
       │ Dream    │    │ Skill    │    │ Direct   │
       │ Weaver   │    │ Chain    │    │ Response │
       └──────────┘    └──────────┘    └──────────┘

Skill Chains

Skill chains are sequences of skills that execute in order, passing output to input. Defined in `chains.json`:

Predefined Chains

#### creative-evolution
Trigger: "evolve", "iterate", "creative exploration", "what if we..."

evoflow → lin:target → art:synthesis

Takes an idea, runs evolutionary iterations, targets linguistic style, synthesizes into creative output.

#### research-to-action
Trigger: "research then build", "investigate and implement", "deep dive into..."

sys:research → art:synthesis → governance-framework

Deep research, synthesize findings, establish governance for implementation.

#### voice-to-dream
Trigger: Voice transcription detected, dream-like language, "I had an idea..."

prompt-synthesizer → extract → dream-weaver

Enriches raw voice/thought, extracts dream seeds, plants in Dream Weaver.

Custom Chains

Define your own chains in `chains.json`:

json

{
  "chains": {
    "my-custom-chain": {
      "name": "My Custom Chain",
      "description": "What this chain does",
      "triggers": {
        "patterns": ["my trigger", "another trigger"],
        "intents": ["build", "create"],
        "semantic": "when user wants to build something custom"
      },
      "steps": [
        {"skill": "skill-name-1", "config": {}},
        {"skill": "skill-name-2", "config": {"option": "value"}},
        {"skill": "skill-name-3"}
      ],
      "output_mode": "final_only"
    }
  }
}

Extractors

Dream Seed Extractor

Identifies nascent ideas worth incubating:

Signal	Weight	Example
Future tense ideation	0.8	"I want to build...", "We should..."
Hypothetical exploration	0.7	"What if...", "Imagine..."
Problem statement	0.6	"The issue is...", "I keep running into..."
Excitement markers	0.5	"!", enthusiasm words, emoji
Connection language	0.4	"This reminds me of...", "Like..."

Threshold: Seeds with combined weight ≥ 1.0 are extracted.

Intent Extractor

Classifies message intent:

Intent	Patterns
`build`	create, make, implement, develop, build
`ship`	deploy, launch, release, publish
`research`	investigate, explore, understand, learn
`connect`	integrate, link, bridge, combine
`automate`	schedule, cron, recurring, automatic
`fix`	bug, broken, error, issue, problem
`creative`	imagine, design, artistic, style
`analyze`	review, assess, evaluate, compare

Chain Trigger Detector

Matches against defined chain triggers (patterns + semantic).

Commands

Command	Description
`/orchestrate status`	Show orchestrator status and stats
`/orchestrate chains`	List available skill chains
`/orchestrate chain <name>`	View chain details
`/orchestrate run <chain> [input]`	Manually run a chain
`/orchestrate extract <text>`	Test extraction on text
`/orchestrate config`	View current config
`/orchestrate config <key> <value>`	Update config
`/orchestrate history`	Recent routing decisions
`/orchestrate learn`	Show learned patterns

Configuration

In `config.yaml`:

yaml

orchestrator:
  enabled: true

  # Extraction settings
  extraction:
    dream_seed_threshold: 1.0
    intent_confidence_threshold: 0.6
    chain_trigger_threshold: 0.7

  # Routing priorities
  routing:
    explicit_commands_bypass: true  # /commands skip orchestration
    config_chains_priority: true    # Try config chains before LLM
    llm_fallback: true              # Use LLM for ambiguous cases
    llm_model: "default"            # Model for LLM routing

  # Dream Weaver integration
  dream_routing:
    auto_incubate: true             # Auto-plant extracted seeds
    min_seed_weight: 1.0
    notify_on_plant: false

  # Skill chain settings
  chains:
    timeout_per_step_ms: 30000
    fail_fast: false                # Continue chain on step failure
    output_mode: "final_only"       # or "all_steps"

  # Bypass patterns (never orchestrate these)
  bypass:
    - "^/[a-z]+"                    # All slash commands
    - "^HEARTBEAT"                  # Heartbeat messages
    - "^\\[System"                  # System messages

LLM Orchestration Mode

When config-matching fails, the orchestrator asks the LLM:

Given this message and available skill chains, suggest:
1. Should a chain be triggered? Which one?
2. Is there a dream seed worth extracting?
3. What's the primary intent?
4. Any other routing suggestions?

Message: "{user_message}"
Available Chains: {chain_names}
Recent Context: {last_3_messages}

The LLM response is parsed and executed. This enables handling of:
- Novel phrasings not in config
- Multi-intent messages
- Complex contextual triggers
- Emergent chain needs

Dream Weaver Integration

When dream seeds are detected:

1. Extract — Pull the seed text and metadata
2. Enrich — Add context from current conversation
3. Route — Send to Dream Weaver's `/incubate`
4. Track — Log the routing decision

python

# Automatic incubation
if seed.weight >= config.min_seed_weight:
    dream_weaver.incubate(
        spore=seed.text,
        keywords=seed.extracted_keywords,
        source="orchestrator",
        context=current_context
    )

Example Flow

User sends voice message:

"I was thinking about maybe building something that
combines the calendar with the todo list, like smart
scheduling that knows what tasks need focus time..."

Orchestrator Processing:

1. Prompt Synthesizer:

Enriched with recent calendar/todo discussion context

2. Extractors:

Dream Seeds:
  - "smart scheduling that knows what tasks need focus time" (1.2)

Intents:
  - build (0.9)
  - connect (0.8)

Chain Triggers:
  - voice-to-dream (0.95)

3. Routing Decision:

1. Execute voice-to-dream chain
2. Route dream seed to Dream Weaver
3. Return enriched prompt to main agent

4. Result:
- Dream seed planted: `dream_20260208_smart_scheduling`
- Chain executed: prompt-synthesizer → extract → dream-weaver
- User gets confirmation

Files

File	Size	Description
`SKILL.md`	-	This documentation
`orchestrator.py`	~20KB	Main routing logic & handler
`chains.json`	~5KB	Predefined skill chains
`extractors.py`	~15KB	Dream/intent/chain extractors
`config.yaml`	~2KB	Default configuration

Data Storage

File	Description
`[home-path]`	Recent routing decisions
`[home-path]`	LLM-discovered patterns
`[home-path]`	Chain execution logs
`[home-path]`	Usage statistics

Philosophy

> Message-First Thinking: Every message is an opportunity — to learn, to create, to connect. The orchestrator ensures nothing valuable slips through.

> Hybrid Intelligence: Config for speed, LLM for nuance. The best of both worlds.

> Dream Capture: Ideas float by in conversation. This skill catches them before they disappear.

---

_Version 1.0.0 — Hybrid routing intelligence for the Clawdbot ecosystem_ 🎼

Promotion Decision

Attach run IDs, datasets, metrics, and reproduction commands.

Source Anchor

homelab/clawdbot/skills/message-orchestrator/SKILL.md

Detected Structure

Method · Evaluation · Math · Code Anchors · Architecture