blitz-molt

Extensions for Moltbot that add autonomous multi-agent orchestration and real-time voice interaction. Part of the Blitz ecosystem.

Extensions

Fleet — Multi-Agent Task Orchestration

An autonomous orchestration engine that breaks high-level goals into task DAGs, executes them through AI agents, validates results, and recovers from failures — all without human intervention.

┌─────────────────────────────────────────────────────────────┐
│                        Goal Queue                           │
│              "Add OAuth2 + refresh tokens"                  │
└──────────────────────┬──────────────────────────────────────┘
                       │
                       ▼
              ┌────────────────┐
              │    Planner     │  LLM decomposes goal → task DAG
              │  (Claude/GPT)  │  with dependencies, validations,
              └───────┬────────┘  and priority levels
                      │
                      ▼
              ┌────────────────┐
              │  Task Router   │  Priority queue + circuit breaker
              │                │  (global + per-project)
              └───────┬────────┘
                      │
          ┌───────────┼───────────┐
          ▼           ▼           ▼
     ┌─────────┐ ┌─────────┐ ┌─────────┐
     │ Task 1  │ │ Task 2  │ │ Task 3  │  Dependency-aware
     │(no deps)│ │(← T1)   │ │(← T1,T2)│  topological execution
     └────┬────┘ └────┬────┘ └────┬────┘
          │           │           │
          ▼           ▼           ▼
     ┌─────────────────────────────────┐
     │       Validation Engine         │  build, test, typecheck,
     │                                 │  lint, file_exists, custom
     └────────────┬────────────────────┘
                  │
            ┌─────┴─────┐
            │           │
          pass        fail
            │           │
            ▼           ▼
      checkpoint   ┌──────────┐
      (git commit) │ Recovery │  LLM analyzes failure context,
                   │ Planner  │  generates recovery tasks,
                   └──────┬───┘  injects into plan
                          │
                          ▼
                   retry with new tasks

Key patterns:

• Circuit breaker (global + per-project) — opens after N consecutive failures, auto-resets after cooldown. Prevents cascade failures across the fleet.
• Task DAG with deadlock detection — topological ordering with dependency resolution. Detects and skips blocked tasks when all remaining tasks are deadlocked.
• Git-based checkpointing — commits after each successful task for rollback capability. Creates feature branches, auto-opens PRs with formatted body on completion.
• LLM-driven failure recovery — on task failure, gathers error context + modified file contents, sends to planner for root cause analysis and recovery task generation.
• Dual backend support — routes tasks to either an embedded AI agent runtime or Claude Code CLI.

Voice Chat — Real-Time Voice Conversations

Browser-based voice interface with local STT (Whisper) and TTS (Kokoro) processing. Client-side VAD, WebSocket audio streaming, and AI responses routed through the agent runtime.

Browser ──PCM──▶ WebSocket Server ──▶ STT (Whisper) ──▶ LLM ──▶ TTS (Kokoro) ──PCM──▶ Browser
         binary     :3099          POST /v1/audio     Agent    POST /v1/audio      binary
         frames                    /transcriptions    Runtime  /speech              frames

Self-contained HTML client served directly from the WebSocket server — no external UI dependencies.

Structure

extensions/
├── fleet/
│   ├── src/
│   │   ├── types.ts              # Full type system (tasks, plans, circuit breaker, events)
│   │   ├── planner.ts            # LLM-driven goal → task DAG decomposition
│   │   ├── conductor.ts          # Orchestration loop with checkpointing and recovery
│   │   ├── task-router.ts        # Priority queue + circuit breaker
│   │   ├── validation-engine.ts  # Build/test/typecheck/lint validation
│   │   ├── agent-bridge.ts       # Dual backend (Pi agent / Claude Code CLI)
│   │   ├── state.ts              # Persistent project state (~/.moltbot/fleet/)
│   │   ├── events.ts             # Typed event bus (22 event types)
│   │   ├── project-manager.ts    # Multi-project lifecycle management
│   │   ├── gateway-methods.ts    # API endpoints (dashboard, projects, circuit breaker)
│   │   └── cli.ts                # CLI commands (status, register, start, pause, resume, stop)
│   └── index.ts
└── voice-chat/
    ├── src/
    │   ├── types.ts              # Session, config, message types
    │   ├── ws-server.ts          # WebSocket server with binary PCM + JSON control
    │   ├── session.ts            # Session lifecycle management
    │   ├── stt-client.ts         # OpenAI-compatible STT (Whisper)
    │   ├── tts-client.ts         # OpenAI-compatible TTS (Kokoro)
    │   ├── agent-bridge.ts       # LLM routing through agent runtime
    │   ├── audio-utils.ts        # PCM audio utilities
    │   ├── config.ts             # Configuration resolution
    │   ├── gateway-methods.ts    # Status and config API
    │   └── client.html           # Self-contained voice UI with client-side VAD
    └── index.ts

Setup

# Clone into your Moltbot extensions directory
cd /path/to/moltbot
ln -s /path/to/blitz-molt/extensions/fleet extensions/fleet
ln -s /path/to/blitz-molt/extensions/voice-chat extensions/voice-chat

# Install dependencies
cd /path/to/blitz-molt
pnpm install

Extensions are loaded automatically by Moltbot's plugin system (jiti) on startup.

Tech

TypeScript, pnpm workspaces. Extensions register gateway methods, CLI commands, and lifecycle hooks through the Moltbot plugin API.

Related

• blitz — The full orchestration platform (server, dashboard, CLI, workers)
• blitzcli.com — Landing page with architecture diagrams and screenshots